Attachment #223499 for bug #394179

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * 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 org.eclipse.jubula.rc.common.implclasses.MatchUtil;
import org.eclipse.jubula.rc.common.implclasses.Verifier;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IButtonAdapter;


/**
 * Implementation for all Button like classes, it holds the
 * general methods for the testing of buttons.
 * 
 * @author BREDEX GmbH
 *
 */
public abstract class AbstractButtonCAPs extends AbstractWidgetCAPs {

    /**
     * Action to read the value of a JButton to store it in a variable in the
     * Client
     * 
     * @param variable the name of the variable
     * @return the text value.
     */
    public String gdReadValue(String variable) {
        return ((IButtonAdapter) this.getComponent()).getText();
    }
    /**
     * 
     * @return the IButtonAdapter for the component. 
     */
    private IButtonAdapter getButtonAdapter() {
        return (IButtonAdapter)getComponent();
    }

    /**
     * Verifies the selected property.
     * 
     * @param selected The selected property value to verify.
     */
    public void gdVerifySelected(boolean selected) {

        Verifier.equals(selected, getButtonAdapter().isSelected());
    }
    
    /**
     * Verifies the passed text.
     * 
     * @param text The text to verify
     * @param operator The RegEx operator used to verify
     */
    public void gdVerifyText(String text, String operator) {
        verifyText(text, operator);
    }

    /**
     * Verifies the passed text.
     * 
     * @param text The text to verify
     */
    public void gdVerifyText(String text) {
        gdVerifyText(text, MatchUtil.DEFAULT_OPERATOR);
    }
    /**
     * Verifies the passed text.
     * @param text The text to verify
     * @param operator The operator used to verify
     */
    public void verifyText(String text, String operator) {
        String value = getButtonAdapter().getText();
        Verifier.match(value, text, operator);
    }

}




/*******************************************************************************
 * 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.util.ArrayList;
import java.util.List;

import org.eclipse.jubula.rc.common.driver.ClickOptions;
import org.eclipse.jubula.rc.common.driver.RobotTiming;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.implclasses.MatchUtil;
import org.eclipse.jubula.rc.common.implclasses.MenuUtilBase;
import org.eclipse.jubula.rc.common.implclasses.Verifier;
import org.eclipse.jubula.rc.common.logger.AutServerLogger;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;
import org.eclipse.jubula.tools.i18n.I18n;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
import org.eclipse.jubula.tools.utils.TimeUtil;

/**
 * General implementation for Menus. Also used for context menus
 * if they behave the same.
 * 
 * @author BREDEX GmbH
 * 
 */
public abstract class AbstractMenuCAPs extends AbstractUICAPs {

    /** the logger */
    private static AutServerLogger log = new AutServerLogger(
            AbstractMenuCAPs.class);

    /**
     * @return the log
     */
    public static AutServerLogger getLog() {
        return log;
    }

    /**
     * This method gets the object which should implementet the menu Interface.
     * It is saved as Component so it must be casted.
     * @return the MenuAdapter
     */
    public IMenuAdapter getMenuAdapter() {
        return (IMenuAdapter) getComponent(); 
    }
    /**
     * Checks if the specified menu item is enabled.
     * 
     * @param menuItem the menu item as a text path to verify against
     * @param operator operator used for matching
     * @param enabled is the specified menu item enabled?
     */
    public void verifyEnabled(String menuItem, String operator, boolean enabled)
    {
        verifyEnabled(MenuUtilBase.splitPath(menuItem), operator, enabled);
    }

    /**
     * Checks if the specified menu item is enabled.
     * 
     * @param menuItem the menu item to verify against
     * @param operator operator used for matching
     * @param enabled is the specified menu item enabled?
     */
    public void verifyEnabled(String[] menuItem, String operator,
            boolean enabled) {
        checkPathLength(menuItem.length);
        final IMenuItemAdapter item = navigateToMenuItem(
                getAndCheckMenu(), menuItem, operator);
        checkIsNull(item);
        try {
            Verifier.equals(enabled, item.isEnabled());
        } finally {
            closeMenu(getAndCheckMenu(), menuItem, operator);
        }

    }
    /**
     * Checks if the given MenuItemAdapter is null and thorws an Exception
     * 
     * @param item the MenuItemAdapter which should be checked
     */
    private void checkIsNull(final IMenuItemAdapter item) {
        if (item.getRealComponent() == null) {
            throwMenuItemNotFound();
        }
    }

    /**
     * Checks if the specified menu item is enabled.
     * 
     * @param menuItem the menu item as a text path to verify against
     * @param enabled is the specified menu item enabled?
     */
    public void verifyEnabledByIndexpath(String menuItem, boolean enabled) {
        verifyEnabledByIndexpath(MenuUtilBase.splitIndexPath(menuItem),
                enabled);
    }

    /**
     * Checks if the specified menu item is enabled.
     * 
     * @param menuItem the menu item to verify against
     * @param enabled is the specified menu item enabled?
     */
    public void verifyEnabledByIndexpath(int[] menuItem, boolean enabled) {
        checkPathLength(menuItem.length);
        final IMenuItemAdapter item = navigateToMenuItem(
                getAndCheckMenu(), menuItem);
        checkIsNull(item);
        try {
            Verifier.equals(enabled, item.isEnabled());
        } finally {
            closeMenu(getAndCheckMenu(), menuItem);
        }
    }



    /**
     * Verifies if the specified menu item exists
     * 
     * @param menuItem the menu item to verifiy against
     * @param operator operator used for matching
     * @param exists  should the menu item exist?
     */
    public void verifyExists(String menuItem, String operator, boolean exists) {
        verifyExists(MenuUtilBase.splitPath(menuItem), operator, exists);
    }

    /**
     * Verifies if the specified menu item exists
     * 
     * @param menuItem the menu item to verify against
     * @param operator operator used for matching
     * @param exists should the menu item exist?
     */
    public void verifyExists(String[] menuItem, String operator, boolean exists)
    {
        checkPathLength(menuItem.length);
        final IMenuItemAdapter item = navigateToMenuItem(
                getAndCheckMenu(), menuItem, operator);
        try {
            Verifier.equals(exists, item.isExisting());
        } finally {
            closeMenu(getAndCheckMenu(), menuItem, operator);
        }
    }


    /**
     * Verifies if the specified menu item exists
     * @param menuItem the menu item to verifiy against
     * @param exists should the menu item exist?
     */
    public void verifyExistsByIndexpath(String menuItem, boolean exists) {
        verifyExistsByIndexpath(MenuUtilBase.splitIndexPath(menuItem), exists);
    }

    /**
     * Verifies if the specified menu item exists
     * 
     * @param menuItem the menu item to verify against
     * @param exists should the menu item exist?
     */
    public void verifyExistsByIndexpath(int[] menuItem, boolean exists) {
        checkPathLength(menuItem.length);
        final IMenuItemAdapter item = navigateToMenuItem(
                        getAndCheckMenu(), menuItem);
        try {
            Verifier.equals(exists, item.isExisting());
        } finally {
            closeMenu(getAndCheckMenu(), menuItem);
        }

    }

    /**
     * Checks if the specified menu item is selected.
     * 
     * @param menuItem the menu item to verify against
     * @param operator operator used for matching
     * @param selected is the specified menu item selected?
     */
    public void verifySelected(String menuItem, String operator,
            boolean selected) {
        verifySelected(MenuUtilBase.splitPath(menuItem), operator, selected);
    }

    /**
     * Checks if the specified menu item is selected.
     * 
     * @param menuItem the menu item to verify against
     * @param operator operator used for matching
     * @param selected is the specified menu item selected?
     */
    public void verifySelected(String[] menuItem, String operator,
            boolean selected) {
        checkPathLength(menuItem.length);
        final IMenuItemAdapter item = navigateToMenuItem(
                getAndCheckMenu(), menuItem, operator);
        checkIsNull(item);
        try {
            Verifier.equals(selected, item.isSelected());

        } finally {
            closeMenu(getAndCheckMenu(), menuItem, operator);
        }

    }

    /**
     * Checks if the specified menu item is selected.
     * 
     * @param menuItem the menu item to verify against
     * @param selected is the specified menu item selected?
     */
    public void verifySelectedByIndexpath(String menuItem, boolean selected) {
        verifySelectedByIndexpath(MenuUtilBase.splitIndexPath(menuItem),
                selected);
    }

    /**
     * Checks if the specified menu item is selected.
     * 
     * @param menuItem the menu item to verify against
     * @param selected is the specified menu item selected?
     */
    public void verifySelectedByIndexpath(int[] menuItem, boolean selected) {
        checkPathLength(menuItem.length);
        final IMenuItemAdapter item = navigateToMenuItem(
                getAndCheckMenu(), menuItem);
        checkIsNull(item);
        try {
            Verifier.equals(selected, item.isSelected());

        } finally {
            closeMenu(getAndCheckMenu(), menuItem);

        }

    }
    
    /**
     * Tries to select a menu item in a menu defined by an Index-Path
     * @param indexPath the menu item to select
     */
    public void selectMenuItemByIndexpath(String indexPath) {
        int[] indexItems = MenuUtilBase.splitIndexPath(indexPath);
        checkPathLength(indexItems.length);
        
        try {
            final IMenuItemAdapter item = navigateToMenuItem(
                    getAndCheckMenu(), indexItems);
        
            checkIsNull(item);
            
            item.selectMenuItem();
        } catch (StepExecutionException e) {
            try {
                closeMenu(getAndCheckMenu(), indexItems);
            } catch (StepExecutionException e1) {
                // Menu item is disabled or menu is already closed
                // Do nothing
                if (getLog().isInfoEnabled()) {
                    getLog().info("Tried to close a disabled or already closed menu."); //$NON-NLS-1$
                }
            }
            throwMenuItemNotFound();
        }
        
    }
    
    /**
     * Tries to select a menu item in a menu defined by a Text-Path
     * @param namePath the menu item to select
     * @param operator operator used for matching
     */
    public void selectMenuItem(String namePath, final String operator) {
        String[] menuItems = MenuUtilBase.splitPath(namePath);
        if (menuItems.length == 0) {
            throw new StepExecutionException("empty path to menuitem not allowed", //$NON-NLS-1$
                EventFactory.createActionError());
        }
        IMenuItemAdapter item = navigateToMenuItem(getAndCheckMenu(), 
                menuItems, operator);
        if (item == null) {
            try {
                closeMenu(getAndCheckMenu(), menuItems, operator);
            } catch (StepExecutionException see) {
                // Menu item is disabled or menu is already closed
                // Do nothing
                getLog().info("Tried to close a disabled or already closed menu."); //$NON-NLS-1$
            }
            throw new StepExecutionException("no such menu item found", //$NON-NLS-1$
                EventFactory.createActionError(TestErrorEvent.NOT_FOUND));
        }
        item.selectMenuItem();
    }
    

    /**
     * 
     * @return the IMenuAdapter.
     * @throws StepExecutionException
     *             if the active window has no menu bar.
     */
    protected IMenuAdapter getAndCheckMenu() throws StepExecutionException {
        Object menu = getMenuAdapter().getRealComponent();
        // Verify that the active window has a menu bar
        if (menu == null) {
            throw new StepExecutionException(
                    I18n.getString(TestErrorEvent.NO_MENU_BAR),
                    EventFactory.createActionError(TestErrorEvent.NO_MENU_BAR));
        }
        return getMenuAdapter();
    }

    /**
     * 
     */
    private void throwMenuItemNotFound() {
        throw new StepExecutionException("no such menu item found", //$NON-NLS-1$
                EventFactory.createActionError(TestErrorEvent.NOT_FOUND));
    }
    

    /**
     * this methods closes the hole menu. It is clicking on the parent item in the menu bar.
     * 
     * If you need another implementation override this method.
     * @param menuBar the main menu
     * @param textPath the text path used for opening the menu
     * @param operator the operator which was used for opening the menu
     */
    protected void closeMenu(IMenuAdapter menuBar, String[] textPath,
            String operator) {
        IMenuItemAdapter menuitem = findMenu(menuBar,
                getIndexForName(menuBar, textPath[0], operator));
        if (menuitem.getRealComponent() != null) {
            getRobot().click(
                    menuitem.getRealComponent(),
                    null,
                    ClickOptions.create().setClickType(
                            ClickOptions.ClickType.RELEASED));
        
        }
    
    }
    /**
     * this methods closes the hole menu. It is clicking on the parent item in the menu bar.
     * 
     * If you need another implementation override this method. 
     * @param menuBar the main menu
     * @param path the integer based path used for opening the menu
     */
    protected void closeMenu(IMenuAdapter menuBar, int[] path) {
        IMenuItemAdapter menuitem = findMenu(menuBar, path[0]);
        if (menuitem.getRealComponent() != null) {
            getRobot().click(
                menuitem.getRealComponent(),
                null,
                ClickOptions.create().setClickType(
                        ClickOptions.ClickType.RELEASED));
            
        }
    }
    
    /**
     * Gets the index of the specific menu entry with the name
     * 
     * @param menu the menu in which all items are stored
     * @param name the name of the item we want the index from
     * @param operator the operator for the matching
     * @return the index for the specific menu entry
     */
    protected int getIndexForName(IMenuAdapter menu, String name,
            String operator) {
        IMenuItemAdapter [] subElements = menu.getItems();
        int downcount = 0;
        for (int j = 0; j < subElements.length; j++) {               
            IMenuItemAdapter tempMenu = (IMenuItemAdapter)subElements[j];
            if (tempMenu.isSeparator()) {
                downcount++;
            }
            if (tempMenu.isShowing()
                    && MatchUtil.getInstance().match(
                            tempMenu.getText(), name, operator)) {
                return j - downcount;
            }
        }
        return Integer.MAX_VALUE;
    }
    
    
    /**
     * implementation for "wait for component"
     * @param timeout the maximum amount of time to wait for the component
     * @param delay the time to wait after the component is found
     */
    public void waitForComponent(int timeout, int delay) {
        if (getComponent().getRealComponent() == null) {
            long start = System.currentTimeMillis();
            do {
                RobotTiming.sleepWaitForComponentPollingDelay();
            } while (System.currentTimeMillis() - start < timeout
                    && getComponent().getRealComponent() == null);
            if (getComponent().getRealComponent() == null) {
                throw new StepExecutionException("No Menubar found.", //$NON-NLS-1$
                        EventFactory.createComponentNotFoundErrorEvent());
            }
        }
        TimeUtil.delay(delay);
    }
    
    /**
     * Tries to navigate through the menu to the specified menu item.
     * This method should be overridden if there is a need for a faster implementation.
     * 
     * @param menuBar the menubar
     * @param path the path where to navigate in the menu.
     * @param operator operator used for matching
     * @return the adapter at the end of the specified path or a adapter that contains no component.
     */
    protected IMenuItemAdapter navigateToMenuItem(
            IMenuAdapter menuBar, String[] path, String operator) {
        checkPathLength(path.length);
        IMenuAdapter currentmenu = menuBar;
        IMenuItemAdapter currentMenuItem = null;
        final int pathLength = path.length;
        final int beforeLast = pathLength - 1;
        
        for (int i = 0; i < path.length; i++) {
            int pathIndex = getIndexForName(currentmenu, path[i], operator);
            currentMenuItem = getNextMenuItem(currentmenu, pathIndex);
            
            if ((currentMenuItem.getRealComponent() == null) 
                    && (i < beforeLast)) {                
                return currentMenuItem;
            }
            
            if (i < beforeLast) {            
                if (!currentMenuItem.hasSubMenu()) {
                    // the given path is longer than the menu levels
                    return newMenuItemAdapter(null);
                }
                currentmenu = currentMenuItem.openSubMenu();
            }
        }
        return currentMenuItem;
    }
    
    /**
     * Tries to navigate through the menu to the specified menu item.
     * This method should be overridden if there is a need for a faster implementation.
     * 
     * @param menubar the menubar
     * @param path the path where to navigate in the menu.
     * @return -the adapter at the end of the specified path or a adapter that contains no component.
     */
    protected IMenuItemAdapter navigateToMenuItem(
            IMenuAdapter menubar, int[] path) {
        checkPathLength(path.length);
        
        IMenuAdapter currentmenu = menubar;
        IMenuItemAdapter currentMenuItem = null;
        final int pathLength = path.length;
        final int beforeLast = pathLength - 1;
            
        for (int i = 0; i < path.length; i++) {
            final int pathIndex = path[i];
            currentMenuItem = getNextMenuItem(currentmenu, pathIndex);
            
            if ((currentMenuItem.getRealComponent() == null) 
                    && (i < beforeLast)) {                
                return currentMenuItem;
            }
            
            if (i < beforeLast) {            
                if (!currentMenuItem.hasSubMenu()) {
                    // the given path is longer than the menu levels
                    return newMenuItemAdapter(null);
                }
                currentmenu = currentMenuItem.openSubMenu();
            }
            
                
                
        }
     
        return currentMenuItem;
    }
    /**
     * gets the next menu item adapter from its specific index
     * @param currentmenu the current menu
     * @param pathIndex the index from the next menu item
     * @return the wanted menu item in a adapter
     */
    private IMenuItemAdapter getNextMenuItem(IMenuAdapter currentmenu,
            final int pathIndex) {
        IMenuItemAdapter currentMenuItem;
        if (pathIndex < 0) {
            throwInvalidPathException();            
        }
        currentMenuItem = findMenu(currentmenu, pathIndex);
        return currentMenuItem;
    }

    
    

    




    /**
     * @param menu menu 
     * @param idx index of the current wanted item
     * @return the next IMenuItemAdapter from the next cascade
     */
    private IMenuItemAdapter findMenu(IMenuAdapter menu, int idx) {
        List visibleSubMenus = new ArrayList();
        IMenuItemAdapter[] subElements = menu.getItems();
        
        for (int i = 0; i < subElements.length; ++i) {
            
            IMenuItemAdapter menuitem = subElements[i];
            if (menuitem.getRealComponent() != null && !menuitem.isSeparator() 
                    && menuitem.isShowing()) {
                visibleSubMenus.add(menuitem);
            }
            
        }
        
        if (idx >= visibleSubMenus.size() || idx < 0) {
            return newMenuItemAdapter(null);
        }
        
        return (IMenuItemAdapter) visibleSubMenus.get(idx);
        
    }
    
    
    /**
     * Checks the path for it length and throws and StepExecutionExecption if it is 0
     * @param length the path length to be checked
     */
    private void checkPathLength(int length) {
        if (length < 1) { 
            throw new StepExecutionException("empty path to menuitem is not allowed", EventFactory //$NON-NLS-1$
                    .createActionError(
                            TestErrorEvent.INVALID_PARAM_VALUE));            
        }
    }
    
    /**
     * 
     */
    private static void throwInvalidPathException() {
        throw new StepExecutionException("invalid path", EventFactory //$NON-NLS-1$
          .createActionError(TestErrorEvent.INVALID_PARAM_VALUE));
    }
    /**
     * This adapts or puts the new MenuItem in the context which is needed for
     * the algorithms.
     * @param component the new MenuItem which is used by the next step
     * @return the adapted or casted MenuItem
     */
    protected abstract IMenuItemAdapter newMenuItemAdapter(Object component);

}




/*******************************************************************************
 * 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.Rectangle;
import java.util.StringTokenizer;

import org.eclipse.jubula.rc.common.CompSystemConstants;
import org.eclipse.jubula.rc.common.driver.ClickOptions;
import org.eclipse.jubula.rc.common.driver.DragAndDropHelper;
import org.eclipse.jubula.rc.common.driver.IRobot;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.implclasses.IndexConverter;
import org.eclipse.jubula.rc.common.implclasses.MatchUtil;
import org.eclipse.jubula.rc.common.implclasses.Verifier;
import org.eclipse.jubula.rc.common.implclasses.table.Cell;
import org.eclipse.jubula.rc.common.logger.AutServerLogger;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.ITableAdapter;
import org.eclipse.jubula.rc.common.util.KeyStrokeUtil;
import org.eclipse.jubula.tools.constants.InputConstants;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
import org.eclipse.jubula.tools.utils.TimeUtil;

/**
 * General implementation for tables.
 * 
 * @author BREDEX GmbH
 */
public abstract class AbstractTableCAPs extends AbstractTextInputSupport {
    
    /** the logger */
    private static AutServerLogger log = new AutServerLogger(
            AbstractMenuCAPs.class);

    /**
     * @return the log
     */
    public static AutServerLogger getLog() {
        return log;
    }
    
    /**
     * This method is mostly needed for clicks
     * @return the real table as object
     */
    private Object getRealTable() {
        return getComponent().getRealComponent();
    }
    /**
     * 
     * @return the ITableAdapter of this table
     */
    private ITableAdapter getTableAdapter() {
        return (ITableAdapter) getComponent();
    }
    
    /**
     * Verifies the rendered text inside the currently selected cell.
     *
     * @param text The cell text to verify.
     * @throws StepExecutionException
     *      If there is no selected cell, or if the rendered text cannot
     *      be extracted.
     */
    public void gdVerifyText(String text)
        throws StepExecutionException {

        gdVerifyText(text, MatchUtil.DEFAULT_OPERATOR);
    }
    
    /**
     * Verifies the rendered text inside the currently selected cell.
     * @param text The cell text to verify.
     * @param operator The operation used to verify
     * @throws StepExecutionException If there is no selected cell, or if the rendered text cannot be extracted.
     */
    public void gdVerifyText(String text, String operator)
        throws StepExecutionException {
        ITableAdapter adapter = getTableAdapter();
        Cell cell = adapter.getSelectedCell();
        final int implRow = cell.getRow();
        final int implCol = cell.getCol();
        checkRowColBounds(implRow, implCol);

        adapter.scrollCellToVisible(implRow, implCol);
        final String current = getCellText(implRow, implCol);
        Verifier.match(current, text, operator);
    }
    
    /**
     * Verifies the rendered text inside the passed cell.
     * @param row The row of the cell.
     * @param rowOperator The row header operator
     * @param col The column of the cell.
     * @param colOperator The column header operator
     * @param text The cell text to verify.
     * @param operator The operation used to verify
     * @throws StepExecutionException If the row or the column is invalid, or if the rendered text cannot be extracted.
     */
    public void gdVerifyText(String text, String operator, final String row,
            final String rowOperator, final String col,
            final String colOperator) throws StepExecutionException {
        ITableAdapter adapter = getTableAdapter();
        final int implRow = adapter.getRowFromString(row, rowOperator);
        final int implCol = adapter.getColumnFromString(col, colOperator);
        String current;
        //if row is header and column is existing
        if (implRow == -1 && implCol > -1) {
            current = adapter.getColumnName(implCol);        
        } else {
            checkRowColBounds(implRow, implCol);
            adapter.scrollCellToVisible(implRow, implCol);
            current = getCellText(implRow, implCol);
        }
        
        

        
        Verifier.match(current, text, operator);
    }
    
    /**
     * Selects the cell of the Table.<br>
     * With the xPos, yPos, xunits and yUnits the click position inside the cell can be defined.
     * @param row The row of the cell.
     * @param rowOperator The row header operator
     * @param col The column of the cell.
     * @param colOperator The column header operator
     * @param clickCount The number of clicks with the right mouse button
     * @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
     * @param extendSelection Should this selection be part of a multiple selection
     * @param button what mouse button should be used
     * @throws StepExecutionException If the row or the column is invalid
     */
    public void gdSelectCell(final String row, final String rowOperator,
        final String col, final String colOperator,
        final int clickCount, final int xPos, final String xUnits,
        final int yPos, final String yUnits, final String extendSelection,
        int button) 
        throws StepExecutionException {
        ITableAdapter adapter = getTableAdapter();
        final int implRow = adapter.getRowFromString(row, rowOperator);
        final int implCol = adapter.getColumnFromString(col, colOperator);
        final boolean isExtendSelection = extendSelection.equals(
                CompSystemConstants.EXTEND_SELECTION_YES); 
        if (log.isDebugEnabled()) {
            log.debug("Selecting row, col: " + row + ", " + col); //$NON-NLS-1$//$NON-NLS-2$
        }
        
        Rectangle cellBounds;
        //if row is header and col is existing
        if (implRow == -1 && implCol > -1) {
            cellBounds = adapter.getHeaderBounds(implCol);
        } else {
            cellBounds = adapter.scrollCellToVisible(implRow, implCol);
        }        
        Object o = getSpecificRectangle(cellBounds);
        ClickOptions clickOptions = ClickOptions.create();
        clickOptions.setClickCount(clickCount).setScrollToVisible(false);
        clickOptions.setMouseButton(button);
        try {
            if (isExtendSelection) {
                getRobot().keyPress(getRealTable(),
                        getExtendSelectionModifier());
            }
            getRobot().click(getRealTable(), o, clickOptions, 
                    xPos, xUnits.equalsIgnoreCase(POS_UNIT_PIXEL), 
                    yPos, yUnits.equalsIgnoreCase(POS_UNIT_PIXEL));
        } finally {
            if (isExtendSelection) {
                getRobot().keyRelease(getRealTable(),
                        getExtendSelectionModifier());
            }
        }
    }
    /**
     * This is a workaround because the toolkit specific
     * Robot implementation are using different rectangle types.
     * @param rectangle the java.awt.rectangle which needs to 
     *          casted
     * @return the rectangle in the type for the specific robot
     */
    protected Object getSpecificRectangle(Rectangle rectangle) {
        //FIXME changing the Robots might be useful here
        return rectangle;
    }
    /**
     * Verifies, if value exists in column.
     *
     * @param col The column of the cell.
     * @param colOperator the column header operator
     * @param value The cell text to verify.
     * @param operator The operation used to verify
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param exists true if value exists, false otherwise
     * @throws StepExecutionException
     *             If the row or the column is invalid, or if the rendered text
     *             cannot be extracted.
     */
    public void gdVerifyValueInColumn(final String col,
            final String colOperator, final String value,
            final String operator, final String searchType, boolean exists)
        throws StepExecutionException {
        ITableAdapter adapter = getTableAdapter();
        final int implCol = adapter.getColumnFromString(col, colOperator);
        
        
        boolean valueExists = isValueExisting(adapter, implCol,
                value, operator, searchType);

        Verifier.equals(exists, valueExists);
    }
    /**
     * Looks if value exists in the Column.
     * 
     * @param adapter the teble adapter working on.
     * @param implCol the implementation column of the cell.
     * @param value the cellt text to verify.
     * @param operator The operation used to verify.
     * @param searchType searchType Determines where the search begins ("relative" or "absolute")
     * @return <code>true</code> it the value exists in the column
     */
    private boolean isValueExisting(ITableAdapter adapter, int implCol, 
            String value, String operator, final String searchType) {
        final int rowCount = adapter.getRowCount();
        for (int i = getStartingRowIndex(searchType);
                i < rowCount; ++i) {
            if (MatchUtil.getInstance().match(getCellText(i,
                            implCol), value, operator)) {
                return true;
            }
        }
        if (adapter.isHeaderVisible()) {
            String header = adapter.getColumnName(implCol);
            if (MatchUtil.getInstance().match(header, value,
                                operator)) {
                return true;
            }
        }
        return false;
    }
    
    
    
    /**
     * Verifies, if value exists in row..
     *
     * @param row The row of the cell.
     * @param rowOperator the row header operator
     * @param value The cell text to verify.
     * @param operator The operation used to verify
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param exists true if value exists, false otherwise
     * @throws StepExecutionException
     *             If the row or the column is invalid, or if the rendered text
     *             cannot be extracted.
     */
    public void gdVerifyValueInRow(final String row, final String rowOperator,
            final String value, final String operator, final String searchType,
            boolean exists)
        throws StepExecutionException {
        final ITableAdapter adapter = getTableAdapter();
        final int implRow = adapter.getRowFromString(row, rowOperator);
        boolean valueIsExisting = false;
        //if row is header
        if (implRow == -1) {
            
            for (int k = getStartingColIndex(searchType); 
                                    k < adapter.getColumnCount(); ++k) {
                if (MatchUtil.getInstance().match(
                        adapter.getColumnName(k),
                        value, operator)) {
                    valueIsExisting = true;
                    break;
                }
            }
                            
                        
        } else {
            
            final int columnCount = adapter.getColumnCount();
            if (columnCount > 0) {
                for (int i = getStartingColIndex(searchType); 
                        i < columnCount; ++i) {
                    if (MatchUtil.getInstance().match(
                            getCellText(implRow, i), value, operator)) {
                        valueIsExisting = true;
                        break;
                    }
                }
            } else {
                // No columns found. This table is used to present a
                // list-like component.
                if (MatchUtil.getInstance().match(
                        adapter.getRowName(implRow),
                            value, operator)) {
                    valueIsExisting = true;
                    
                }
            }             
  
        }
        Verifier.equals(exists, valueIsExisting);
    }
    
    /**
     * Verifies the editable property of the given indices.
     *
     * @param editable
     *            The editable property to verify.
     * @param row the row to select
     * @param rowOperator the row header operator
     * @param col the column to select
     * @param colOperator the column header operator
     */
    public void gdVerifyEditable(boolean editable, String row,
            String rowOperator, String col, String colOperator) {
        //if row is header row
        
        if (getTableAdapter().getRowFromString(row, rowOperator) == -1) {
            throw new StepExecutionException("Unsupported Header Action", //$NON-NLS-1$
                    EventFactory.createActionError(
                            TestErrorEvent.UNSUPPORTED_HEADER_ACTION));
        }        
        gdSelectCell(row, rowOperator, col, colOperator, ClickOptions.create(),
                CompSystemConstants.EXTEND_SELECTION_NO);
        gdVerifyEditable(editable);
    }
    
    
    /**
     * Selects a table cell in the given row and column via click in the midle of the cell.
     * @param row The row of the cell.
     * @param rowOperator The row header operator
     * @param col The column of the cell.
     * @param colOperator The column header operator
     * @param co the click options to use
     * @param extendSelection Should this selection be part of a multiple selection
     */
    private void gdSelectCell(final String row, final String rowOperator,
            final String col, final String colOperator,
            final ClickOptions co, final String extendSelection) {
            
        gdSelectCell(row, rowOperator, col, colOperator, co.getClickCount(),
                    50, POS_UNI_PERCENT, 50, POS_UNI_PERCENT, extendSelection, 
                    co.getMouseButton());
    }
    
    
    /**
     * Verifies the rendered text inside cell at the mouse position on screen.
     *
     * @param text The cell text to verify.
     * @param operator The operation used to verify
     * @throws StepExecutionException If there is no selected cell, or if the
     *                              rendered text cannot be extracted.
     */
    public void gdVerifyTextAtMousePosition(String text, String operator)
        throws StepExecutionException {        
        if (isMouseOnHeader()) {
            throw new StepExecutionException("Unsupported Header Action", //$NON-NLS-1$
                    EventFactory.createActionError(
                            TestErrorEvent.UNSUPPORTED_HEADER_ACTION));
        }        
        Cell cell = getCellAtMousePosition();
        gdVerifyText(text, operator, 
                Integer.toString(IndexConverter.toUserIndex(cell.getRow())),
                MatchUtil.EQUALS, 
                Integer.toString(IndexConverter.toUserIndex(cell.getCol())),
                MatchUtil.EQUALS);
    }
    
    /**
     * Verifies the editable property of the selected cell.
     *
     * @param editable the editable property to verify.
     */
    public void gdVerifyEditableSelected(boolean editable) {
        gdVerifyEditable(editable);
    }
    
    /**
     * Verifies the editable property of the current selected cell.
     *
     * @param editable The editable property to verify.
     */
    public void gdVerifyEditable(boolean editable) {
        Cell cell = getTableAdapter().getSelectedCell();
        
        Verifier.equals(editable, getTableAdapter()
                .isCellEditable(cell.getRow(), cell.getCol()));
    }
    
    /**
     * Verifies the editable property of the cell under current mouse position.
     *
     * @param editable the editable property to verify.
     */
    public void gdVerifyEditableMousePosition(boolean editable) {
        //if row is header row
        if (isMouseOnHeader()) {
            throw new StepExecutionException("Unsupported Header Action", //$NON-NLS-1$
                    EventFactory.createActionError(
                            TestErrorEvent.UNSUPPORTED_HEADER_ACTION));
        }
        Cell cell = getCellAtMousePosition();
        boolean isEditable = getTableAdapter().isCellEditable(
                cell.getRow(), cell.getCol());
        Verifier.equals(editable, isEditable);
    }
    /**
     * Finds the first row which contains the value <code>value</code>
     * in column <code>col</code> and selects this row.
     * @param col the column
     * @param colOperator the column header operator
     * @param value the value
     * @param clickCount the number of clicks.
     * @param regexOp the regex operator
     * @param extendSelection Should this selection be part of a multiple selection
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param button what mouse button should be used
     */
    public void gdSelectRowByValue(String col, String colOperator,
            final String value, final String regexOp, int clickCount,
            final String extendSelection, final String searchType, int button) {
        gdSelectRowByValue(col, colOperator, value, regexOp, extendSelection,
                searchType, ClickOptions.create()
                        .setClickCount(clickCount)
                        .setMouseButton(button));
    }
    
    /**
     * Finds the first row which contains the value <code>value</code>
     * in column <code>col</code> and selects this row.
     *
     * @param col the column
     * @param colOperator the column header operator
     * @param value the value
     * @param regexOp the regex operator
     * @param extendSelection Should this selection be part of a multiple selection
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param co the clickOptions to use
     */
    protected void gdSelectRowByValue(String col, String colOperator,
        final String value, final String regexOp, final String extendSelection,
        final String searchType, ClickOptions co) {
        ITableAdapter adapter = getTableAdapter();
        final int implCol = adapter.getColumnFromString(col, colOperator);
        Integer implRow = null;
        final int rowCount = adapter.getRowCount();
        
        for (int i = getStartingRowIndex(searchType); i < rowCount; ++i) {
            if (MatchUtil.getInstance().match(getCellText(i, implCol), 
                    value, regexOp)) {

                implRow = new Integer(i);
                break;
            }
        }
        if (implRow == null) {
            String header = adapter.getColumnName(implCol);
            if (MatchUtil.getInstance().match(header, value, regexOp)) {
                implRow = new Integer(-1);
            }
        }

        if (implRow == null) {
            throw new StepExecutionException("no such row found", //$NON-NLS-1$
                    EventFactory.createActionError(TestErrorEvent.NOT_FOUND));
        }
        
        String  userIdxRow = new Integer(IndexConverter.toUserIndex(
                implRow.intValue())).toString();
        String  userIdxCol = new Integer(IndexConverter.toUserIndex(
                implCol)).toString();            
        
        gdSelectCell(userIdxRow, MatchUtil.EQUALS, userIdxCol, colOperator, co,
                extendSelection);
    }
    
    /**
     * Finds the first column which contains the value <code>value</code>
     * in the given row and selects the cell.
     *
     * @param row the row to select
     * @param rowOperator the row header operator
     * @param value the value
     * @param clickCount the number of clicks
     * @param regex search using regex
     * @param extendSelection Should this selection be part of a multiple selection
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param button what mouse button should be used
     */
    public void gdSelectCellByColValue(String row, String rowOperator,
        final String value, final String regex, int clickCount,
        final String extendSelection, final String searchType, int button) {
        gdSelectCellByColValue(row, rowOperator, value, regex, extendSelection,
                searchType, ClickOptions.create()
                    .setClickCount(clickCount)
                    .setMouseButton(button));
    }
    
    /**
     * Finds the first column which contains the value <code>value</code>
     * in the given row and selects the cell.
     *
     * @param row the row
     * @param rowOperator the row header operator
     * @param value the value
     * @param regex search using regex
     * @param extendSelection Should this selection be part of a multiple selection
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param co the click options to use
     */
    protected void gdSelectCellByColValue(String row, String rowOperator,
        final String value, final String regex, final String extendSelection,
        final String searchType, ClickOptions co) { 
        ITableAdapter adapter = getTableAdapter();
        final int implRow = adapter.getRowFromString(row, rowOperator);
        int colCount = adapter.getColumnCount();
        Integer implCol = null;
        if (implRow == -1) {
            
            for (int i = getStartingColIndex(searchType); i < colCount; ++i) {
                if (MatchUtil.getInstance().match(adapter.getColumnName(i), 
                        value, regex)) {
                    implCol = new Integer(i);
                    break;
                }
            }           
        } else {
            for (int i = getStartingColIndex(searchType); i < colCount; ++i) {
                if (MatchUtil.getInstance().match(getCellText(implRow, i), 
                        value, regex)) {

                    implCol = new Integer(i);
                    break;
                }
            } 
        }
        if (implCol == null) {
            throw new StepExecutionException("no such cell found", EventFactory //$NON-NLS-1$
                    .createActionError(TestErrorEvent.NOT_FOUND));
        }
        
        String usrIdxRowStr = new Integer(IndexConverter.toUserIndex(
                implRow)).toString();
        String usrIdxColStr = new Integer(IndexConverter.toUserIndex(
                implCol.intValue())).toString();
        
        gdSelectCell(usrIdxRowStr, rowOperator, usrIdxColStr, MatchUtil.EQUALS,
                co, extendSelection);
        
    }
    
    /**
     * Action to read the value of the current selected cell of the JTable 
     * to store it in a variable in the Client
     * @param variable the name of the variable
     * @return the text value.
     */
    public String gdReadValue(String variable) {
        final Cell selectedCell = getTableAdapter().getSelectedCell();
        return getCellText(selectedCell.getRow(), selectedCell.getCol());
    }
    
    /**
     * Action to read the value of the passed cell of the JTable
     * to store it in a variable in the Client
     * @param variable the name of the variable
     * @param row the row to select
     * @param rowOperator the row header operator
     * @param col the column to select
     * @param colOperator the column header operator
     * @return the text value.
     */
    public String gdReadValue(String variable, String row, String rowOperator,
            String col, String colOperator) {
        ITableAdapter adapter = getTableAdapter();
        final int implRow = adapter.getRowFromString(row, rowOperator);
        final int implCol = adapter.getColumnFromString(col, colOperator);
        
        //if row is header and column is existing
        if (implRow == -1 && implCol > -1) {
            return adapter.getColumnName(implCol); 
        }
        
        checkRowColBounds(implRow, implCol);

        adapter.scrollCellToVisible(implRow, implCol);
        return getCellText(implRow, implCol);
    }
    
    /**
     * {@inheritDoc}
     */
    public String gdReadValueAtMousePosition(String variable) {
        Cell cellAtMousePosition = getTableAdapter().getSelectedCell();
        return getCellText(cellAtMousePosition.getRow(), 
                cellAtMousePosition.getCol());
    }
    
    /**
     * Tries to click in the cell under the mouse position. If the mouse is not
     * over a cell, the current selected cell will be clicked on. If there is no
     * selected cell, the middle of the table is used to click on.
     * @param count Number of clicks
     * @param button The mouse button
     */
    public void gdClick(int count, int button) {
        ITableAdapter adapter = getTableAdapter();
        Cell cell = null;
        if (isMouseOverCell()) {
            cell = getCellAtMousePosition();
        } else if (adapter.hasCellSelection()) {
            cell = adapter.getSelectedCell();
        } 
        if (cell != null) {
            Rectangle cellRect = 
                    adapter.scrollCellToVisible(cell.getRow(), cell.getCol());
            getRobot().click(getRealTable(), cellRect, ClickOptions.create()
                .setClickCount(count).setMouseButton(button));
        } else {
            super.gdClick(count, button);
        }
    }
   
    /**
     * Selects a cell relative to the cell at the current mouse position.
     * If the mouse is not at any cell, the current selected cell is used.
     * @param direction the direction to move.
     * @param cellCount the amount of cells to move
     * @param clickCount the click count to select the new cell.
     * @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
     * @param extendSelection Should this selection be part of a multiple selection
     * @throws StepExecutionException if any error occurs
     */
    public void gdMove(String direction, int cellCount, int clickCount,
        final int xPos, final String xUnits,
        final int yPos, final String yUnits, final String extendSelection)
        throws StepExecutionException {
        if (isMouseOnHeader()) {
            throw new StepExecutionException("Unsupported Header Action", //$NON-NLS-1$
                    EventFactory.createActionError(
                            TestErrorEvent.UNSUPPORTED_HEADER_ACTION));
        }
        Cell currCell = null;
        try {
            currCell = getCellAtMousePosition();
        } catch (StepExecutionException e) {
            currCell = getTableAdapter().getSelectedCell();
        }
        int newCol = currCell.getCol();
        int newRow = currCell.getRow();
        if (CompSystemConstants.TABLE_MOVE_UP
                .equalsIgnoreCase(direction)) {
            newRow -= cellCount;
        } else if (CompSystemConstants.TABLE_MOVE_DOWN
                .equalsIgnoreCase(direction)) {
            newRow += cellCount;
        } else if (CompSystemConstants.TABLE_MOVE_LEFT
                .equalsIgnoreCase(direction)) {
            newCol -= cellCount;
        } else if (CompSystemConstants.TABLE_MOVE_RIGHT
                .equalsIgnoreCase(direction)) {
            newCol += cellCount;
        }
        newRow = IndexConverter.toUserIndex(newRow);
        newCol = IndexConverter.toUserIndex(newCol);
        String row = Integer.toString(newRow);
        String col = Integer.toString(newCol);
        gdSelectCell(row, MatchUtil.DEFAULT_OPERATOR , col, 
                MatchUtil.DEFAULT_OPERATOR, clickCount, xPos,
                xUnits, yPos, yUnits, extendSelection, 
                InputConstants.MOUSE_BUTTON_LEFT);
//        gdSelectCell(newRow, newCol, clickCount,
//                     xPos, xUnits, yPos, yUnits, extendSelection);
    }
    
    /**
     * Writes the passed text into the currently selected cell.
     * 
     * @param text
     *            The text.
     * @throws StepExecutionException
     *             If there is no selected cell, or if the cell is not editable,
     *             or if the table cell editor permits the text to be written.
     */
    public void gdInputText(final String text) throws StepExecutionException {
        inputText(text, false);
    }
    
    /**
     * Types the text in the specified cell.
     * @param text The text
     * @param row The row of the cell.
     * @param rowOperator The row operator
     * @param col The column of the cell.
     * @param colOperator The column operator
     * @throws StepExecutionException If the text input fails
     */
    public void gdInputText(String text, String row, String rowOperator,
            String col, String colOperator)
        throws StepExecutionException {
        //if row is header row
        if (getTableAdapter().getRowFromString(row, rowOperator) == -1) {
            throw new StepExecutionException("Unsupported Header Action", //$NON-NLS-1$
                    EventFactory.createActionError(
                            TestErrorEvent.UNSUPPORTED_HEADER_ACTION));
        }
        gdSelectCell(row, rowOperator, col, colOperator, 
                ClickOptions.create().setClickCount(1), 
                CompSystemConstants.EXTEND_SELECTION_NO);
        gdInputText(text);
    }
    
    /**
     * Types <code>text</code> into the component. This replaces the shown
     * content in the current selected cell.
     * 
     * @param text the text to type in
     * @throws StepExecutionException
     *  If there is no selected cell, or if the cell is not editable,
     *  or if the table cell editor permits the text to be written.
     */
    public void gdReplaceText(String text) throws StepExecutionException {
        inputText(text, true);
    }
    
    /**
     * Replaces the given text in the given cell coordinates
     * @param text the text to replace
     * @param row The row of the cell.
     * @param rowOperator The row operator
     * @param col The column of the cell.
     * @param colOperator The column operator
     */
    public void gdReplaceText(String text, String row, String rowOperator,
            String col, String colOperator) {
        //if row is header row
        if (getTableAdapter().getRowFromString(row, rowOperator) == -1) {
            throw new StepExecutionException("Unsupported Header Action", //$NON-NLS-1$
                    EventFactory.createActionError(
                            TestErrorEvent.UNSUPPORTED_HEADER_ACTION));
        }
        gdSelectCell(row, rowOperator, col, colOperator, 
                ClickOptions.create().setClickCount(1), 
                CompSystemConstants.EXTEND_SELECTION_NO);
        inputText(text, true);
    }
    
    /**
     * Drags the cell of the Table.<br>
     * With the xPos, yPos, xunits and yUnits the click position inside the
     * cell can be defined.
     *
     * @param mouseButton the mouseButton.
     * @param modifier the modifier.
     * @param row the row to select
     * @param rowOperator the row header operator
     * @param col the column to select
     * @param colOperator the column header operator
     * @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
     *             If the row or the column is invalid
     */
    public void gdDragCell(final int mouseButton, final String modifier,
            final String row, final String rowOperator,
            final String col, final String colOperator, final int xPos,
            final String xUnits, final int yPos, final String yUnits)
        throws StepExecutionException {

        final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
        dndHelper.setModifier(modifier);
        dndHelper.setMouseButton(mouseButton);
        dndHelper.setDragComponent(null);
        gdSelectCell(row, rowOperator, col, colOperator, 0, xPos, xUnits, yPos,
                yUnits, CompSystemConstants.EXTEND_SELECTION_NO, 1);
        pressOrReleaseModifiers(modifier, true);
        getRobot().mousePress(null, null, mouseButton);
    }
    
    /**
     * Drops on the cell of the JTable.<br>
     * With the xPos, yPos, xunits and yUnits the click position inside the
     * cell can be defined.
     *
     * @param row the row to select
     * @param rowOperator the row header operator
     * @param col the column to select
     * @param colOperator the column header operator
     * @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
     * @param delayBeforeDrop the amount of time (in milliseconds) to wait
     *                        between moving the mouse to the drop point and
     *                        releasing the mouse button
     * @throws StepExecutionException
     *             If the row or the column is invalid
     */
    public void gdDropCell(final String row, final String rowOperator,
            final String col, final String colOperator, final int xPos,
            final String xUnits, final int yPos, final String yUnits,
            int delayBeforeDrop) throws StepExecutionException {

        final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
        try {
            gdSelectCell(row, rowOperator, col, colOperator, 0, xPos, xUnits,
                    yPos, yUnits, CompSystemConstants.EXTEND_SELECTION_NO, 1);
            waitBeforeDrop(delayBeforeDrop);
        } finally {
            getRobot().mouseRelease(null, null, dndHelper.getMouseButton());
            pressOrReleaseModifiers(dndHelper.getModifier(), false);
        }
    }
    
    /**
     * Finds the first row which contains the value <code>value</code>
     * in column <code>col</code> and drags this row.
     *
     * @param mouseButton the mouse button
     * @param modifier the modifier
     * @param col the column
     * @param colOperator the column header operator
     * @param value the value
     * @param regexOp the regex operator
     * @param searchType Determines where the search begins ("relative" or "absolute")
     */
    public void gdDragRowByValue(int mouseButton, String modifier, String col,
            String colOperator, final String value, final String regexOp,
            final String searchType) {

        final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
        dndHelper.setModifier(modifier);
        dndHelper.setMouseButton(mouseButton);
        gdSelectRowByValue(col, colOperator, value, regexOp, 1,
                CompSystemConstants.EXTEND_SELECTION_NO, searchType, 1);
        pressOrReleaseModifiers(modifier, true);
        getRobot().mousePress(null, null, mouseButton);
    }
    
    /**
     * Finds the first row which contains the value <code>value</code>
     * in column <code>col</code> and drops on this row.
     *
     * @param col the column to select
     * @param colOperator the column header operator
     * @param value the value
     * @param regexOp the regex operator
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param delayBeforeDrop the amount of time (in milliseconds) to wait
     *                        between moving the mouse to the drop point and
     *                        releasing the mouse button
     */
    public void gdDropRowByValue(String col, String colOperator,
            final String value, final String regexOp, final String searchType,
            int delayBeforeDrop) {
        
        final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
        try {
            gdSelectRowByValue(col, colOperator, value, regexOp,
                    CompSystemConstants.EXTEND_SELECTION_NO, 
                    searchType, ClickOptions
                    .create().setClickCount(0));
            waitBeforeDrop(delayBeforeDrop);
        } finally {
            getRobot().mouseRelease(null, null, dndHelper.getMouseButton());
            pressOrReleaseModifiers(dndHelper.getModifier(), false);
        }
    }
    
    /**
     * Finds the first column which contains the value <code>value</code>
     * in the given row and drags the cell.
     *
     * @param mouseButton the mouse button
     * @param modifier the modifiers
     * @param row the row to select
     * @param rowOperator the row header operator
     * @param value the value
     * @param regex search using regex
     * @param searchType Determines where the search begins ("relative" or "absolute")
     */
    public void gdDragCellByColValue(int mouseButton, String modifier,
            String row, String rowOperator, final String value,
            final String regex, final String searchType) {

        final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
        dndHelper.setModifier(modifier);
        dndHelper.setMouseButton(mouseButton);

        gdSelectCellByColValue(row, rowOperator, value, regex,
                CompSystemConstants.EXTEND_SELECTION_NO, searchType, 
                ClickOptions.create().setClickCount(0));
        pressOrReleaseModifiers(modifier, true);
        getRobot().mousePress(null, null, mouseButton);
    }
    
    /**
     * Finds the first column which contains the value <code>value</code>
     * in the given row and drops on the cell.
     *
     * @param row the row to select
     * @param rowOperator the row header operator
     * @param value the value
     * @param regex search using regex
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param delayBeforeDrop the amount of time (in milliseconds) to wait
     *                        between moving the mouse to the drop point and
     *                        releasing the mouse button
     */
    public void gdDropCellByColValue(String row, String rowOperator,
            final String value, final String regex, final String searchType,
            int delayBeforeDrop) {

        final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
        try {
            gdSelectCellByColValue(row, rowOperator, value, regex, 
                    CompSystemConstants.EXTEND_SELECTION_NO, searchType, 
                    ClickOptions.create().setClickCount(0));
            waitBeforeDrop(delayBeforeDrop);
        } finally {
            getRobot().mouseRelease(null, null, dndHelper.getMouseButton());
            pressOrReleaseModifiers(dndHelper.getModifier(), false);
        }
    }
    

    /**
     * Gets the text from the specific cell which is given
     * by the row and the column.
     * @param row the zero based index of the row
     * @param column the zero based index of the column
     * @return the text of the cell of the given coordinates
     */
    private String getCellText(final int row, final int column) {
        return getTableAdapter().getCellText(row, column);

    }
    
    /**
     * Presses or releases the given modifier.
     * @param modifier the modifier.
     * @param press if true, the modifier will be pressed.
     * if false, the modifier will be released.
     */
    protected void pressOrReleaseModifiers(String modifier, boolean press) {
        final IRobot robot = getRobot();
        final StringTokenizer modTok = new StringTokenizer(
                KeyStrokeUtil.getModifierString(modifier), " "); //$NON-NLS-1$
        while (modTok.hasMoreTokens()) {
            final String mod = modTok.nextToken();
            final int keyCode = getKeyCode(mod);
            if (press) {
                robot.keyPress(null, keyCode);
            } else {
                robot.keyRelease(null, keyCode);
            }
        }
    }
    
    /**
     * Gets the key code for a specific modifier
     * @param mod the modifier
     * @return the integer key code value
     */
    protected abstract int getKeyCode(String mod);
    
    /**
     * Checks whether <code>0 <= value < count</code>. 
     * @param value The value to check.
     * @param count The upper bound.
     */
    private void checkBounds(int value, int count) {
        if (value < 0 || value >= count) {
            throw new StepExecutionException("Invalid row/column: " + value, //$NON-NLS-1$
                EventFactory.createActionError(
                        TestErrorEvent.INVALID_INDEX_OR_HEADER));
        }
    }
    
    /**
     * Checks if the passed row and column are inside the bounds of the Table. 
     * @param row The row
     * @param column The column
     * @throws StepExecutionException If the row or the column is outside of the Table's bounds.
     */
    protected void checkRowColBounds(int row, int column)
        throws StepExecutionException {
        ITableAdapter adapter = getTableAdapter();
        checkBounds(row, adapter.getRowCount());
        
        // Corner case: Only check the bounds if the table is not being
        //              used as a list or anything other than the first column
        //              is being checked.
        int colCount = adapter.getColumnCount();
        if (colCount > 0 || column > 0) {
            checkBounds(column, colCount);
        }
    }
    
    /**
     * @param searchType Determines column where the search begins ("relative" or "absolute")
     * @return The index from which to begin a search, based on the search type
     *         and (if appropriate) the currently selected cell.
     */
    private int getStartingColIndex(String searchType) {
        int startingIndex = 0;
        if (searchType.equalsIgnoreCase(
                CompSystemConstants.SEARCH_TYPE_RELATIVE)) {
            startingIndex = getTableAdapter().getSelectedCell().getCol() + 1;
        }
        return startingIndex;
    }

    /**
     * @param searchType Determines the row where the search begins ("relative" or "absolute")
     * @return The index from which to begin a search, based on the search type
     *         and (if appropriate) the currently selected cell.
     */
    private int getStartingRowIndex(String searchType) {
        int startingIndex = 0;
        if (searchType.equalsIgnoreCase(
                CompSystemConstants.SEARCH_TYPE_RELATIVE)) {
            startingIndex = getTableAdapter().getSelectedCell().getRow() + 1;
        }
        return startingIndex;
    }
    
    /**
     * inputs/replaces the given text
     * @param text the text to input
     * @param replace wheter to replace or not
     * @throws StepExecutionException If there is no selected cell,
     * or if the cell is not editable, or if the table cell editor permits
     * the text to be written.
     */
    private void inputText(final String text, boolean replace) 
        throws StepExecutionException {
        ITableAdapter adapter = getTableAdapter();
        
        final Cell cell = adapter.getSelectedCell();
        // Ensure that the cell is visible.
        Rectangle rectangle = 
                adapter.scrollCellToVisible(cell.getRow(), cell.getCol());
        
        Object editor = activateEditor(cell, rectangle);
        editor = setEditorToReplaceMode(editor, replace);
        
        getRobot().type(editor, text);
    }
    
    /**
     * @return true if the mouse pointer is over any cell, false otherwise.
     */
    private boolean isMouseOverCell() {
        try {
            getCellAtMousePosition();
        } catch (StepExecutionException se) {
            return false;
        }
        return true;
    }
    
    /**
     * Waits the given amount of time. Logs a drop-related error if interrupted.
     *
     * @param delayBeforeDrop the amount of time (in milliseconds) to wait
     *                        between moving the mouse to the drop point and
     *                        releasing the mouse button
     */
    static void waitBeforeDrop(int delayBeforeDrop) {
        TimeUtil.delay(delayBeforeDrop);
    }
    
    /**
     * Sets the specific editor to an replace mode. Means that the next key
     * input will override the complete text of the editor.
     * @param editor 
     * @param replace if <code>true</code> than the editor has to override
     *              the complete text with the next key input. Else the next
     *              key input will append to the end.
     * @return the editor if it changed
     */
    protected abstract Object setEditorToReplaceMode(Object editor,
            boolean replace);
   
    /**
     * Activates the editor of the specific cell.
     * @param cell 
     * @param rectangle 
     * @return the editor of the cell
     */
    protected abstract Object activateEditor(Cell cell, Rectangle rectangle);
    

    /**
     * Gets The modifier for an extended selection (more than one item)
     * @return the modifier
     */
    protected abstract int getExtendSelectionModifier();
    
    /**
     * @return the cell under the current mouse position.
     * @throws StepExecutionException If no cell is found.
     */
    protected abstract Cell getCellAtMousePosition() 
        throws StepExecutionException;
   
    /**
     * Verifies if mouse is on header.
     * @return true if mouse is on header
     */
    protected abstract boolean isMouseOnHeader();

    /**
     * Selects the passed row of the JTable. This is actually a selection of the
     * cell <code>(row, 0)</code>.
     *
     * @param row
     *            The row
     * @param extendSelection Should this selection be part of a multiple selection
     * @throws StepExecutionException
     *             If the row is invalid
     * @deprecated the same as gdSelectCell
     * Will be removed!
     */
    public void gdSelectRow(int row, String extendSelection)
        throws StepExecutionException {
        // FIXME this is only here for testing purpose (to get all CaA tests running)
        gdSelectCell(String.valueOf(row), MatchUtil.DEFAULT_OPERATOR, "1", //$NON-NLS-1$
                MatchUtil.DEFAULT_OPERATOR, 
                ClickOptions.create().setClickCount(1), extendSelection);
    }
    
    /**
     * Finds the first column which contains the value <code>value</code>
     * in the given row and selects the cell.
     * 
     * @param row the row
     * @param value the value
     * @param clickCount the mouse clicks.
     * @param regex search using regex
     * @param extendSelection Should this selection be part of a multiple selection
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @deprecated Will be removed with gdSelectCellByColValue with String parameter
     * for Row/Column
     */
    public void gdSelectCellByColValue(int row, final String value, 
        final String regex, int clickCount, final String extendSelection, 
        final String searchType) {
        // FIXME this is only here for testing purpose (to get all CaA tests running)
        gdSelectCellByColValue(String.valueOf(row), MatchUtil.DEFAULT_OPERATOR,
                value, regex, clickCount, extendSelection, searchType, 1);

    }
    
    /**
     * Finds the first row which contains the value <code>value</code>
     * in column <code>col</code> and selects this row.
     * @param col the column
     * @param value the value
     * @param clickCount the number of clicks.
     * @param regexOp the regex operator
     * @param extendSelection Should this selection be part of a multiple selection
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @deprecated Will be removed with gdSelectRowByValue with String parameter
     * for Row/Column
     */
    public void gdSelectRowByValue(int col, final String value,
        int clickCount, final String regexOp, final String extendSelection, 
        final String searchType) {
        // FIXME this is only here for testing purpose (to get all CaA tests running)
        gdSelectRowByValue(String.valueOf(col), MatchUtil.DEFAULT_OPERATOR,
                value, regexOp, clickCount, extendSelection, searchType, 1);
    }
}




/*******************************************************************************
 * 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 org.eclipse.jubula.rc.common.exception.StepExecutionException;

/**
 * This class represents the general implmentation for components,
 *  which have text input support.
 * 
 * @author BREDEX GmbH
 */
public abstract class AbstractTextInputSupport extends AbstractTextVerifiable {

    /**
     * Verifies the editable property of the current component.<br>
     * If it is a complex component, it is always the selected object.
     * @param editable The editable property to verify.
     */
    public abstract void gdVerifyEditable(boolean editable);
 // FIXME this is only a pattern because only Tables uses this at the moment
    /**
     * Types <code>text</code> into the component. This replaces the shown
     * content.<br>
     * If it is a complex component, it is always the selected object.
     * @param text the text to type in
     * @throws StepExecutionException
     *  If there is no selected cell, or if the cell is not editable,
     *  or if the table cell editor permits the text to be written.
     */
    public abstract void gdReplaceText(String text) 
        throws StepExecutionException;
 // FIXME this is only a pattern because only Tables uses this at the moment
    /**
     * Writes the passed text into the currently component.<br>
     * If it is a complex component, it is always the selected object.
     * @param text The text.
     * @throws StepExecutionException
     *             If there is no selected cell, or if the cell is not editable,
     *             or if the table cell editor permits the text to be written.
     */
    public abstract void gdInputText(final String text) 
        throws StepExecutionException;
 // FIXME this is only a pattern because only Tables uses this at the moment
}




/*******************************************************************************
 * 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 org.eclipse.jubula.rc.common.exception.StepExecutionException;

/**
 * This class represents the general implementation for components
 * which have readable text.
 * 
 * @author BREDEX GmbH
 */
public abstract class AbstractTextVerifiable extends AbstractWidgetCAPs {

    /**
     * Action to read the value of the current component 
     * to store it in a variable in the Client.<br>
     * If it is a complex component, it is always the selected object.
     * @param variable the name of the variable
     * @return the text value.
     */
    public abstract String gdReadValue(String variable);
    // FIXME this is only a pattern because only Tables uses this at the moment

    /**
     * Verifies the rendered text inside the currently component.<br>
     * If it is a complex component, it is always the selected object.
     * @param text The text to verify.
     * @param operator The operation used to verify
     * @throws StepExecutionException If the rendered text cannot be extracted.
     */
    public abstract void gdVerifyText(String text, String operator)
        throws StepExecutionException;
    // FIXME this is only a pattern because only Tables uses this at the moment
}




/*******************************************************************************
 * 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.util.Collection;
import java.util.Iterator;

import org.apache.commons.lang.Validate;
import org.eclipse.jubula.rc.common.CompSystemConstants;
import org.eclipse.jubula.rc.common.driver.ClickOptions;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.exception.StepVerifyFailedException;
import org.eclipse.jubula.rc.common.implclasses.IndexConverter;
import org.eclipse.jubula.rc.common.implclasses.MatchUtil;
import org.eclipse.jubula.rc.common.implclasses.Verifier;
import org.eclipse.jubula.rc.common.implclasses.tree.AbstractTreeNodeTraverser;
import org.eclipse.jubula.rc.common.implclasses.tree.AbstractTreeOperationContext;
import org.eclipse.jubula.rc.common.implclasses.tree.ChildTraverser;
import org.eclipse.jubula.rc.common.implclasses.tree.ExpandCollapseTreeNodeOperation;
import org.eclipse.jubula.rc.common.implclasses.tree.INodePath;
import org.eclipse.jubula.rc.common.implclasses.tree.IndexNodePath;
import org.eclipse.jubula.rc.common.implclasses.tree.ParentTraverser;
import org.eclipse.jubula.rc.common.implclasses.tree.PathBasedTraverser;
import org.eclipse.jubula.rc.common.implclasses.tree.SelectTreeNodeOperation;
import org.eclipse.jubula.rc.common.implclasses.tree.SiblingTraverser;
import org.eclipse.jubula.rc.common.implclasses.tree.StringNodePath;
import org.eclipse.jubula.rc.common.implclasses.tree.TreeNodeOperation;
import org.eclipse.jubula.rc.common.implclasses.tree.TreeNodeOperationConstraint;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.ITreeAdapter;
import org.eclipse.jubula.tools.constants.StringConstants;
import org.eclipse.jubula.tools.constants.TestDataConstants;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
import org.eclipse.jubula.tools.utils.StringParsing;


/**
 * General implementation for Trees.
 * 
 * @author BREDEX GmbH
 */
public abstract class AbstractTreeCAPs extends AbstractWidgetCAPs {

    /**
     * {@inheritDoc}
     */
    public String[] getTextArrayFromComponent() {
        //FIXME is here an TextArray?
        return null;
    }

    /**
     *  This method is only casting the IComponentAdapter to the wanted ITreeAdapter
     * @return The ITreeAdapter out of the stored IComponentAdapter
     */
    private ITreeAdapter getTreeAdapter() {
        return (ITreeAdapter)getComponent();
        
    }
    
    /**
     * Verifies the text of the Node at mousePosition
     * @param text the text to check
     * @param operator the operator for the verification
     */
    public abstract void gdVerifyTextAtMousePosition(
            String text, 
            String operator);
    /**
     * Splits the <code>treepath</code> string into an array, one entry for each level in the path
     *
     * @param treePath The tree path
     * @return An array of string representing the tree path
     */
    protected String[] splitTextTreePath(String treePath) {
        return StringParsing.splitToArray(treePath,
                TestDataConstants.PATH_CHAR_DEFAULT,
                TestDataConstants.ESCAPE_CHAR_DEFAULT, 
                true);
    }
    
    /**
     * Splits the <code>treepath</code> string into an array, one entry for each level in the path
     *
     * @param treePath The tree path
     * @return An array of indices (type <code>Integer</code>) representing
     *         the tree path
     * @throws StepExecutionException
     *             If the values of the passed path cannot be parsed
     */
    protected Integer[] splitIndexTreePath(String treePath)
        throws StepExecutionException {
        Integer[] indexPath = null;
        String[] path = splitTextTreePath(treePath);
        if (path != null) {
            indexPath = new Integer[path.length];
            for (int i = 0; i < path.length; i++) {
                indexPath[i] = new Integer(IndexConverter.intValue(path[i]));
            }
        }
        return IndexConverter.toImplementationIndices(indexPath);
    }
    
    /**
     * Splits the <code>treepath</code> string into an array, one entry for each level in the path
     * 
     * @param treePath The tree path
     * @param operator The operator
     * @return An array of string representing the tree path
     */
    protected INodePath createStringNodePath(String [] treePath, 
            String operator) {
        return new StringNodePath(treePath, operator);
    }
    
    /**
     * Splits the <code>treepath</code> string into an array, one entry for each level in the path
     *
     * @param treePath The tree path
     * @return An array of string representing the tree path
     */
    protected INodePath createIndexNodePath(Integer [] treePath) {
        return new IndexNodePath(treePath);
    }

    
    /**
     * Traverses the tree by searching for the nodes in the tree
     * path entry and calling the given operation on each matching node.
     *
     * @param treePath The tree path.
     * @param pathType For example, "relative" or "absolute".
     * @param preAscend Relative traversals will start this many parent nodes
     *            above the current node. Absolute traversals ignore this
     *            parameter.
     * @param operation The tree node operation.
     * @throws StepExecutionException If the path traversion fails.
     */
    protected void traverseTreeByPath(INodePath treePath, String pathType,
            int preAscend, TreeNodeOperation operation)
        throws StepExecutionException {

        Validate.notNull(treePath);
        Validate.notNull(operation);

        ITreeAdapter adapter = getTreeAdapter();
        AbstractTreeOperationContext context = adapter.getContext();

        AbstractTreeNodeTraverser traverser =
            new PathBasedTraverser(context, treePath);

        traverser.traversePath(operation, 
                getStartNode(pathType, preAscend, context));

    }
   
    /**
     * Traverses the tree by searching for the nodes in the tree
     * path entry and calling the given operation on the last element in the path.
     * @param treePath The tree path.
     * @param pathType For example, "relative" or "absolute".
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param operation The tree node operation.
     * @throws StepExecutionException If the path traversion fails.
     */
    protected void traverseLastElementByPath(INodePath treePath, 
            String pathType, int preAscend, TreeNodeOperation operation) 
        throws StepExecutionException {

        Validate.notNull(treePath);
        Validate.notNull(operation);

        AbstractTreeOperationContext context = getTreeAdapter().getContext();
        Object startNode = getStartNode(pathType, preAscend, context);

        AbstractTreeNodeTraverser traverser = new PathBasedTraverser(
                context, treePath, new TreeNodeOperationConstraint());
        
        traverser.traversePath(operation, startNode);
    }
    
    /**
     * @param pathType pathType
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param objectPath objectPath
     * @param co the click options to use
     */
    private void selectByPath(String pathType, int preAscend, 
            INodePath objectPath, ClickOptions co) {

        TreeNodeOperation expOp = new ExpandCollapseTreeNodeOperation(false);
        TreeNodeOperation selectOp = new SelectTreeNodeOperation(co);
        INodePath subPath = objectPath.subPath(0, objectPath.getLength() - 1);

        traverseTreeByPath(subPath, pathType, preAscend, expOp);
        traverseLastElementByPath(objectPath, pathType, preAscend, selectOp);
    }
    
    /**
     * Returns the selected node
     * @param context context
     * @return node
     */
    protected Object getSelectedNode(AbstractTreeOperationContext context) {
        return context.getSelectedNode();
    }
    
    /**
     * Clicks the tree.
     * If the mouse pointer is in the tree no mouse move will be perfomed.
     * Otherwise, the mouse is first moved to the center of the tree.
     *
     * @param count Number of mouse clicks
     * @param button Pressed button
     */
    public void gdClick(int count, int button) {
        if (getRobot().isMouseInComponent(
                getTreeAdapter().getRealComponent())) {
            getRobot().clickAtCurrentPosition(
                    getTreeAdapter().getRealComponent(), count, button);
        } else {
            getRobot().click(getTreeAdapter().getRealComponent(), null, 
                ClickOptions.create().setClickCount(count)
                    .setMouseButton(button));
        }       
    }
    
    /**
     * Collapses the JTree. The passed tree path is a slash-seperated list of
     * nodes that specifies a valid top-down path in the JTree. The last node of
     * the tree path is collapsed if it is currently expanded. Otherwise, the JTree is
     * left unchanged.
     *
     * @param pathType whether the path is relative or absolute
     * @param preAscend Relative traversals will start this many parent nodes
     *            above the current node. Absolute traversals ignore this
     *            parameter.
     * @param treePath The tree path.
     * @param operator
     *            Whether regular expressions are used to determine the tree path.
     *            <code>"matches"</code> for regex, <code>"equals"</code> for simple matching.
     * @throws StepExecutionException
     *             If the tree path is invalid or the double click to collapse
     *             the node fails.
     */
    public void gdCollapse(String pathType, int preAscend,
        String treePath, String operator) throws StepExecutionException {
        traverseLastElementByPath(
                createStringNodePath(splitTextTreePath(treePath), operator),
                pathType, preAscend,
                new ExpandCollapseTreeNodeOperation(true));
    }
    
    /**
     * Collapses the tree. This method works like {@link #gdCollapse(String, int, String, String)},
     * but expects an enumeration of indices representing the top-down tree
     * path. Any index is the node's position at the current tree level.
     *
     * @param pathType whether the path is relative or absolute
     * @param preAscend Relative traversals will start this many parent nodes
     *            above the current node. Absolute traversals ignore this
     *            parameter.
     * @param indexPath  The index path
     * @throws StepExecutionException
     *             If the tree path is invalid or the double-click to collapse
     *             the node fails.
     */
    public void gdCollapseByIndices(String pathType, int preAscend,
        String indexPath) throws StepExecutionException {

        try {
            traverseLastElementByPath(
                    createIndexNodePath(splitIndexTreePath(indexPath)),
                    pathType, preAscend,
                    new ExpandCollapseTreeNodeOperation(true));
        } catch (NumberFormatException e) {
            throw new StepExecutionException(e.getMessage(), EventFactory
                    .createActionError(TestErrorEvent.INVALID_INDEX));
        }
    }
    
    /**
     * <p>
     * Expands the Tree. Any node defined by the passed tree path is expanded,
     * if it is collapsed. The node is expanded by performing a double click
     * onto the node. If the node is already expanded, the JTree is left
     * unchanged. The tree path is a slash-seperated list of nodes that specifies
     * a valid top-down path in the JTree.
     * </p>
     *
     * An example: Say the passed tree path is <code>animals/birds/kakadu</code>.
     * To get a valid expansion, the JTree has to look as follows:
     *
     * <pre>
     * animals
     * |
     * - -- birds
     *      |
     *      - -- kakadu
     * </pre>
     *
     * <code>animals</code> is the Tree's root node, if the root node has
     * been set to visible,
     * or it is one of the root node's children, if the root node has been set
     * to invisible.
     *
     * <p>
     * It is important to know that the tree path entries have to match the
     * rendered node texts, but not the underlying user object data etc.
     * </p>
     *
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes
     *            above the current node. Absolute traversals ignore this
     *            parameter.
     * @param treePath
     *            The tree path.
     * @param operator
     *            If regular expressions are used to determine the tree path
     * @throws StepExecutionException
     *             If the tree path is invalid or the double click fails.
     */
    public void gdExpand(String pathType, int preAscend,
        String treePath, String operator) throws StepExecutionException {
        traverseTreeByPath(
                createStringNodePath(splitTextTreePath(treePath), operator),
                pathType, preAscend,
                new ExpandCollapseTreeNodeOperation(false));
    }
    
    /**
     * Expands the tree. This method works like {@link #gdExpand(String, int, String, String)}, but
     * expects an enumeration of indices representing the top-down tree path.
     * Any index is the node's position at the current tree level.
     *
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes
     *            above the current node. Absolute traversals ignore this
     *            parameter.
     * @param indexPath The index path
     * @throws StepExecutionException
     *             If the tree path is invalid or the double-click fails.
     */
    public void gdExpandByIndices(String pathType, int preAscend,
        String indexPath) throws StepExecutionException {

        try {
            traverseTreeByPath(
                    createIndexNodePath(splitIndexTreePath(indexPath)),
                    pathType, preAscend,
                    new ExpandCollapseTreeNodeOperation(false));
        } catch (NumberFormatException e) {
            throw new StepExecutionException(e.getMessage(), EventFactory
                    .createActionError(TestErrorEvent.INVALID_INDEX));
        }
    }
    
    
    
    /**
     * Selects a node relative to the currently selected node.
     * @param direction the direction to move.
     *                  directions:
     *                      UP - Navigates through parents
     *                      DOWN - Navigates through children
     *                      NEXT - Navigates to next sibling
     *                      PREVIOUS - Navigates to previous sibling
     * @param distance the distance to move
     * @param clickCount the click count to select the new cell.
     * @throws StepExecutionException if any error occurs
     */
    public void gdMove(String direction, int distance, int clickCount) 
        throws StepExecutionException {
        
        AbstractTreeOperationContext context = getTreeAdapter().getContext();

        Object selectedNode = getSelectedNode(context);
        
        TreeNodeOperation selectOp = 
            new SelectTreeNodeOperation(
                    ClickOptions.create().setClickCount(clickCount));
        TreeNodeOperationConstraint constraint = 
            new TreeNodeOperationConstraint();

        if (CompSystemConstants.TREE_MOVE_UP.equalsIgnoreCase(direction)) {
            AbstractTreeNodeTraverser traverser = 
                new ParentTraverser(context, distance, constraint);
            traverser.traversePath(selectOp, selectedNode);
        } else if (CompSystemConstants
                .TREE_MOVE_DOWN.equalsIgnoreCase(direction)) {
            TreeNodeOperation expandOp = 
                new ExpandCollapseTreeNodeOperation(false);
            AbstractTreeNodeTraverser expandTraverser = 
                new ChildTraverser(context, distance - 1);
            expandTraverser.traversePath(expandOp, selectedNode);

            AbstractTreeNodeTraverser selectTraverser = 
                new ChildTraverser(context, distance, constraint);
            selectTraverser.traversePath(selectOp, selectedNode);
            
        } else if (CompSystemConstants
                .TREE_MOVE_NEXT.equalsIgnoreCase(direction)) {
            // Look through siblings
            AbstractTreeNodeTraverser traverser = 
                new SiblingTraverser(context, distance, true, constraint);
            traverser.traversePath(selectOp, selectedNode);
            
        } else if (CompSystemConstants
                .TREE_MOVE_PREVIOUS.equalsIgnoreCase(direction)) {
            // Look through siblings
            AbstractTreeNodeTraverser traverser = 
                new SiblingTraverser(context, distance, false, constraint);
            traverser.traversePath(selectOp, selectedNode);
        }

    }
    
    /**
     * Selects the node at the end of the <code>treepath</code>.
     *
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes
     *            above the current node. Absolute traversals ignore this
     *            parameter.
     * @param treePath The tree path.
     * @param operator If regular expressions are used to match the tree path
     * @param clickCount the click count
     * @param button what mouse button should be used
     * @param extendSelection Whether this selection extends a previous 
     *                        selection.
     * @throws StepExecutionException If the tree path is invalid, if the
     * double-click to expand the node fails, or if the selection is invalid.
     */
    public void gdSelect(String pathType, int preAscend, String treePath,
            String operator, int clickCount, int button, 
            final String extendSelection)
        throws StepExecutionException {
        selectByPath(pathType, preAscend,
                createStringNodePath(splitTextTreePath(treePath), operator),
                ClickOptions.create()
                    .setClickCount(clickCount)
                    .setMouseButton(button)
                    .setClickModifier(getClickModifier(extendSelection)));
    }
    /**
     * Selects the last node of the path given by <code>indexPath</code>
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes
     *            above the current node. Absolute traversals ignore this
     *            parameter.
     * @param indexPath the index path
     * @param clickCount the number of times to click
     * @param button what mouse button should be used
     * @param extendSelection Whether this selection extends a previous 
     *                        selection.
     * @throws StepExecutionException if <code>indexPath</code> is not a valid
     * path
     */
    public void gdSelectByIndices(String pathType, int preAscend,
            String indexPath, int clickCount, int button,
            final String extendSelection) 
        throws StepExecutionException {
        
        selectByPath(pathType, preAscend,
                createIndexNodePath(splitIndexTreePath(indexPath)),
                ClickOptions.create()
                .setClickCount(clickCount)
                .setMouseButton(button)
                .setClickModifier(getClickModifier(extendSelection)));
    }
    
    /**
     * Tests whether the given treePath exists or not
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes
     *            above the current node. Absolute traversals ignore this
     *            parameter.
     * @param treePath the path to check
     * @param operator the RegEx operator
     * @param exists if true, the verify succeeds if the path DOES exist.
     *  If false, the verify succeeds if the path DOES NOT exist.
     */
    public void gdVerifyPath(String pathType, int preAscend,
            String treePath, String operator, boolean exists) {
        try {
            gdExpand(pathType, preAscend, treePath, operator);
        } catch (StepExecutionException e) {
            if (exists) {
                throw new StepVerifyFailedException(
                        "Verify failed on tree-path: " //$NON-NLS-1$
                                + treePath, EventFactory.createVerifyFailed(
                                        treePath, StringConstants.EMPTY));
            }
            return;
        }
        if (!exists) {
            throw new StepVerifyFailedException("Verify failed on tree-path: ",  //$NON-NLS-1$
                EventFactory.createVerifyFailed(
                        StringConstants.EMPTY, treePath));
        }
    }

    /**
     * Tests whether the given treePath exists or not
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes
     *            above the current node. Absolute traversals ignore this
     *            parameter.
     * @param treePath the path to check
     * @param exists if true, the verify succeeds if the path DOES exist.
     *  If false, the verify succeeds if the path DOES NOT exist.
     */
    public void gdVerifyPathByIndices(String pathType, int preAscend,
            String treePath, boolean exists) {
        try {
            gdExpandByIndices(pathType, preAscend, treePath);
        } catch (StepExecutionException e) {
            if (exists) {
                throw new StepVerifyFailedException("Verify failed on tree-path: " //$NON-NLS-1$
                    + treePath,
                    EventFactory.createVerifyFailed(treePath, 
                            StringConstants.EMPTY));
            }
            return;
        }
        if (!exists) {
            throw new StepVerifyFailedException("Verify failed on tree-path: ",  //$NON-NLS-1$
                EventFactory.createVerifyFailed(
                        StringConstants.EMPTY, treePath));
        }
    }
    
    /**
     * {@inheritDoc}
     */
    public String gdStoreSelectedNodeValue(String variable) {
        AbstractTreeOperationContext context = getTreeAdapter().getContext();
        Object selectedNode = 
            getSelectedNode(context);
        if (selectedNode == null) {
            throw new StepExecutionException("No tree item selected", //$NON-NLS-1$ 
                EventFactory.createActionError(TestErrorEvent.NO_SELECTION));
        }
        
        return context.getRenderedText(selectedNode);
    }
    
    /**
     * Returns the text from the mouse position.
     * @param variable -
     * @return the text from the node at mouse position
     */
    public String gdStoreValueAtMousePosition(String variable) {
        AbstractTreeOperationContext context = getTreeAdapter().getContext();
        
        return context.getRenderedText(getNodeAtMousePosition());
    }
    /**
     * 
     * @return the tree node at the current mouse position.
     * @throws StepExecutionException If no tree node can be found at the 
     *                                current mouse position.
     */
    protected abstract Object getNodeAtMousePosition() 
        throws StepExecutionException;

    /**
     * Verifies whether the first selection in the tree has a rendered text that is
     * equal to <code>selection</code>.
     *
     * @param selection
     *            The selection to verify
     * @throws StepExecutionException
     *             If no node is selected or the verification fails.
     */
    public void gdVerifySelectedValue(String selection)
        throws StepExecutionException {
        gdVerifySelectedValue(selection, MatchUtil.DEFAULT_OPERATOR);
    }

    /**
     * Verifies whether the first selection in the tree has a rendered text that is
     * equal to <code>pattern</code>.
     *
     * @param pattern
     *            The expected text
     * @param operator
     *            The operator to use when comparing the expected and
     *            actual values.
     * @throws StepExecutionException
     *             If no node is selected or the verification fails.
     */
    public void gdVerifySelectedValue(String pattern, String operator)
        throws StepExecutionException {

        AbstractTreeOperationContext context = getTreeAdapter().getContext();
        checkNodeText(getSelectedNode(context), pattern, operator);
    }
    


    /**
     * Checks the text for the given node against the given pattern and 
     * operator.
     * 
     * @param node The node containing the text to check.
     * @param pattern The expected text.
     * @param operator The operator to use when comparing the expected and
     *          actual values.
     * @throws StepVerifyFailedException If the verification fails.
     */
    protected void checkNodeText(Object node, String pattern, String operator) 
        throws StepVerifyFailedException {
        
        AbstractTreeOperationContext context = getTreeAdapter().getContext();
        Collection nodeTextList = context.getNodeTextList(node);
        Iterator it = nodeTextList.iterator();
        boolean isMatched = false;
        while (it.hasNext() && !isMatched) {
            try {
                Verifier.match((String)it.next(), pattern, operator);
                isMatched = true;
            } catch (StepVerifyFailedException svfe) {
                if (!it.hasNext()) {
                    throw svfe;
                }
                // Otherwise just try the next element
            }
        }
    }
    
    /**
     * @param pathType  For example, "relative" or "absolute".
     * @param preAscend Relative traversals will start this many parent nodes
     *            above the current node. Absolute traversals ignore this
     *            parameter.
     * @param context The context of the traversal.
     * @return The node at which to begin the traversal or <code>null</code>
     *         if the traversal should begin at the root of the node.
     */
    protected Object getStartNode(String pathType, int preAscend,
            AbstractTreeOperationContext context) {
        Object startNode;
        ITreeAdapter tree = getTreeAdapter();
        if (pathType.equals(
                CompSystemConstants.TREE_PATH_TYPE_RELATIVE)) {
            startNode = getSelectedNode(context);
            Object child = startNode;
            for (int i = 0; i < preAscend; ++i) {
                if ((startNode == null) || ((tree.isRootVisible()) 
                        && (tree.getRootNode() == null))) {
                    TestErrorEvent event = EventFactory
                        .createActionError(TestErrorEvent.TREE_NODE_NOT_FOUND);
                    throw new StepExecutionException(
                        "Tree node not found: Parent of " //$NON-NLS-1$
                        + child.toString(), event);
                }
                child = startNode;
                startNode = context.getParent(startNode);
                
            }
         // Extra handling for tree without visible root node
            if ((startNode == null) || ((tree.isRootVisible()) 
                    && (tree.getRootNode() == null))) {
                startNode = null;
            }
        } else if (pathType.equals(
                CompSystemConstants.TREE_PATH_TYPE_ABSOLUTE)) {
            startNode = null;
        } else {
            throw new StepExecutionException(
                    pathType + " is not a valid Path Type", EventFactory //$NON-NLS-1$
                    .createActionError(TestErrorEvent.INVALID_PARAM_VALUE));

        }
        
        return startNode;
    }
    
    /**
     * @param mouseButton mouseButton
     * @param modifierSpecification modifierSpecification
     * @param pathType pathType
     * @param preAscend preAscend
     * @param treeTextPath treeTextPath
     * @param operator operator */ 
    public abstract void gdDragByTextPath(
        int mouseButton, 
        String modifierSpecification, 
        String pathType, 
        int preAscend, 
        String treeTextPath, 
        String operator);

    /**
     * @param pathType pathType
     * @param preAscend preAscend
     * @param treeTextPath treeTextPath
     * @param operator operator
     * @param delayBeforeDrop delayBeforeDrop */ 
    public abstract void gdDropByTextPath(
        String pathType, 
        int preAscend, 
        String treeTextPath, 
        String operator, 
        int delayBeforeDrop);

    /**
     * @param mouseButton mouseButton
     * @param modifierSpecification modifierSpecification
     * @param pathType pathType
     * @param preAscend preAscend
     * @param treeIndexPath treeIndexPath */ 
    public abstract void gdDragByIndexPath(
        int mouseButton, 
        String modifierSpecification, 
        String pathType, 
        int preAscend, 
        String treeIndexPath);

    /**
     * @param pathType pathType
     * @param preAscend preAscend
     * @param treeIndexPath treeIndexPath
     * @param delayBeforeDrop delayBeforeDrop */ 
    public abstract void gdDropByIndexPath(
        String pathType, 
        int preAscend, 
        String treeIndexPath, 
        int delayBeforeDrop);

    
    
}




/*******************************************************************************
 * 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 org.eclipse.jubula.rc.common.AUTServer;
import org.eclipse.jubula.rc.common.driver.IRobot;
import org.eclipse.jubula.rc.common.driver.IRobotFactory;
import org.eclipse.jubula.rc.common.exception.RobotException;
import org.eclipse.jubula.rc.common.implclasses.IBaseImplementationClass;
import org.eclipse.jubula.rc.common.uiadapter.factory.GUIAdapterFactoryRegistry;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;
/**
 * Implementation of basic functions for all tester classes. This class
 * gives the basic functions which are needed for testing.
 * 
 * 
 * @author BREDEX GmbH
 */
public abstract class AbstractUICAPs implements IBaseImplementationClass {

    
    
    /** constants for communication */
    protected static final String POS_UNIT_PIXEL = "Pixel"; //$NON-NLS-1$
    
    /** constants for communication */
    protected static final String POS_UNI_PERCENT = "Percent"; //$NON-NLS-1$
    /**    */
    private IComponentAdapter m_component;


    /**
     * Gets the Robot. 
     * @return The Robot
     * @throws RobotException If the Robot cannot be created.
     */
    protected IRobot getRobot() throws RobotException {
        return AUTServer.getInstance().getRobot();
    }
    /**
     * Gets the Robot factory. The factory is created once per instance.
     * @return The Robot factory.
     */
    protected abstract IRobotFactory getRobotFactory();
    
    /**
     * {@inheritDoc}
     */
    public void setComponent(Object graphicsComponent) {
        GUIAdapterFactoryRegistry afr = GUIAdapterFactoryRegistry.getInstance();
        m_component = null;
        IComponentAdapter adapter = 
                (IComponentAdapter)afr.getAdapter(graphicsComponent);
        m_component = adapter;
    }
    /**
     * Getter for the stored GraphicalComponent
     * @return gets the stored IComponentAdapter
     */
    public IComponentAdapter getComponent() {
        return m_component;
    }

    
    
    

    
}




/*******************************************************************************
 * 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 org.eclipse.jubula.rc.common.CompSystemConstants;
import org.eclipse.jubula.rc.common.driver.ClickOptions;
import org.eclipse.jubula.rc.common.driver.ClickOptions.ClickModifier;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.implclasses.Verifier;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IWidgetAdapter;
/**
 * Implementation of basic functions for a lot of graphics components
 * except for context menus and menus. 
 * 
 * @author BREDEX GmbH
 */
public abstract class AbstractWidgetCAPs extends AbstractUICAPs {

    
    /**
     * Casts the IComponentAdapter to an IWidgetAdapter for better access
     * @return The widgetAdapter
     */
    private IWidgetAdapter getWidgetAdapter() {
        return (IWidgetAdapter) getComponent();
    }
    
    /**
     * Verifies that the component exists and is visible.
     *
     * @param exists  <code>True</code> if the component is expected to exist
     *            and be visible, otherwise <code>false</code>.
     */
    public void gdVerifyExists(boolean exists) {
        Verifier.equals(exists, getWidgetAdapter().isShowing());
    }


    /**
     * Verifies if the component has the focus.
     * @param hasFocus <code>True</code> if the component is expected to has 
     *                  the focus, otherwise <code>false</code>
     */
    public void gdVerifyFocus(boolean hasFocus) {
        Verifier.equals(hasFocus, getWidgetAdapter().hasFocus());
    }
    /**
     * Verifies if the component is enabled
     * @param enabled <code>True</code> if the component is expected to be 
     *                  enabled, otherwise <code>false</code>
     */
    public void gdVerifyEnabled(boolean enabled) {
        Verifier.equals(enabled, getWidgetAdapter().isEnabled());
    }
    
    /**
     * Verifies the value of the property with the name <code>name</code>.
     * The name of the property has be specified according to the JavaBean
     * specification. The value returned by the property is converted into a
     * string by calling <code>toString()</code> and is compared to the passed
     * <code>value</code>.
     * 
     * @param name The name of the property
     * @param value The value of the property as a string
     * @param operator The operator used to verify
     */
    public void gdVerifyProperty(final String name, String value,
            String operator) {
        
        final IWidgetAdapter bean = (IWidgetAdapter) getComponent();
        bean.getPropteryValue(name);

        final String propToStr = bean.getPropteryValue(name);
        Verifier.match(propToStr, value, operator);
    }

    
    /**
     * Clicks the center of the component.
     * @param count Number of mouse clicks
     * @param button Pressed button
     */
    public void gdClick(int count, int button) {
        getRobot().click(getComponent().getRealComponent(), null,
                ClickOptions.create()
                    .setClickCount(count)
                    .setMouseButton(button));
    }
    /**
     * clicks into a component.
     *
     * @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 {

        getRobot().click(getComponent().getRealComponent(), null,
                ClickOptions.create()
                    .setClickCount(count)
                    .setMouseButton(button),
                xPos, xUnits.equalsIgnoreCase(POS_UNIT_PIXEL),
                yPos, yUnits.equalsIgnoreCase(POS_UNIT_PIXEL));
    }
    
    /**
     * Performs a Drag. Moves into the middle of the Component and presses and
     * holds the given modifier and the given mouse button.
     * @param mouseButton the mouse button.
     * @param modifier the modifier, e.g. shift, ctrl, etc.
     * @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
     */
    public void gdDrag(int mouseButton, String modifier, int xPos,
            String xUnits, int yPos, String yUnits) {
        getWidgetAdapter().gdDrag(mouseButton, modifier, xPos, xUnits,
                yPos, yUnits);
    }


    /**
     * Performs a Drop. Moves into the middle of the Component and releases
     * the modifier and mouse button pressed by gdDrag.
     * @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
     * @param delayBeforeDrop the amount of time (in milliseconds) to wait
     *                        between moving the mouse to the drop point and
     *                        releasing the mouse button
     */
    public void gdDrop(int xPos, String xUnits, int yPos, String yUnits,
            int delayBeforeDrop) {

        getWidgetAdapter().gdDrop(xPos, xUnits, yPos, yUnits,
               delayBeforeDrop);
    }
    
    /**
     * dummy method for "wait for component"
     * @param timeout the maximum amount of time to wait for the component
     * @param delay the time to wait after the component is found
     * {@inheritDoc}
     */
    public void gdWaitForComponent (int timeout, int delay) {
        // do NOT delete this method!
        // do nothing, implementation is in class CAPTestCommand.getImplClass
        // because this action needs a special implementation!
    }
    
    /**
     * Stores the value of the property with the name <code>name</code>.
     * The name of the property has be specified according to the JavaBean
     * specification. The value returned by the property is converted into a
     * string by calling <code>toString()</code> and is stored to the passed
     * variable.
     * 
     * @param variableName The name of the variable to store the property value in
     * @param propertyName The name of the property
     * @return the property value.
     */
    public String gdStorePropertyValue(String variableName, 
        final String propertyName) {
        IWidgetAdapter bean = (IWidgetAdapter) getComponent();

        return bean.getPropteryValue(propertyName);
    }
    
    /**
     * Select an item in the popup menu
     * @param indexPath path of item indices
     * @param button MouseButton
     * @throws StepExecutionException error
     */
    public void gdPopupSelectByIndexPath(String indexPath, int button)
        throws StepExecutionException {

        AbstractMenuCAPs popup = getWidgetAdapter().showPopup(button);
        popup.selectMenuItemByIndexpath(indexPath);
    }
    /**
     * Selects an item in the popup menu
     * @param textPath path of item texts
     * @param operator operator used for matching
     * @param button MouseButton
     * @throws StepExecutionException error
     */
    public void gdPopupSelectByTextPath(String textPath, String operator,
            int button)
        throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter().showPopup(button);
        popup.selectMenuItem(textPath, operator);
    }
    /**
     * Selects an item in the popup menu
     *
     * @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
     * @param textPath path of item texts
     * @param operator operator used for matching
     * @param button MouseButton
     * @throws StepExecutionException error
     */
    public void gdPopupSelectByTextPath(final int xPos, final String xUnits, 
            final int yPos, final String yUnits, 
            String textPath, String operator, int button)
        throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter()
                .showPopup(xPos, xUnits, yPos, yUnits, button);
        popup.selectMenuItem(textPath, operator);
    }
    
    /**
     * Opens the popup menu at the given position relative the current component
     * and selects an item at the given position in the popup menu
     *
     * @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
     * @param indexPath path of item indices
     * @param button MouseButton
     * @throws StepExecutionException error
     */
    public void gdPopupSelectByIndexPath(
            int xPos, String xUnits, int yPos, String yUnits, 
            String indexPath, int button) throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter().showPopup(button);
        popup.selectMenuItemByIndexpath(indexPath);
    }
    
    /**
     * Checks if the specified context menu entry is enabled.
     * @param indexPath the menu item to verify
     * @param enabled for checking enabled or disabled
     * @param button MouseButton
     */
    public void gdPopupVerifyEnabledByIndexPath(String indexPath,
            boolean enabled, int button)
        throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter().showPopup(button);        
        popup.verifyEnabledByIndexpath(indexPath, enabled);
    }
    
  
    /**
     * Opens the popup menu at the given position relative the current component
     * and checks if the specified context menu entry is enabled.
     * @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
     * @param indexPath the menu item to verify
     * @param enabled for checking enabled or disabled
     * @param button MouseButton
     */
    public void gdPopupVerifyEnabledByIndexPath(int xPos, String xUnits, 
            int yPos, String yUnits, String indexPath, 
            boolean enabled, int button) throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter()
                .showPopup(xPos, xUnits, yPos, yUnits, button);
        popup.verifyEnabledByIndexpath(indexPath, enabled);
    }
    
    /**
     * Checks if the specified context menu entry is enabled.
     * @param textPath the menu item to verify
     * @param operator operator used for matching
     * @param enabled for checking enabled or disabled
     * @param button MouseButton
     */
    public void gdPopupVerifyEnabledByTextPath(String textPath,
            String operator, boolean enabled, int button)
        throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter().showPopup(button);
        popup.verifyEnabled(textPath, operator, enabled);
    }
    
    /**
     * Opens the popup menu at the given position relative the current component
     * and checks if the specified context menu entry is enabled.
     * @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
     * @param textPath the menu item to verify
     * @param operator operator used for matching
     * @param enabled for checking enabled or disabled
     * @param button MouseButton
     */
    public void gdPopupVerifyEnabledByTextPath(final int xPos, 
            final String xUnits, final int yPos,
            final String yUnits, String textPath, String operator,
                boolean enabled, int button)
        throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter()
                .showPopup(xPos, xUnits, yPos, yUnits, button);
        popup.verifyEnabled(textPath, operator, enabled);
    }
    
    /**
     * Checks if the specified context menu entry is selected.
     * @param indexPath the menu item to verify
     * @param selected for checking if entry is selected
     * @param button MouseButton
     */
    public void gdPopupVerifySelectedByIndexPath(String indexPath,
            boolean selected, int button)
        throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter().showPopup(button);
        popup.verifySelectedByIndexpath(indexPath, selected);
    }
    
    /**
     * Opens the popup menu at the given position relative the current component
     * and checks if the specified context menu entry is selected.
     * @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
     * @param indexPath the menu item to verify
     * @param selected for checking if entry is selected
     * @param button MouseButton
     */
    public void gdPopupVerifySelectedByIndexPath(int xPos, String xUnits, 
            int yPos, String yUnits, String indexPath, boolean selected, 
            int button) throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter()
                .showPopup(xPos, xUnits, yPos, yUnits, button);
        popup.verifySelectedByIndexpath(indexPath, selected);
    }
    
    /**
     * Checks if the specified context menu entry is selected.
     * @param textPath the menu item to verify
     * @param operator operator used for matching
     * @param selected for checking if entry is selected
     * @param button MouseButton
     */
    public void gdPopupVerifySelectedByTextPath(String textPath,
            String operator, boolean selected, int button)
        throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter().showPopup(button);
        popup.verifySelected(textPath, operator, selected);
    }
    
    /**
     * Opens the popup menu at the given position relative the current component
     * and checks if the specified context menu entry is selected.
     * @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
     * @param textPath the menu item to verify
     * @param operator operator used for matching
     * @param selected for checking if entry is selected
     * @param button MouseButton
     */
    public void gdPopupVerifySelectedByTextPath(final int xPos, 
            final String xUnits, final int yPos,
            final String yUnits, String textPath, String operator,
                boolean selected, int button)
        throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter()
                .showPopup(xPos, xUnits, yPos, yUnits, button);
        popup.verifySelected(textPath, operator, selected);
    }
    
    /**
     * Checks if the specified context menu entry exists.
     * @param indexPath the menu item to verify
     * @param exists for checking if entry exists
     * @param button MouseButton
     */
    public void gdPopupVerifyExistsByIndexPath(String indexPath,
            boolean exists, int button)
        throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter().showPopup(button);
        popup.verifyExistsByIndexpath(indexPath, exists);      
    }
    
    /**
     * Opens the popup menu at the given position relative the current component
     * and checks if the specified context menu entry exists.
     * @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
     * @param indexPath the menu item to verify
     * @param exists for checking if entry exists
     * @param button MouseButton
     */
    public void gdPopupVerifyExistsByIndexPath(int xPos, String xUnits, 
            int yPos, String yUnits, String indexPath, 
            boolean exists, int button) throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter()
                .showPopup(xPos, xUnits, yPos, yUnits, button);
        popup.verifyExistsByIndexpath(indexPath, exists);
    }
    
    /**
     * Checks if the specified context menu entry exists.
     * @param textPath the menu item to verify
     * @param operator operator used for matching
     * @param exists for checking if entry exists
     * @param button MouseButton
     */
    public void gdPopupVerifyExistsByTextPath(String textPath,
            String operator, boolean exists, int button)
        throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter().showPopup(button);
        popup.verifyExists(textPath, operator, exists);
    }
    
    /**
     * Opens the popup menu at the given position relative the current component
     * and checks if the specified context menu entry exists.
     * @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
     * @param textPath the menu item to verify
     * @param operator operator used for matching
     * @param exists for checking if entry exists
     * @param button MouseButton
     */
    public void gdPopupVerifyExistsByTextPath(final int xPos, 
            final String xUnits, final int yPos,
            final String yUnits, String textPath, String operator,
            boolean exists, int button)
        throws StepExecutionException {
        AbstractMenuCAPs popup = getWidgetAdapter()
                .showPopup(xPos, xUnits, yPos, yUnits, button);
        popup.verifyExists(textPath, operator, exists);
    }
    /**
     * 
     * @param extendSelection
     *            the string to indicate that the selection should be extended
     * @return a ClickModifier for the given extend selection
     */
    protected ClickModifier getClickModifier(String extendSelection) {
        // FIXME This is a method which belongs in an upper class
        
        ClickModifier cm = ClickModifier.create();
        if (CompSystemConstants.EXTEND_SELECTION_YES
                .equalsIgnoreCase(extendSelection)) {
            cm.add(ClickModifier.M1);
        }
        return cm;
    }
    
    /**
     * Simulates a tooltip for demonstration purposes.
     *
     * @param text The text to show in the tooltip
     * @param textSize The size of the text in points
     * @param timePerWord The amount of time, in milliseconds, used to display a
     *                    single word. A word is defined as a string surrounded
     *                    by whitespace.
     * @param windowWidth The width of the tooltip window in pixels.
     */
    public void gdShowText(final String text, final int textSize,
        final int timePerWord, final int windowWidth) {
        getWidgetAdapter().showToolTip(text, textSize,
                timePerWord, windowWidth);
    }

}

Lines 30-35 public class DragAndDropHelper { Link Here

(-)a/org.eclipse.jubula.rc.common/src/org/eclipse/jubula/rc/common/driver/DragAndDropHelper.java (+18 lines)
30	/** Flag if the Mouse is in drag mode (pressed key) */	30	/** Flag if the Mouse is in drag mode (pressed key) */
31	private boolean m_isDragMode = false;	31	private boolean m_isDragMode = false;
32		32
		33	/** The Component to drag */
		34	private Object m_dragComponent = null;
		35
		36
33	/**	37	/**
34	* hidden singleton constructor.	38	* hidden singleton constructor.
35	*/	39	*/
Lines 92-95 public class DragAndDropHelper { Link Here
92	m_isDragMode = drag;	96	m_isDragMode = drag;
93	}	97	}
94		98
		99	/**
		100	* @return the dragComponent
		101	*/
		102	public Object getDragComponent() {
		103	return m_dragComponent;
		104	}
		105
		106	/**
		107	* @param dragComponent the dragComponent to set
		108	*/
		109	public void setDragComponent(Object dragComponent) {
		110	m_dragComponent = dragComponent;
		111	}
		112
95	}	113	}




/*******************************************************************************
 * 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.uiadapter.factory;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.jubula.rc.common.adaptable.IAdapterFactory;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;
/**
 * This factory registry holds all the toolkit specific factory's.
 * These factory's holding the classes which are implementing the component
 * specific interface. It could be an adapter or the specific component
 * implementing the interface.
 * 
 * You must register a factory before a test is started.
 * @author BREDEX GmbH
 *
 */
public class GUIAdapterFactoryRegistry {

    /**
     * Singleton instance of this class
     */
    private static GUIAdapterFactoryRegistry instance = 
        new GUIAdapterFactoryRegistry();

    /**
     * Map that manages the registration. Key is always a class Value is a
     * collection of IAdapterFactory
     */
    private Map m_registrationMap = new HashMap();

    /**
     * Call Constructor only by using getInstance
     */
    private GUIAdapterFactoryRegistry() {
    }

    /**
     * Return the singleton of this class
     * 
     * @return singleton
     */
    public static GUIAdapterFactoryRegistry getInstance() {
        return instance;
    }

    /**
     * Register adapter factory with all its supported classes
     * 
     * @param factory
     *            adapter factory that should be registered
     */
    public void registerFactory(IUIAdapterFactory factory) {
        Class[] supportedClasses = factory.getSupportedClasses();
        for (int i = 0; i < supportedClasses.length; i++) {
            m_registrationMap.put(supportedClasses[i], factory);
        }
    }

    /**
     * Sign off adapter factory from all its supported classes
     * 
     * @param factory
     *            adapter factory that should be signed off
     */
    public void signOffFactory(IAdapterFactory factory) {
        Class[] supportedClasses = factory.getSupportedClasses();
        for (int i = 0; i < supportedClasses.length; i++) {
            m_registrationMap.remove(supportedClasses[i]);
        }
    }
    /**
     * 
     * @param objectToAdapt 
     * @return -
     */
    public IComponentAdapter getAdapter(Object objectToAdapt) {
        Class adapteeclass = objectToAdapt.getClass();
        IUIAdapterFactory factory = (IUIAdapterFactory) m_registrationMap.
                get(adapteeclass);
        while (factory == null && adapteeclass != Object.class) {
            factory = (IUIAdapterFactory) m_registrationMap.
                get(adapteeclass.getSuperclass());
        }
        
        return factory.getAdapter(objectToAdapt);
        
    }
}




/*******************************************************************************
 * 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.uiadapter.factory;

import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;

/**
 * This is the interface for the factory which is used by the 
 * <code>AbstractUI</code> to get the specific Object which implements the
 * corresponding interface for the tester class.
 * 
 * @author BREDEX GmbH
 */
public interface IUIAdapterFactory {
    /**
     * @return all classes that will be supported by this adapter factory
     */
    Class[] getSupportedClasses();

    /**
     * Adapts object to adapt to a new object of type targetAdapterClass
     * 
     * @param objectToAdapt
     *            object that should be adapted
     * @return the adapter for the object to adapt of type targetAdapterClass
     */
    IComponentAdapter getAdapter(Object objectToAdapt);
}




/*******************************************************************************
 * 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.uiadapter.interfaces;

/**
 * Interface for all necessary methods to test buttons.
 * It extends the <code>IWidgetAdapter</code> to add button specific methods.
 * 
 * 
 * @author BREDEX GmbH
 */

public interface IButtonAdapter extends IWidgetAdapter {
    /**
     * Gets the text from the button
     * @return the text which is saved in the component
     */
    public String getText();

    /**
     * isSelected is mostly for RadioButtons and CheckBoxes
     * @return <code>true</code> if the component is selected
     */
    public boolean isSelected();
    /**
     * Action to read the value of a Button to store it in a variable
     * in the Client
     * @param variable the name of the variable
     * @return the text value.
     */
    public String  readValue(String variable);
   
}




/*******************************************************************************
 * 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.uiadapter.interfaces;
/**
 * This is the main interface for classes which will hold or be the
 * component that implement the methods we need for this
 * specific component to test .
 * 
 * @author BREDEX GmbH
 */
public interface IComponentAdapter {
    /**
     * Gets the toolkit specific component
     * @return toolkit specific component
     */
    public Object getRealComponent();
   
}




/*******************************************************************************
 * 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.uiadapter.interfaces;


/**
 * This interface is for the functionality of menus. This is only for the
 * not visible part of menus which only contains the next menuitems in the
 * Hierarchy of the menu.
 * 
 * @author BREDEX GmbH
 */
public interface IMenuAdapter extends IComponentAdapter {

    /**
     * 
     * @return the items of the menu
     */
    public IMenuItemAdapter[] getItems();

    /**
     * Gets the amount of items in the menu
     * 
     * @return the amount of Items in the menu (with Seperator)
     */
    public int getItemCount();
}




/*******************************************************************************
 * 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.uiadapter.interfaces;

/**
 * Interface for all necessary methods for testing menuitems.
 * 
 * @author BREDEX GmbH
 */
public interface IMenuItemAdapter extends IComponentAdapter {

    /**
     * 
     * @return the text which is saved in the item
     */
    public String getText();
    /**
     * 
     * @return <code>true</code> if the component is visible
     */
    public boolean isEnabled();
    /**
     * 
     * @return <code>true</code> if the component exists
     *         that means there is an item in this wrapper 
     */
    public boolean isExisting();
    /**
     * 
     * @return <code>true</code> if the component is selected
     * 
     */
    public boolean isSelected();
    /**
     * 
     * @return <code>true</code> if the component is Showing
     */
    public boolean isShowing();
    
    /** Gets the menu of the menuitem 
     * @return the menu which is attached to the item
     */
    public IMenuAdapter getMenu();
    
    /**
     * 
     * @return <code>true</code> if the menuitem has a menu
     */
    public boolean hasSubMenu();
    /**
     * Checks whether the given menu item is a separator. 
     * This method runs in the GUI thread.
     * @return <code>true</code> if <code>menuItem</code> is a separator item.
     *         Otherwise <code>false</code>.
     */
    public boolean isSeparator();
    
    /**
     * This Methods selects the specific menuItem with an click
     * or in another toolkit specitif way
     */
    public void selectMenuItem();
    
    /**
     * This method trys to open the the next Menu in the cascade
     * 
     * @return the next SubMenu in the Menu
     */
    public IMenuAdapter openSubMenu();
   
    
}




/*******************************************************************************
 * 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.uiadapter.interfaces;

import java.awt.Rectangle;

import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.implclasses.table.Cell;

/**
 * Interface for all necessary methods for testing tables.
 * 
 * @author BREDEX GmbH
 */
public interface ITableAdapter extends IWidgetAdapter {
    
    
    /**
     * Gets the number of columns
     * 
     * @return the number of columns
     */
    public int getColumnCount();
    
    /**
     * Gets the number of rows
     * 
     * @return the number of rows
     */
    public int getRowCount();
    
    /**
     * @param row the zero based index of the row
     * @param column the zero based index of the column
     * @return the text of the cell of the given coordinates
     */
    public String getCellText(int row, int column);
     
    /**
     * Returns the name of the column appearing in the view at
     * column position <code>column</code>.
     *
     * @param  column    the column in the view being queried
     * @return the name of the column at position <code>column</code>
            in the view where the first column is column 0
     */
    public String getColumnName(int column);
    
    /**
     * Gets column index from string with header name or index
     *
     * @param col Headername or index of column 
     * @param operator The operation used to verify
     * @return column index 
     */
    public int getColumnFromString(String col, String operator);
    
    /**
     * This is only for a specific case where tables could act
     * like lists. And the getText is not working.
     * If this is not the case for the component return <code>null</code>
     * @param row the row
     * @return the text of the row
     */
    public String getRowName(int row);
    
    /**
     * Gets row index from string with index or text of first row
     *
     * @param row index or value in first col
     * @param operator The operation used to verify
     * @return integer of String of row 
     */
    public int getRowFromString(String row, String operator);
    
    /**
     * gets header bounds for column
     * @param col The column.
     * @return The rectangle of the header
     */
    public Rectangle getHeaderBounds(int col);

    /**
     * @return The currently selected cell of the Table.
     * @throws StepExecutionException If no cell is selected.
     */
    public Cell getSelectedCell() throws StepExecutionException;
    
    /**
     * 
     * @return <code>true</code> if the Header is visible, <code>false</code> otherwise
     */
    public boolean isHeaderVisible();

    /**
     * 
     * @param row the row
     * @param col the column
     * @return <code>true</code> if the Cell is editable, <code>false</code> otherwise
     */
    public boolean isCellEditable(int row, int col);

    /**
     * @return true, if there is any cell selection in the table, false otherwise.
     */
    public boolean hasCellSelection();
    
    /**
     * Scrolls the passed cell (as row and column) to visible.<br>
     * This method must return null if there is no scrolling.
     * @param row The row.
     * @param col The column.
     * @return The rectangle of the cell.
     * @throws StepExecutionException If getting the cell rectangle or the scrolling fails.
     */
    public Rectangle scrollCellToVisible (int row , int col)
        throws StepExecutionException;
    

}




/*******************************************************************************
 * 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.uiadapter.interfaces;

import org.eclipse.jubula.rc.common.implclasses.tree.AbstractTreeOperationContext;

/**
 * Interface for all necessary methods for testing trees.
 * 
 * @author BREDEX GmbH
 */
public interface ITreeAdapter extends IWidgetAdapter {

    /**
     * Gets the root node(s) of the tree.
     * This could be either a single node or multiple nodes
     * @return The root node(s).
     */ 
    public Object getRootNode();
    
    /**
     * Gets the TreeOperationContext which is created through an
     * toolkit specific implementation.
     * @return the TreeOperationContext for the tree
     */
    public AbstractTreeOperationContext getContext();
    
    /**
     * 
     * @return The visibility of the Root Node
     */
    public boolean isRootVisible();
}




/*******************************************************************************
 * 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.uiadapter.interfaces;

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

/**
 * This interface defines basic functionality for nearly all UI components.
 * 
 * @author BREDEX GmbH
 */
public interface IWidgetAdapter extends IComponentAdapter {

    /**
     * 
     * @return <code>true</code> if the component is visible
     */
    public boolean isShowing();
    /**
     * 
     * @return <code>true</code> if the component is enabled
     */
    public boolean isEnabled();
    /**
     * 
     * @return <code>true</code> if the component has focus
     */
    public boolean hasFocus();
    /**
     * @param propertyname the name of the property value to return
     * @return the property value
     */
    public String getPropteryValue(String propertyname);
    
    
    /**
     * Shows and returns the popup menu
     *
     * @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
     * @param button MouseButton
     * @return the popup menu
     * @throws StepExecutionException error
     */
    public AbstractMenuCAPs showPopup(final int xPos, 
            final String xUnits, final int yPos,
            final String yUnits, final int button)
        throws StepExecutionException;
    
    /**
     * Shows and returns the popup menu
     * @param button MouseButton
     * @return the popup menu
     */
    public AbstractMenuCAPs showPopup(int button);
    
    
    
    /**
     * Simulates a tooltip for demonstration purposes.
     *
     * @param text The text to show in the tooltip
     * @param textSize The size of the text in points
     * @param timePerWord The amount of time, in milliseconds, used to display a
     *                    single word. A word is defined as a string surrounded
     *                    by whitespace.
     * @param windowWidth The width of the tooltip window in pixels.
     */
    public void showToolTip(final String text, final int textSize,
            final int timePerWord, final int windowWidth);
    
    /**
     * Performs a Drag. Moves into the middle of the Component and presses and
     * holds the given modifier and the given mouse button.
     * @param mouseButton the mouse button.
     * @param modifier the modifier, e.g. shift, ctrl, etc.
     * @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
     */
    public void gdDrag(int mouseButton, String modifier, int xPos,
            String xUnits, int yPos, String yUnits);
    
    /**
     * Performs a Drop. Moves into the middle of the Component and releases
     * the modifier and mouse button pressed by gdDrag.
     * @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
     * @param delayBeforeDrop the amount of time (in milliseconds) to wait
     *                        between moving the mouse to the drop point and
     *                        releasing the mouse button
     */
    public void gdDrop(int xPos, String xUnits, int yPos, String yUnits,
            int delayBeforeDrop);

}




import org.eclipse.jubula.rc.common.driver.IRobot;
import org.eclipse.jubula.rc.common.driver.IRobotFactory;
import org.eclipse.jubula.rc.common.listener.BaseAUTListener;
import org.eclipse.jubula.rc.common.uiadapter.factory.GUIAdapterFactoryRegistry;
import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig;
import org.eclipse.jubula.rc.swing.listener.CheckListener;
import org.eclipse.jubula.rc.swing.listener.ComponentHandler;
import org.eclipse.jubula.rc.swing.listener.FocusTracker;
import org.eclipse.jubula.rc.swing.listener.MappingListener;
import org.eclipse.jubula.rc.swing.listener.RecordListener;
import org.eclipse.jubula.rc.swing.swing.uiadapter.factory.SwingAdapterFactory;
import org.eclipse.jubula.tools.constants.AUTServerExitConstants;
import org.eclipse.jubula.tools.constants.DebugConstants;
import org.eclipse.jubula.tools.utils.EnvironmentUtils;

        }
        
        AUTServer.getInstance().invokeAUT();
        
        // FIXME dont know where to put
        GUIAdapterFactoryRegistry.getInstance().
            registerFactory(new SwingAdapterFactory());
        System.out.println("AdapterFactory registered"); //$NON-NLS-1$
    }

    /**




/*******************************************************************************
 * 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 org.eclipse.jubula.rc.common.driver.IRobotFactory;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IButtonAdapter;
import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig;

/**
 * The implementation class for <code>AbstractButton</code> and subclasses. Note
 * the "Abstract" in the class name implies only that this class can test
 * <code>AbstractButton</code> components. The class itself should <em>NOT</em>
 * be designated <code>abstract</code>, as this class is instantiated using
 * reflection.
 * 
 * @author BREDEX GmbH
 */
public class AbstractButtonCAPs 
    extends org.eclipse.jubula.rc.common.caps.AbstractButtonCAPs {

    /** Robot Factory*/
    private IRobotFactory m_robotFactory;

    /**
     * Clicks the button <code>count</code> times.
     * 
     * @param count The number of clicks
     */
    public void gdClick(int count) {
        gdClick(count, 1);
    }

    /**
     * {@inheritDoc}
     */
    public String[] getTextArrayFromComponent() {
        IButtonAdapter returnvalue = ((IButtonAdapter)getComponent());
        return new String[] { returnvalue.getText() };
    }

    /** 
     * {@inheritDoc}
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }

}




/*******************************************************************************
 * 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.Container;
import java.awt.event.ContainerEvent;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.StringTokenizer;

import javax.swing.AbstractButton;
import javax.swing.JLabel;
import javax.swing.JPopupMenu;
import javax.swing.JToggleButton;
import javax.swing.text.JTextComponent;

import org.eclipse.jubula.rc.common.AUTServer;
import org.eclipse.jubula.rc.common.adaptable.AdapterFactoryRegistry;
import org.eclipse.jubula.rc.common.adaptable.ITextRendererAdapter;
import org.eclipse.jubula.rc.common.driver.IRobot;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.util.KeyStrokeUtil;
import org.eclipse.jubula.rc.swing.swing.driver.KeyCodeConverter;
import org.eclipse.jubula.rc.swing.swing.implclasses.EventListener;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;

/**
 * Util class for Swing specific aspects.
 * 
 * @author BREDEX GmbH
 */
public class CapUtil {

    /**
     * <code>RENDERER_FALLBACK_TEXT_GETTER_METHOD_1</code>
     */
    public static final String RENDERER_FALLBACK_TEXT_GETTER_METHOD_1 = "getTestableText"; //$NON-NLS-1$

    /**
     * <code>RENDERER_FALLBACK_TEXT_GETTER_METHOD_2</code>
     */
    public static final String RENDERER_FALLBACK_TEXT_GETTER_METHOD_2 = "getText"; //$NON-NLS-1$
      
   
    /**
     * Is true, if a popup menu is shown
     */
    public static class PopupShownCondition implements
        EventListener.Condition {

    /**
     * the popup menu
     */
        private JPopupMenu m_popup = null;
        
    /**
     *
     * @return the popup menu
     */
        public JPopupMenu getPopup() {
            return m_popup;
        }

    /**
     * {@inheritDoc}
     * @param event event
     * @return result of the condition
     */
        public boolean isTrue(AWTEvent event) {
            if (event.getID() != ContainerEvent.COMPONENT_ADDED) {
                return false;
            }
            ContainerEvent ce = (ContainerEvent)event;
            if (ce.getChild() instanceof JPopupMenu) {
                m_popup = (JPopupMenu)ce.getChild();
                return true;
            } else if (ce.getChild() instanceof Container) {
                Container popupContainer = (Container)ce.getChild();
                final int length = popupContainer.getComponents().length;
                for (int i = 0; i < length; i++) {
                    if (popupContainer.getComponents()[i]
                                                       instanceof JPopupMenu) {
        
                        m_popup = (JPopupMenu)popupContainer.getComponents()[i];
                        return true;
                    }
                }
            }
            return false;
        }
    }
    /**
     * 
     */
    private CapUtil() { }
    
    /**
     * 
     * @return the Robot
     */
    public static IRobot getRobot() {
        return AUTServer.getInstance().getRobot();
    }


    /**
     * Presses or releases the given modifier.
     * @param modifier the modifier.
     * @param press if true, the modifier will be pressed.
     * if false, the modifier will be released.
     */
    public static void pressOrReleaseModifiers(String modifier, boolean press) {
        final IRobot robot = getRobot();
        final StringTokenizer modTok = new StringTokenizer(
                KeyStrokeUtil.getModifierString(modifier), " "); //$NON-NLS-1$
        while (modTok.hasMoreTokens()) {
            final String mod = modTok.nextToken();
            final int keyCode = KeyCodeConverter.getKeyCode(mod);
            if (press) {
                robot.keyPress(null, keyCode);
            } else {
                robot.keyRelease(null, keyCode);
            }
        }
    }
     
    /**
     * @param renderer
     *            The component which is used as the renderer
     * @return The string that the renderer displays.
     * @throws StepExecutionException
     *             If the renderer component is not of type <code>JLabel</code>,
     *             <code>JToggleButton</code>, <code>AbstractButton</code>,
     *             <code>JTextComponent</code> or supports one of the fallback 
     *             methods
     */
    public static String getRenderedText(Component renderer)
        throws StepExecutionException {
        String renderedText = resolveRenderedText(renderer);
        if (renderedText != null) {
            return renderedText;
        }
        throw new StepExecutionException(
            "Renderer not supported: " + renderer.getClass(), //$NON-NLS-1$
            EventFactory.createActionError(
                    TestErrorEvent.RENDERER_NOT_SUPPORTED));
    }
    
    /**
     * @param renderer
     *            The component which is used as the renderer
     * @return The string that the renderer displays or <code>null</code> if it
     *         could not be resolved.
     */
    private static String resolveRenderedText(Component renderer) {
        if (renderer instanceof JLabel) {
            return ((JLabel)renderer).getText();
        } else if (renderer instanceof JToggleButton) {
            return ((JToggleButton)renderer).isSelected() ? Boolean.TRUE
                .toString() : Boolean.FALSE.toString();
        } else if (renderer instanceof AbstractButton) {
            return ((AbstractButton)renderer).getText();
        } else if (renderer instanceof JTextComponent) {
            return ((JTextComponent)renderer).getText();
        } 
        // Check if an adapter exists
        ITextRendererAdapter textRendererAdapter = 
            ((ITextRendererAdapter) AdapterFactoryRegistry
                .getInstance().getAdapter(
                        ITextRendererAdapter.class, renderer));
        if (textRendererAdapter != null) {
            return textRendererAdapter.getText();
        } else if (renderer != null) {
            String[] methodNames = new String[] {
                RENDERER_FALLBACK_TEXT_GETTER_METHOD_1,
                RENDERER_FALLBACK_TEXT_GETTER_METHOD_2 };
            for (int i = 0; i < methodNames.length; i++) {
                String text = getTextFromComponent(renderer, methodNames[i]);
                if (text != null) {
                    return text;
                }
            }
        }
        return null;
    }
    
    /**
     * @param obj
     *            the object to invoke the method for
     * @param getterName
     *            the name of the getter Method for string retrival
     * @return the return value of the given method name or <code>null</code> if
     *         something went wrong during method invocation
     */
    private static String getTextFromComponent(Object obj, String getterName) {
        String text = null;
        try {
            Method getter = null;
            Class objClass = obj.getClass();
            try {
                getter = objClass.getDeclaredMethod(getterName, null);
            } catch (NoSuchMethodException e) {
                // ignore
            } catch (SecurityException e) {
                // ignore
            }
            if (getter == null) {
                try {
                    getter = objClass.getMethod(getterName, null);
                } catch (NoSuchMethodException e) {
                    return text;
                } catch (SecurityException e) {
                    return text;
                }
            }
            getter.setAccessible(true);
            Object returnValue = getter.invoke(obj, null);
            if (returnValue instanceof String) {
                text = (String) returnValue;
            }
            return text;
        } catch (SecurityException e) {
            return text;
        } catch (IllegalArgumentException e) {
            return text;
        } catch (IllegalAccessException e) {
            return text;
        } catch (InvocationTargetException e) {
            return text;
        }
    }
}




/*******************************************************************************
 * 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.Component;
import java.awt.Container;
import java.awt.Window;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JPopupMenu;
import javax.swing.MenuElement;

import org.eclipse.jubula.rc.common.caps.AbstractMenuCAPs;
import org.eclipse.jubula.rc.common.driver.IRobotFactory;
import org.eclipse.jubula.rc.common.implclasses.IBaseImplementationClass;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;
import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig;
import org.eclipse.jubula.rc.swing.swing.implclasses.WindowHelper;
import org.eclipse.jubula.rc.swing.swing.uiadapter.JMenuItemAdapter;

/**
 * Toolkit specific commands for the <code>JMenuBar</code>.
 * 
 * @author BREDEX GmbH
 */
public class JMenuBarCAPs extends AbstractMenuCAPs 
    implements IBaseImplementationClass {
    
    /** The robot factory.  */
    private IRobotFactory m_robotFactory;
    /**
     * {@inheritDoc}
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }
        
    /**
     * {@inheritDoc}
     */
    public String[] getTextArrayFromComponent() {
        
        return null;
    }
    
    /**
     * Workaround to get the menu bar existing somewhere in the given 
     * container's hierarchy. This method should <b>only</b> be used if 
     * {@link JFrame#getJMenuBar()} / {@link JDialog#getJMenuBar()} return 
     * <code>null</code>, which is a very rare case.
     * 
     * This method also performs some unorthodox visibility testing in order
     * to avoid retrieving the wrong menu.
     * 
     * @param rootPane The root container from which to start the search for
     *                 the menu bar.
     * @return the first menu bar found in the hierarchy that: <ul>
     *          <li>is showing</li>
     *          <li>contains at least one visible menu</li>
     */
    private JMenuBar getMenuBarWorkaround(Container rootPane) {
        JMenuBar menuBar = null;
        List menuList = new ArrayList();
        collectMenuBarsWorkaround(rootPane, menuList);
        Iterator menuIter = menuList.iterator();
        while (menuIter.hasNext() && menuBar == null) {
            JMenuBar menu = (JMenuBar)menuIter.next();
            boolean hasAtLeastOneItem = false;
            MenuElement [] subElements = menu.getSubElements();
            for (int i = 0; 
                    i < subElements.length && !hasAtLeastOneItem; 
                    i++) {
                if (subElements[i] instanceof JMenu) {
                    JMenu subMenu = (JMenu)subElements[i];
                    hasAtLeastOneItem = 
                        subMenu != null && subMenu.isShowing();
                }
            }
            if (hasAtLeastOneItem) {
                menuBar = menu;
            }
        }
        return menuBar;
    }
    
    /**
     * Adds all menu bars found in the hierarchy <code>container</code> to 
     * <code>menuBarList</code>. This is part of a workaround for finding menus
     * in AUTs that don't make proper use of 
     * {@link JFrame#setJMenuBar()} / {@link JDialog#setJMenuBar()}.
     * 
     * @see #getMenuBarWorkaround(Container)
     * 
     * @param container The root container from which to start the search for
     *                  the menu bars. 
     * @param menuBarList The list to which each menu bar found will be added.
     *                    Only objects of type {@link JMenuBar} will be added
     *                    to this list.
     */
    private void collectMenuBarsWorkaround(
            Container container, List menuBarList) {
        Component [] children = container.getComponents();
        for (int i = 0; i < children.length; i++) {
            if (children[i] instanceof JMenuBar
                    && children[i].isShowing()) {
                menuBarList.add(children[i]);
            }
        }
        
        for (int i = 0; i < children.length; i++) {
            if (children[i] instanceof Container
                    && children[i].isVisible()) {
                collectMenuBarsWorkaround((Container)children[i], menuBarList);
            }
        }
        
    }
    /**
     * @return the component
     */
    public IComponentAdapter getComponent() {
        if (super.getComponent().getRealComponent() instanceof JPopupMenu) {
            return super.getComponent();
        }
        Window activeWindow = WindowHelper.getActiveWindow();
        if (activeWindow == null) {
            getLog().warn("JMenuBarImplClass.getComponent(): No active window."); //$NON-NLS-1$
        } else {
            JMenuBar menuBar = null;
            Container rootPane = null;
            if (activeWindow instanceof JDialog) {
                JDialog dialog = (JDialog)activeWindow;
                menuBar = dialog.getJMenuBar();
                rootPane = dialog.getRootPane();
            } else if (activeWindow instanceof JFrame) {
                JFrame frame = (JFrame)activeWindow;
                menuBar = frame.getJMenuBar();
                rootPane = frame.getRootPane();
            }

            if (menuBar == null) {
                menuBar = getMenuBarWorkaround(rootPane);
            }

            setComponent(menuBar);
        }
        return super.getComponent();
    }

    /**
     *{@inheritDoc}
     */
    protected void closeMenu(IMenuAdapter menuBar, String[] textPath,
            String operator) {
        if (menuBar.getRealComponent() instanceof JPopupMenu) {
            for (int i = 0; i < textPath.length; i++) {
                getRobot().keyType(menuBar.getRealComponent(),
                        KeyEvent.VK_ESCAPE);
            }
            return;
        }
        super.closeMenu(menuBar, textPath, operator);
            
    }
    
    /**
     *{@inheritDoc}
     */
    protected void closeMenu(IMenuAdapter menuBar, int[] path) {
        if (menuBar.getRealComponent() instanceof JPopupMenu) {
            for (int i = 0; i < path.length; i++) {
                getRobot().keyType(menuBar.getRealComponent(),
                        KeyEvent.VK_ESCAPE);
            }
            return;
        }
        super.closeMenu(menuBar, path);
    }
    
    /**
     * {@inheritDoc}
     */
    protected IMenuItemAdapter newMenuItemAdapter(Object component) {
        return new JMenuItemAdapter(component);
    }

}




/*******************************************************************************
 * 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.Component;
import java.awt.IllegalComponentStateException;
import java.awt.Point;
import java.awt.Rectangle;

import javax.swing.JTable;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;

import org.eclipse.jubula.rc.common.caps.AbstractTableCAPs;
import org.eclipse.jubula.rc.common.driver.ClickOptions;
import org.eclipse.jubula.rc.common.driver.IEventThreadQueuer;
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.table.Cell;
import org.eclipse.jubula.rc.common.logger.AutServerLogger;
import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig;
import org.eclipse.jubula.rc.swing.swing.driver.KeyCodeConverter;
import org.eclipse.jubula.rc.swing.utils.SwingUtils;
/**
 * Toolkit specific commands for the <code>JTable</code>
 * 
 * @author BREDEX GmbH
 */
public class JTableCAPs extends AbstractTableCAPs {

    /** the logger */
    private static AutServerLogger log = new AutServerLogger(
            JTableCAPs.class);

    /** the RobotFactory from the AUT */
    private IRobotFactory m_robotFactory;
    
    /**
     * @return the log
     */
    public static AutServerLogger getLog() {
        return log;
    }    

    /**
     * {@inheritDoc}
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }
    
    /**
     * 
     * @return the real AUT JTable
     */
    private JTable getTable() {
        return (JTable) getComponent().getRealComponent();
    }
    
    /**
     * @return The event thread queuer.
     */
    public IEventThreadQueuer getEventThreadQueuer() {
        return getRobotFactory().getEventThreadQueuer();
    }
    

    /**
     * {@inheritDoc}
     */
    public String[] getTextArrayFromComponent() {
        final String[] componentTextArray;
        TableColumnModel columnModel = getTable().getColumnModel();
        if (columnModel == null) {
            componentTextArray = null;
        } else {
            componentTextArray = new String[columnModel.getColumnCount()];
            for (int i = 0; i < componentTextArray.length; i++) {
                TableColumn tableColumn = columnModel.getColumn(i);
                if (tableColumn == null) {
                    componentTextArray[i] = null;
                } else {
                    Object headerValue = tableColumn.getHeaderValue();
                    if (headerValue == null) {
                        componentTextArray[i] = null;
                    } else {
                        componentTextArray[i] = headerValue.toString();
                    }
                }
            }
        }
        return componentTextArray;
    }
    /**
     * {@inheritDoc}
     */
    protected int getExtendSelectionModifier() {
        return SwingUtils.getSystemDefaultModifier();
    }

    /**
     * {@inheritDoc}
     */
    protected Cell getCellAtMousePosition() throws StepExecutionException {
        JTable table = getTable();
        Point mousePos = getRobot().getCurrentMousePosition();
        Point tablePos = table.getLocationOnScreen();
        Point relativePos = new Point(mousePos.x - tablePos.x,
            mousePos.y - tablePos.y);
        final int column = table.columnAtPoint(relativePos);
        final int row = table.rowAtPoint(relativePos);
        if (log.isDebugEnabled()) {
            log.debug("Selected row, col: " + row + ", " + column); //$NON-NLS-1$ //$NON-NLS-2$
        }
        checkRowColBounds(row, column);
        return new Cell(row, column);
    }

    /**
     * {@inheritDoc}
     */
    protected boolean isMouseOnHeader() {
        JTable table = getTable();
        if (table.getTableHeader() == null
                || !(table.getTableHeader().isShowing())) {
            return false;
        }
        
        JTableHeader header = table.getTableHeader();
        Point mousePos = getRobot().getCurrentMousePosition();        
        try {
            Point headerPos = header.getLocationOnScreen();
            Point relativePos = new Point(mousePos.x - headerPos.x,
                mousePos.y - headerPos.y);            
            return header.getBounds().contains(relativePos);
        } catch (IllegalComponentStateException icse) {
            return false;
        } 
    }

    /**
     * {@inheritDoc}
     */
    protected Object setEditorToReplaceMode(Object editor, boolean replace) {
        Object returnvalue = editor;
        if (replace) {
            getRobot().clickAtCurrentPosition(editor, 3, 1);
        } else {
            returnvalue = getComponent().getRealComponent();
        }
        return returnvalue;
    }

    /**
     * {@inheritDoc}
     */
    protected Object activateEditor(Cell cell, Rectangle rectangle) {
        Object table = getComponent().getRealComponent();
        getRobot().click(table, rectangle);
        Component editor = getTableCellEditor(cell);
        // sometimes the editor only appears after doubleclick!
        if (editor == null) {
            ClickOptions co = ClickOptions.create().setClickCount(2);
            getRobot().click(table, rectangle, co);
            editor = getTableCellEditor(cell);
        }
        return editor;
    }
    
    /**
     * Gets the TableCellEditor of the given cell
     * @param cell the cell.
     * @return the TableCellEditor
     */
    private Component getTableCellEditor(final Cell cell) {
        final JTable table = (JTable) getComponent().getRealComponent();
        return (Component) getEventThreadQueuer()
            .invokeAndWait("getCellEditor", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        Object value = table.getValueAt(
                            cell.getRow(), cell.getCol());
                        boolean selected = table.isCellSelected(
                            cell.getRow(), cell.getCol());
                        return table.getCellEditor(cell.getRow(),
                            cell.getCol()).getTableCellEditorComponent(table,
                                value, selected, cell.getRow(), cell.getCol());
                    }
                });
    }


    /**
     * {@inheritDoc}
     */
    protected int getKeyCode(String key) {
        return KeyCodeConverter.getKeyCode(key);
    }

}




/*******************************************************************************
 * 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.Point;
import javax.swing.JTree;
import javax.swing.tree.TreePath;

import org.eclipse.jubula.rc.common.CompSystemConstants;
import org.eclipse.jubula.rc.common.caps.AbstractTreeCAPs;
import org.eclipse.jubula.rc.common.driver.DragAndDropHelper;
import org.eclipse.jubula.rc.common.driver.IEventThreadQueuer;
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.swing.driver.RobotFactoryConfig;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
import org.eclipse.jubula.tools.utils.TimeUtil;
/**
 * Toolkit specific commands for the <code>JTree</code>
 * 
 * @author BREDEX GmbH
 */
public class JTreeCAPs extends AbstractTreeCAPs {

    /** Robot Factory*/
    private IRobotFactory m_robotFactory;

    
    /**
     * Waits the given amount of time. Logs a drop-related error if interrupted.
     *
     * @param delayBeforeDrop the amount of time (in milliseconds) to wait
     *                        between moving the mouse to the drop point and
     *                        releasing the mouse button
     */
    static void waitBeforeDrop(int delayBeforeDrop) {
        TimeUtil.delay(delayBeforeDrop);
    }
    
    /**
     * {@inheritDoc}
     */
    public void gdDragByTextPath(int mouseButton,
            String modifier, String pathType, int preAscend,
            String treeTextPath, String operator) {
        final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
        dndHelper.setModifier(modifier);
        dndHelper.setMouseButton(mouseButton);
        gdSelect(pathType, preAscend, treeTextPath, operator, 0, 1, 
                CompSystemConstants.EXTEND_SELECTION_NO);
        pressOrReleaseModifiers(modifier, true);
        getRobot().mousePress(null, null, mouseButton);

    }

    /**
     * {@inheritDoc}
     */
    public void gdDropByTextPath(String pathType, int preAscend,
            String treeTextPath, String operator, int delayBeforeDrop) {
        try {
            gdSelect(pathType, preAscend, treeTextPath, operator, 0, 1,
                    CompSystemConstants.EXTEND_SELECTION_NO);
            waitBeforeDrop(delayBeforeDrop);
        } finally {
            final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
            getRobot().mouseRelease(null, null, dndHelper.getMouseButton());
            pressOrReleaseModifiers(dndHelper.getModifier(), false);
        }

    }

    /**
     * {@inheritDoc}
     */
    public void gdDragByIndexPath(int mouseButton,
            String modifier, String pathType, int preAscend,
            String treeIndexPath) {
        final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
        dndHelper.setModifier(modifier);
        dndHelper.setMouseButton(mouseButton);
        gdSelectByIndices(pathType, preAscend, treeIndexPath, 0, 1,
                CompSystemConstants.EXTEND_SELECTION_NO);
        pressOrReleaseModifiers(modifier, true);
        getRobot().mousePress(null, null, mouseButton);

    }

    /**
     * {@inheritDoc}
     */
    public void gdDropByIndexPath(String pathType, int preAscend,
            String treeIndexPath, int delayBeforeDrop) {
        try {
            gdSelectByIndices(pathType, preAscend, treeIndexPath, 0, 1,
                    CompSystemConstants.EXTEND_SELECTION_NO);
            waitBeforeDrop(delayBeforeDrop);
        } finally {
            final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
            getRobot().mouseRelease(null, null, dndHelper.getMouseButton());
            pressOrReleaseModifiers(dndHelper.getModifier(), false);
        }
        
    }
    /**
     * {@inheritDoc}
     */
    public void gdVerifyTextAtMousePosition(String text, String operator) {
        checkNodeText(getNodeAtMousePosition(), text, operator);
    }
    /**
     * 
     * @return the tree node at the current mouse position.
     * @throws StepExecutionException If no tree node can be found at the 
     *                                current mouse position.
     */
    protected Object getNodeAtMousePosition() throws StepExecutionException {
        return getEventThreadQueuer().invokeAndWait("getNodeAtMousePosition", new IRunnable() { //$NON-NLS-1$
            
            public Object run() throws StepExecutionException {
                Point mousePosition = getRobot().getCurrentMousePosition();
                Point treeLocation = getTreeComponent().getLocationOnScreen();
                Point relativePos = new Point(
                        mousePosition.x - treeLocation.x,
                        mousePosition.y - treeLocation.y);

                int rowAtMousePosition = 
                    getTreeComponent().
                        getRowForLocation(relativePos.x, relativePos.y);
                
                if (rowAtMousePosition != -1) {
                    TreePath treePath = 
                        getTreeComponent().
                            getPathForLocation(relativePos.x, relativePos.y);
                    
                    if (treePath != null 
                            && treePath.getLastPathComponent() != null) {
                        return treePath.getLastPathComponent();
                    }
                    
                }
                
                throw new StepExecutionException("No tree node found at mouse position.", //$NON-NLS-1$
                    EventFactory.createActionError(TestErrorEvent.NOT_FOUND));
            }
            
        });

    }
    /**
     * 
     * @return The JTree
     */
    private JTree getTreeComponent() {
        return (JTree) getComponent().getRealComponent();
    }

    /** 
     * {@inheritDoc}
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }
    
    /**
     * Presses or releases the given modifier.
     * @param modifier the modifier.
     * @param press if true, the modifier will be pressed.
     * if false, the modifier will be released.
     */
    protected void pressOrReleaseModifiers(String modifier, boolean press) {
        CapUtil.pressOrReleaseModifiers(modifier, press);
    }
    
    /**
     * @return The event thread queuer.
     */
    protected IEventThreadQueuer getEventThreadQueuer() {
        return getRobotFactory().getEventThreadQueuer();
    }
}




/*******************************************************************************
 * 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.uiadapter;

import javax.swing.AbstractButton;

import org.eclipse.jubula.rc.common.driver.IEventThreadQueuer;
import org.eclipse.jubula.rc.common.driver.IRunnable;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IButtonAdapter;
/**
 * Implementation of the button interface as an adapter which holds
 * the <code>javax.swing.AbstractButton</code>.
 * 
 * @author BREDEX GmbH
 */
public class AbstractButtonAdapter extends WidgetAdapter
    implements IButtonAdapter {

    /**
     * Creates an object with the adapted JMenu.
     * @param objectToAdapt this must be an object of the Type 
     *      <code>AbstractButton</code>
     */
    public AbstractButtonAdapter(Object objectToAdapt) {
        super(objectToAdapt);
    }
    
    /**
     * 
     * @return the casted Object 
     */
    private AbstractButton getAbstractButton() {
        return (AbstractButton) getRealComponent();
    }
    /**
     * @return The event thread queuer.
     */
    public IEventThreadQueuer getEventThreadQueuer() {
        return getRobotFactory().getEventThreadQueuer();
    }
   
    /**
     * {@inheritDoc}
     */
    public String getText() {
        return (String) getEventThreadQueuer().invokeAndWait(
                "getText", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return getAbstractButton().getText();
                    }
                });
    }

    /**
     * {@inheritDoc}
     */
    public boolean isEnabled() {
        Boolean returnvalue = (Boolean) getEventThreadQueuer().invokeAndWait(
                "isEnabled", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return getAbstractButton().getModel().isEnabled()
                                ? Boolean.TRUE : Boolean.FALSE;
                    }
                });
        return (boolean) returnvalue.booleanValue();
    }

    /**
     * {@inheritDoc}
     */
    public boolean isSelected() {
        Boolean returnvalue = (Boolean) getEventThreadQueuer().invokeAndWait(
                "isSelected", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return getAbstractButton().getModel().isSelected()
                                ? Boolean.TRUE : Boolean.FALSE;
                    }
                });
        return (boolean) returnvalue.booleanValue();
    }
    
    /**
     * {@inheritDoc}
     */
    public String readValue(String variable) {

        return (String) getEventThreadQueuer().invokeAndWait(
                "isShowing", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return getAbstractButton().getText();
                    }
                });
    }

}




/*******************************************************************************
 * 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.uiadapter;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import javax.swing.JMenu;
import javax.swing.JMenuItem;

import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;
/**
 * Implementation of the menu interface for adapting the <code>JMenu</code>.
 * In Swing we have three implementations of the menu interface because
 * the Interface is used for the <code>JMenubar</code>, the <code>JPopupMenu</code> and the <code>JMenu</code>.
 * All these behave same in the implementation.
 * 
 * @author BREDEX GmbH
 *
 */
public class JMenuAdapter implements IMenuAdapter {
    /** The JMenu from the AUT */
    private JMenu m_menu;
    
    /**
     * Creates an object with the adapted JMenu.
     * @param toAdapt graphics component which will be adapted
     */
    public JMenuAdapter(Object toAdapt) { 
        m_menu = (JMenu) toAdapt;
    }
    
    /**
     * {@inheritDoc}
     */
    public Object getRealComponent() {
        return m_menu;
    }
    
    /**
     * {@inheritDoc}
     */
    public IMenuItemAdapter[] getItems() {
        List adapters = new LinkedList();
        
        for (int i = 0; i < m_menu.getItemCount(); i++) {
            JMenuItem getted = m_menu.getItem(i);
            if (getted instanceof JMenuItem) {
                adapters.add(new JMenuItemAdapter(getted));
            }
            
        }
        

        IMenuItemAdapter[] allitems = null;
        if (adapters.size() > 0) {
            allitems = new IMenuItemAdapter[adapters.size()];
            int i = 0;
            for (Iterator iterator = adapters.iterator(); iterator.hasNext();) {
                Object object = (Object) iterator.next();
                
                allitems[i] = (IMenuItemAdapter) object;
                i++;
            }

        }
        
        
        return allitems;
    }
    /**
     * {@inheritDoc}
     */
    public int getItemCount() {
        return m_menu.getItemCount();
    }
    


}




/*******************************************************************************
 * 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.uiadapter;

import java.util.LinkedList;
import java.util.List;

import javax.swing.JMenuBar;
import javax.swing.JMenuItem;

import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;

/**
 * Implementation of the menu interface for adapting the <code>JMenuBar</code>.
 * In Swing we have three implementations of the menu interface because
 * the Interface is used for the <code>JMenubar</code>, the <code>JPopupMenu</code> and the <code>JMenu</code>.
 * All these behave same in the implementation.
 * 
 * @author BREDEX GmbH
 *
 */
public class JMenuBarAdapter implements IMenuAdapter {
    /** The JMenuBar */
    private JMenuBar m_menuBar;
    
    /**
     * @param objectToAdapt 
     */
    public JMenuBarAdapter(Object objectToAdapt) {
        m_menuBar = (JMenuBar) objectToAdapt;
    }
        
    /**
     * {@inheritDoc}
     */
    public Object getRealComponent() {

        return m_menuBar;
    }
    /**
     * {@inheritDoc}
     */

    public IMenuItemAdapter[] getItems() {
        Object[] menus = m_menuBar.getSubElements();
        List adapters = new LinkedList();
        for (int i = 0; i < menus.length; i++) {
            if (menus[i] instanceof JMenuItem) {
                adapters.add(new JMenuItemAdapter(menus[i]));
            }
        }
        IMenuItemAdapter[] allitems = new IMenuItemAdapter[adapters.size()];
        adapters.toArray(allitems);
        return allitems;
    }

    /**
     * {@inheritDoc}
     */
    public int getItemCount() {
        return m_menuBar.getMenuCount();
    }

}




/*******************************************************************************
 * 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.uiadapter;

import javax.swing.JMenu;
import javax.swing.JMenuItem;

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.driver.RobotTiming;
import org.eclipse.jubula.rc.common.exception.RobotException;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;
import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;

/**
 * Implementation of the MenuItem interface for adapting <code>JMenuItem</code>.
 * @author BREDEX GmbH
 * 
 */
public class JMenuItemAdapter 
    implements IMenuItemAdapter {

    /** the JMenuItem from the AUT    */
    private JMenuItem m_menuItem;

    /** the RobotFactory from the AUT */
    private IRobotFactory m_robotFactory;
  
    /**
     * 
     * @param objectToAdapt 
     */
    public JMenuItemAdapter(Object objectToAdapt) {
        m_menuItem = (JMenuItem) objectToAdapt;        
    }
    /**
     * Gets the Robot factory. The factory is created once per instance.
     *
     * @return The Robot factory.
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }
    /**
     * Gets the IEventThreadQueuer.
     *
     * @return The Robot
     * @throws RobotException
     *             If the Robot cannot be created.
     */
    protected IRobot getRobot() throws RobotException {
        return getRobotFactory().getRobot();
    }
    /**
     * @return The event thread queuer.
     */
    public IEventThreadQueuer getEventThreadQueuer() {
        return getRobotFactory().getEventThreadQueuer();
    }
    

    /**
     * {@inheritDoc}
     */
    public Object getRealComponent() {

        return m_menuItem;
    }

    /**
     * {@inheritDoc}
     */
    public void setComponent(Object element) {
        m_menuItem = (JMenuItem) element;

    }

    /**
     * {@inheritDoc}
     */
    public boolean isEnabled() {
        Boolean actual = (Boolean) getEventThreadQueuer().invokeAndWait(
                "isEnabled", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        // see findBugs
                        return ((m_menuItem != null)
                                && (m_menuItem instanceof JMenuItem)
                                && m_menuItem.isEnabled()) 
                                ? Boolean.TRUE : Boolean.FALSE;
                    }
                });

        return actual.booleanValue();
    }
    /**
     * {@inheritDoc}
     */
    public String getText() {
        return (String) getEventThreadQueuer().invokeAndWait(
                "getText", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_menuItem.getText();
                    }
                });
    }
    /**
     * {@inheritDoc}
     */
    public boolean isShowing() {
        Boolean actual = (Boolean) getEventThreadQueuer().invokeAndWait(
                "isShowing", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        // see findBugs
                        return ((m_menuItem != null)
                                && (m_menuItem instanceof JMenuItem)
                                && m_menuItem.isShowing()) 
                                ? Boolean.TRUE : Boolean.FALSE;
                    }
                });

        return actual.booleanValue();
    }
    
    /**
     * {@inheritDoc}
     */
    public boolean isExisting() {
        if (m_menuItem != null) {
            return true;
        }
        return false;
    }
    /**
     * {@inheritDoc}
     */
    public boolean isSelected() {
        Boolean actual = (Boolean) getEventThreadQueuer().invokeAndWait(
                "isSelected", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return ((m_menuItem != null)
                                && (m_menuItem instanceof JMenuItem)
                                && m_menuItem.isSelected()) 
                                ? Boolean.TRUE : Boolean.FALSE;
                    }
                });

        return actual.booleanValue();
    }
    
    /**
     * {@inheritDoc}
     */
    public IMenuAdapter getMenu() {
        if (m_menuItem instanceof JMenu) {
            return new JMenuAdapter(m_menuItem);
        }
        return null;
    }
    
    /**
     * {@inheritDoc}
     */
    public boolean hasSubMenu() {
        if (m_menuItem.getSubElements().length > 0) {
            return true;
        }
        return false;
    }
    /**
     * {@inheritDoc}
     */
    public boolean isSeparator() {
        if (m_menuItem == null) {
            return true;
        }
        return false;
    }
    
    /**
     * {@inheritDoc}
     */
    public void selectMenuItem() {
        clickMenuItem(getRobot(), m_menuItem);
        
    }
    
    /**
     * {@inheritDoc}
     */
    public IMenuAdapter openSubMenu() {
        if (!m_menuItem.isEnabled()) {
            throw new StepExecutionException("menu item not enabled", //$NON-NLS-1$
                    EventFactory.createActionError(
                            TestErrorEvent.MENU_ITEM_NOT_ENABLED));
        }
        if (!(m_menuItem instanceof JMenu)) {
            throw new StepExecutionException("unexpected item found", //$NON-NLS-1$
                    EventFactory.createActionError(TestErrorEvent.NOT_FOUND));
        }
        JMenu menu = (JMenu) m_menuItem;        
        getRobot().click(m_menuItem, null, ClickOptions.create().setClickType(
            ClickOptions.ClickType.RELEASED));
        RobotTiming.sleepPostShowSubMenuItem(menu.getDelay());
        return getMenu();
    }
    
    /**
     * Clicks on a menu item
     * 
     * @param robot the robot
     * @param item  the menu item
     */
    private void clickMenuItem(IRobot robot, JMenuItem item) {
        if (!item.isEnabled()) {
            throw new StepExecutionException("menu item not enabled", //$NON-NLS-1$
                    EventFactory.createActionError(
                            TestErrorEvent.MENU_ITEM_NOT_ENABLED));
        }
        robot.click(item, null, ClickOptions.create().setClickType(
            ClickOptions.ClickType.RELEASED));
    }
}




/*******************************************************************************
 * 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.uiadapter;

import java.util.LinkedList;
import java.util.List;

import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;

import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;
/**
 * Implementation of the menu interface for adapting the <code>JPopupMenu</code>.
 * In Swing we have three implementations of the menu interface because
 * the Interface is used for the <code>JMenubar</code>, the <code>JPopupMenu</code> and the <code>JMenu</code>.
 * All these behave same in the implementation.
 * 
 * @author BREDEX GmbH
 *
 */
public class JPopupMenuAdapter implements IMenuAdapter {
    /** */
    private JPopupMenu m_contextMenu;
    
    /**
     * 
     * @param adaptee 
     */
    public JPopupMenuAdapter(Object adaptee) {
        m_contextMenu = (JPopupMenu) adaptee;
    }
    
    /** {@inheritDoc} */
    public Object getRealComponent() {
        return m_contextMenu;
    }

    /** {@inheritDoc} */
    public IMenuItemAdapter[] getItems() {
        Object[] menuItems = m_contextMenu.getSubElements();
        List adapters = new LinkedList();
        for (int i = 0; i < menuItems.length; i++) {
            if (menuItems[i] instanceof JMenuItem) {
                adapters.add(new JMenuItemAdapter(menuItems[i]));
            }
        }
        IMenuItemAdapter[] allitems = new IMenuItemAdapter[adapters.size()];
        adapters.toArray(allitems);
        return allitems;
    }

    /** {@inheritDoc} */
    public int getItemCount() {
        return m_contextMenu.getSubElements().length;
    }

    
}




/*******************************************************************************
 * 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.uiadapter;

import java.awt.Component;
import java.awt.Rectangle;

import javax.swing.JTable;
import javax.swing.table.TableCellRenderer;

import org.eclipse.jubula.rc.common.caps.AbstractMenuCAPs;
import org.eclipse.jubula.rc.common.driver.IRunnable;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.implclasses.IndexConverter;
import org.eclipse.jubula.rc.common.implclasses.MatchUtil;
import org.eclipse.jubula.rc.common.implclasses.table.Cell;
import org.eclipse.jubula.rc.common.logger.AutServerLogger;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.ITableAdapter;
import org.eclipse.jubula.rc.swing.swing.caps.CapUtil;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
/**
 * Implements the table interface as an adapter for the <code>JTable</code>.
 *
 * @author BREDEX GmbH
 */
public class JTableAdapter extends WidgetAdapter implements ITableAdapter {

    /** the logger */
    private static AutServerLogger log = new AutServerLogger(
            AbstractMenuCAPs.class);

    /** The JTable from the AUT   */
    private JTable m_table;
    
    /**
     * Creates an object with the adapted JMenu.
     * @param objectToAdapt the object which needed to be adapted
     */
    public JTableAdapter(Object objectToAdapt) {
        super(objectToAdapt);
        m_table = (JTable) objectToAdapt;
    }
   
    /**
     * {@inheritDoc}
     */
    public void setComponent(Object element) {
        m_table = (JTable) element;

    }

    /**
     * {@inheritDoc}
     */
    public int getColumnCount() {
        Integer returnvalue = (Integer) getEventThreadQueuer().invokeAndWait(
                "getColumnCount", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return new Integer(m_table.getColumnCount());
                    }
                });
        return returnvalue.intValue();
    }

    /**
     * {@inheritDoc}
     */
    public int getRowCount() {
        Integer returnvalue = (Integer) getEventThreadQueuer().invokeAndWait(
                "getRowCount", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return new Integer(m_table.getRowCount());
                    }
                });
        return returnvalue.intValue();
    }

    /**
     * {@inheritDoc}
     */
    public String getCellText(final int row, final int column) {
        Object o = getEventThreadQueuer().invokeAndWait("getCellText", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        Object value = m_table.getValueAt(row, column);
                        boolean selected = m_table.isCellSelected(row,
                                column);
                        if (log.isDebugEnabled()) {
                            log.debug("Getting cell text:"); //$NON-NLS-1$
                            log.debug("Row, col: " + row + ", " + column); //$NON-NLS-1$ //$NON-NLS-2$
                            log.debug("Value: " + value); //$NON-NLS-1$
                        }
                        TableCellRenderer renderer = m_table.getCellRenderer(
                                row, column);
                        Component c = renderer.getTableCellRendererComponent(
                                m_table, value, selected, true, row,
                                column);

                        return CapUtil.getRenderedText(c);
                    }
                });

        String current = String.valueOf(o);
        return current;
    }
    
    /**
     * {@inheritDoc}
     */
    public String getColumnName(final int column) {
        String returnvalue = (String)getEventThreadQueuer().invokeAndWait(
                "getColumnName", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        return m_table.getColumnName(column);
                    }
                });
        return returnvalue;
    }

    /**
     * {@inheritDoc}
     */
    public int getColumnFromString(final String col, final String operator) {
        Integer returnvalue = (Integer) getEventThreadQueuer().invokeAndWait(
                "getColumnFromString", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        int column = -2;
                        try {
                            int usrIdxCol = Integer.parseInt(col);
                            if (usrIdxCol == 0) {
                                usrIdxCol = usrIdxCol + 1;
                            }
                            column = IndexConverter.toImplementationIndex(
                                    usrIdxCol);
                        } catch (NumberFormatException nfe) {
                            try {
                                if (m_table.getTableHeader() == null
                                        || !(m_table.getTableHeader()
                                                .isShowing())) {
                                    throw new StepExecutionException("No Header", //$NON-NLS-1$
                                            EventFactory.createActionError(
                                                TestErrorEvent.NO_HEADER));
                                }
                                for (int i = 0; i < m_table.getColumnCount();
                                        i++) {
                                    String header = m_table.getColumnName(i);
                                    if (MatchUtil.getInstance().match(
                                            header, col, operator)) {
                                        column = i;
                                    }
                                }
                            } catch (IllegalArgumentException iae) {
                                //do nothing here                
                            }
                        }
                        
                        return new Integer(column);
                    }
                });
        return returnvalue.intValue();
    }

    /**
     * {@inheritDoc}
     */
    public String getRowName(final int row) {
        // JTable does not act like lists
        return null;
    }

    /**
     * {@inheritDoc}
     */
    public int getRowFromString(final String row, final String operator) {
        Integer returnvalue = (Integer) getEventThreadQueuer().invokeAndWait(
                "getRowFromString", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        int rowInt = -2;        
                        try {
                            rowInt = IndexConverter.toImplementationIndex(
                                    Integer.parseInt(row));
                            if (rowInt == -1) {
                                if (m_table.getTableHeader() == null
                                        || !(m_table.getTableHeader()
                                                .isShowing())) {
                                    throw new StepExecutionException("No Header", //$NON-NLS-1$
                                            EventFactory.createActionError(
                                                TestErrorEvent.NO_HEADER));
                                }                
                            }
                        } catch (NumberFormatException nfe) {
                            for (int i = 0; i < m_table.getRowCount(); i++) {
                                String cellTxt = getCellText(i, 0);
                                if (MatchUtil.getInstance().match(cellTxt, row,
                                        operator)) {
                                    return new Integer(i);
                                }
                            }
                        }        
                        return new Integer(rowInt);
                    }
                });
        return returnvalue.intValue();
    }

    /**
     * {@inheritDoc}
     */
    public Rectangle getBounds() {
        Rectangle returnvalue = (Rectangle) getEventThreadQueuer()
                .invokeAndWait("getBounds", //$NON-NLS-1$
                    new IRunnable() {                     
                        public Object run() throws StepExecutionException {
                            return m_table.getBounds();
                        }
                    });
        
        return returnvalue;
    }

    /**
     * {@inheritDoc}
     */
    public Rectangle getHeaderBounds(int col) {
        Rectangle returnvalue = (Rectangle) getEventThreadQueuer()
                .invokeAndWait("getHeaderBounds", //$NON-NLS-1$
                    new IRunnable() {                     
                        public Object run() throws StepExecutionException {
                            return m_table.getTableHeader().getBounds();
                        }
                    });
        
        return returnvalue;
    }

    /**
     * {@inheritDoc}
     */
    public Cell getSelectedCell() throws StepExecutionException {
        
        Cell returnvalue = (Cell) getEventThreadQueuer().invokeAndWait(
                "getSelectedCell", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                
                        int row = m_table.getSelectedRow();
                        int col = m_table.getSelectedColumn();
                        if (log.isDebugEnabled()) {
                            log.debug("Selected row, col: " + row + ", " + col); //$NON-NLS-1$ //$NON-NLS-2$
                        }
                        try {
                            checkRowColBounds(row, col);
                        } catch (StepExecutionException e) {
                            if ((e.getEvent() != null)
                                    && (TestErrorEvent.INVALID_INDEX.equals(
                                            e.getEvent()
                                            .getProps().get(TestErrorEvent
                                                    .Property
                                                    .DESCRIPTION_KEY)))) {
                // set "invalid index" to "no selection" -> better description!
                                throw new StepExecutionException("No selection", //$NON-NLS-1$
                                        EventFactory.createActionError(
                                                TestErrorEvent.NO_SELECTION));
                            }
                            throw e;
                        }
                        return new Cell(row, col);
                    }
                });
        return returnvalue;
    }

    /**
     * {@inheritDoc}
     */
    public boolean isHeaderVisible() {
        Boolean returnvalue = (Boolean) getEventThreadQueuer().invokeAndWait(
                "isHeaderVisible", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        if (m_table.getTableHeader() != null) {
                            return m_table.getTableHeader().isVisible()
                                    ? Boolean.TRUE : Boolean.FALSE;
                        }
                        return Boolean.FALSE;
                    }
                });
        return (boolean) returnvalue.booleanValue();
    }

    /**
     * {@inheritDoc}
     */
    public boolean isCellEditable(int row, int col) {
        Boolean editable = (Boolean) getEventThreadQueuer().invokeAndWait(
                "isCellEditable", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        Cell cell = getSelectedCell();
                        // see findBugs
                        return (m_table.isCellEditable(cell.getRow(),
                                cell.getCol())) ? Boolean.TRUE : Boolean.FALSE;
                    }
                });
        return editable.booleanValue();
    }

    /**
     * Checks wether <code>0 <= value < count</code>.
     *
     * @param value
     *            The value to check.
     * @param count
     *            The upper bound.
     */
    private void checkBounds(int value, int count) {
        if ((value < 0) || (value >= count)) {
            throw new StepExecutionException("Invalid row/column: " + value, //$NON-NLS-1$
                EventFactory.createActionError(
                        TestErrorEvent.INVALID_INDEX_OR_HEADER));
        }
    }

    /**
     * Checks if the passed row and column are inside the bounds of the JTable.
     *
     * @param row
     *            The row
     * @param column
     *            The column
     * @throws StepExecutionException
     *             If the row or the column is outside of the JTable's bounds.
     */
    private void checkRowColBounds(int row, int column)
        throws StepExecutionException {
        checkBounds(row, m_table.getRowCount());
        checkBounds(column, m_table.getColumnCount());
    }
    
    /**
     * {@inheritDoc}
     */
    public boolean hasCellSelection() {
        try {
            getSelectedCell();
        } catch (StepExecutionException e) {
            return false;
        }
        return true;
    }
    
    /**
     * {@inheritDoc}
     */
    public Rectangle scrollCellToVisible(final int row, final int col)
        throws StepExecutionException {
        Rectangle bounds = (Rectangle) getEventThreadQueuer().invokeAndWait(
                "getCellRect", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        return m_table
                                .getCellRect(row, col, true);
                    }
                });

        getRobot().scrollToVisible(m_table, bounds);
        return bounds;
    }
}




/*******************************************************************************
 * 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.uiadapter;

import javax.swing.JTree;

//import org.eclipse.jubula.rc.common.driver.IRunnable;
import org.eclipse.jubula.rc.common.implclasses.tree.AbstractTreeOperationContext;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.ITreeAdapter;
import org.eclipse.jubula.rc.swing.swing.implclasses.TreeOperationContext;
/**
 * Implementation of the Tree interface as an adapter for <code>JTree</code>.
 * 
 * @author BREDEX GmbH
 *
 */
public class JTreeAdapter extends WidgetAdapter implements ITreeAdapter {
    
   
    /**
     * Creates an object with the adapted JMenu.
     * @param objectToAdapt 
     */
    public JTreeAdapter(Object objectToAdapt) {
        super(objectToAdapt);
    }
    
    /**
     * @return the casted Object 
     */
    private JTree getTable() {
        return (JTree) getRealComponent();
    }
        
    /**
     * {@inheritDoc}
     */
    public AbstractTreeOperationContext getContext() {
        TreeOperationContext context = new TreeOperationContext(
                getEventThreadQueuer(), getRobot(), getTable());
        return context;
    }
    /**
     * {@inheritDoc}
     */
    public Object getRootNode() {
        
        return getTable().getModel().getRoot();
    }
    /**
     * {@inheritDoc}
     */
    public boolean isRootVisible() {
        return getTable().isRootVisible();
    }
    
}




/*******************************************************************************
 * 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.uiadapter;


import java.awt.AWTEvent;
import java.awt.Toolkit;

import javax.swing.JComponent;

import org.eclipse.jubula.rc.common.caps.AbstractMenuCAPs;
import org.eclipse.jubula.rc.common.driver.ClickOptions;
import org.eclipse.jubula.rc.common.driver.DragAndDropHelper;
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.driver.RobotTiming;
import org.eclipse.jubula.rc.common.exception.RobotException;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.listener.EventLock;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IWidgetAdapter;
import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig;
import org.eclipse.jubula.rc.swing.swing.caps.CapUtil;
import org.eclipse.jubula.rc.swing.swing.caps.JMenuBarCAPs;
import org.eclipse.jubula.rc.swing.swing.caps.CapUtil.PopupShownCondition;
import org.eclipse.jubula.rc.swing.swing.implclasses.EventListener;
import org.eclipse.jubula.tools.constants.TimeoutConstants;
import org.eclipse.jubula.tools.i18n.I18n;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
import org.eclipse.jubula.tools.utils.TimeUtil;
/**
 * Implements the interface for widgets and supports basic methods
 * which are needed for nearly all Swing ui components.
 * This is a basic adaption for <code>JComponent</code>.
 * 
 * @author BREDEX GmbH 
 */
public abstract class WidgetAdapter implements IWidgetAdapter {
      
    /** constants for communication */
    protected static final String POS_UNIT_PIXEL = "Pixel"; //$NON-NLS-1$
    /** constants for communication */
    protected static final String POS_UNI_PERCENT = "Percent"; //$NON-NLS-1$
    
    /** the RobotFactory from the AUT */
    private IRobotFactory m_robotFactory;
    

     
    /** */
    private JComponent m_component;

    /**
     * Used to store the component into the adapter.
     * @param objectToAdapt 
     */
    protected WidgetAdapter(Object objectToAdapt) {
        m_component = (JComponent) objectToAdapt;
    }
    
    /**
     * {@inheritDoc}
     */
    public Object getRealComponent() {
        return m_component;
    }
    
    /**
     * Gets the Robot factory. The factory is created once per instance.
     *
     * @return The Robot factory.
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }
    /**
     * Gets the IEventThreadQueuer.
     *
     * @return The Robot
     * @throws RobotException
     *             If the Robot cannot be created.
     */
    protected IRobot getRobot() throws RobotException {
        return getRobotFactory().getRobot();
    }
    /**
     * @return The event thread queuer.
     */
    public IEventThreadQueuer getEventThreadQueuer() {
        return getRobotFactory().getEventThreadQueuer();
    }
    
    /**
     * {@inheritDoc}
     */
    public String getPropteryValue(final String propertyname) {
        Object prop = getEventThreadQueuer().invokeAndWait("getProperty",  //$NON-NLS-1$
                new IRunnable() {
                    public Object run() throws StepExecutionException {
                        try {
                            return getRobot().getPropertyValue(
                                    getRealComponent(), propertyname);
                        } catch (RobotException e) {
                            throw new StepExecutionException(
                                e.getMessage(), 
                                EventFactory.createActionError(
                                    TestErrorEvent.PROPERTY_NOT_ACCESSABLE));
                        }
                    }
                });
        return String.valueOf(prop);
    }

    /**
     * {@inheritDoc}
     */
    public boolean isShowing() {
        Boolean returnvalue = (Boolean) getEventThreadQueuer().invokeAndWait(
                "isShowing", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_component.isShowing()
                                ? Boolean.TRUE : Boolean.FALSE;
                    }
                });
        return (boolean) returnvalue.booleanValue();
    }

    /**
     * {@inheritDoc}
     */
    public boolean hasFocus() {
        Boolean returnvalue = (Boolean) getEventThreadQueuer().invokeAndWait(
                "hasFocus", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_component.hasFocus()
                                ? Boolean.TRUE : Boolean.FALSE;
                    }
                });
        return (boolean) returnvalue.booleanValue();
    }
    
    /**
     * {@inheritDoc}
     */
    public boolean isEnabled() {
        Boolean returnvalue = (Boolean) getEventThreadQueuer().invokeAndWait(
                "isEnabled", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_component.isEnabled()
                                ? Boolean.TRUE : Boolean.FALSE;
                    }
                });
        return (boolean) returnvalue.booleanValue();
    }
    
    /**
     * {@inheritDoc}
     */
    public AbstractMenuCAPs showPopup(final int button) {
        final Object component = m_component;
        Runnable showPopup = new Runnable() {
            public void run() {
                RobotTiming.sleepPreShowPopupDelay();
                ClassLoader oldCl = Thread.currentThread()
                    .getContextClassLoader();
                Thread.currentThread().setContextClassLoader(component
                        .getClass().getClassLoader());
                if ((getRobot()).isMouseInComponent(component)) {
                    getRobot().clickAtCurrentPosition(
                            component, 1, button);
                } else {
                    getRobot().click(component, null, 
                        ClickOptions.create()
                            .setClickCount(1)
                            .setMouseButton(button));
                }
                Thread.currentThread().setContextClassLoader(oldCl);
            }
        };

        return showPopup(showPopup);
    }
    
    /**
     * {@inheritDoc}
     */
    public AbstractMenuCAPs showPopup(
            final int xPos, final String xUnits, 
            final int yPos, final String yUnits, final int button)
        throws StepExecutionException {
        final Object component = m_component;
        Runnable showPopup = new Runnable() {
            public void run() {
                RobotTiming.sleepPreShowPopupDelay();
                boolean isAbsoluteCoordinatesX = 
                    xUnits.equalsIgnoreCase(POS_UNIT_PIXEL); 
                boolean isAbsoluteCoordinatesY = 
                    yUnits.equalsIgnoreCase(POS_UNIT_PIXEL); 
                getRobot().click(component, null, 
                    ClickOptions.create().setMouseButton(button),
                    xPos, isAbsoluteCoordinatesX, 
                    yPos, isAbsoluteCoordinatesY);
            }
        };
        return showPopup(showPopup);
    }
    
    /**
     * Shows a popup menu using the given runnable and waits for the popup
     * menu to appear.
     *
     * @param showPopupOperation The implementation to use for opening the
     *                           popup menu.
     * @return the popup menu.
     */
    public AbstractMenuCAPs showPopup(Runnable showPopupOperation) {
        PopupShownCondition cond = new PopupShownCondition();
        EventLock lock = new EventLock();
        EventListener listener = new EventListener(lock, cond);
        Toolkit.getDefaultToolkit().addAWTEventListener(listener,
                AWTEvent.CONTAINER_EVENT_MASK);

        // showPopupOperation must run in the current thread in order to
        // avoid a race condition.
        showPopupOperation.run();

        synchronized (lock) {
            try {
                long timeout = TimeoutConstants.SERVER_TIMEOUT_WAIT_FOR_POPUP;
                long done = System.currentTimeMillis() + timeout;
                long now;
                while ((!lock.isReleased() || (cond.getPopup() == null)
                        || !cond.getPopup().isShowing())
                        && (timeout > 0)) {
                    lock.wait(timeout);
                    now = System.currentTimeMillis();
                    timeout = done - now;
                }
            } catch (InterruptedException e) {
                // ignore
            } finally {
                Toolkit.getDefaultToolkit().removeAWTEventListener(listener);
            }
        }
        if (!lock.isReleased() || (cond.getPopup() == null)
                || !cond.getPopup().isShowing()) {
            throw new StepExecutionException("popup not shown", //$NON-NLS-1$
                    EventFactory.createActionError(
                            TestErrorEvent.POPUP_NOT_FOUND));
        }
        AbstractMenuCAPs menuCAPs = new JMenuBarCAPs();
        menuCAPs.setComponent(cond.getPopup());
        return menuCAPs;
    }
    
    /**
     * {@inheritDoc}
     */
    public void showToolTip(final String text, final int textSize,
            final int timePerWord, final int windowWidth) {
        throw new StepExecutionException(
                I18n.getString(TestErrorEvent.UNSUPPORTED_OPERATION_ERROR),
                EventFactory.createActionError(
                    TestErrorEvent.UNSUPPORTED_OPERATION_ERROR));
    }
    
    /**
     * {@inheritDoc}
     */
    public void gdDrag(int mouseButton, String modifier, int xPos,
            String xUnits, int yPos, String yUnits) {
        final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
        dndHelper.setMouseButton(mouseButton);
        dndHelper.setModifier(modifier);
        final IRobot robot = getRobot();
        clickDirect(0, mouseButton, xPos, xUnits, yPos, yUnits);
        CapUtil.pressOrReleaseModifiers(modifier, true);
        robot.mousePress(null, null, mouseButton);
    }


    /**
     * {@inheritDoc}
     */
    public void gdDrop(int xPos, String xUnits, int yPos, String yUnits,
            int delayBeforeDrop) {

        final DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
        final String modifier = dndHelper.getModifier();
        final int mouseButton = dndHelper.getMouseButton();
        try {
            clickDirect(0, mouseButton, xPos, xUnits, yPos, yUnits);
            TimeUtil.delay(delayBeforeDrop);
        } finally {
            getRobot().mouseRelease(null, null, mouseButton);
            CapUtil.pressOrReleaseModifiers(modifier, false);
        }
    }
    
        /**
         * clicks into the component.
         *
         * @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
         */
    private void clickDirect(int count, int button, int xPos, String xUnits,
            int yPos, String yUnits) throws StepExecutionException {

        getRobot().click(m_component, null,
                ClickOptions.create()
                    .setClickCount(count)
                    .setMouseButton(button),
                xPos, xUnits.equalsIgnoreCase(POS_UNIT_PIXEL),
                yPos, yUnits.equalsIgnoreCase(POS_UNIT_PIXEL));
    }
}




/*******************************************************************************
 * 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.uiadapter.factory;


import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JRadioButton;
import javax.swing.JTable;
import javax.swing.JTree;

import org.eclipse.jubula.rc.common.uiadapter.factory.IUIAdapterFactory;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;
import org.eclipse.jubula.rc.swing.swing.uiadapter.AbstractButtonAdapter;
import org.eclipse.jubula.rc.swing.swing.uiadapter.JMenuBarAdapter;
import org.eclipse.jubula.rc.swing.swing.uiadapter.JMenuItemAdapter;
import org.eclipse.jubula.rc.swing.swing.uiadapter.JPopupMenuAdapter;
import org.eclipse.jubula.rc.swing.swing.uiadapter.JTableAdapter;
import org.eclipse.jubula.rc.swing.swing.uiadapter.JTreeAdapter;
/**
 * This is the adapter factory for all swing components. It is
 * creating the specific adapter for a swing component.
 * 
 * Since we are using adapter here, it is a adapter factory. But this must not
 * be the case. It is only relevant that the object is implementing the
 * specific interface.
 * @author BREDEX GmbH
 *
 */
public class SwingAdapterFactory implements IUIAdapterFactory {
    /**
     * 
     */
    private static final Class[] SUPPORTEDCLASSES = new Class[] { 
        JButton.class, JCheckBox.class, JRadioButton.class,
        JMenuBar.class, JMenuItem.class, JTree.class , 
        JCheckBox.class, JRadioButton.class, JTable.class, JPopupMenu.class};
    
    /**
     * {@inheritDoc}
     */
    public Class[] getSupportedClasses() {

        return SUPPORTEDCLASSES;
    }
    /**
     * {@inheritDoc}
     */
    public IComponentAdapter getAdapter(Object objectToAdapt) {
        IComponentAdapter returnvalue = null;
        if (objectToAdapt instanceof JButton) {
            returnvalue = new AbstractButtonAdapter(objectToAdapt);
            
        } else if (objectToAdapt instanceof JRadioButton) {
            returnvalue = new AbstractButtonAdapter(objectToAdapt);
            
        } else if (objectToAdapt instanceof JCheckBox) {
            returnvalue = new AbstractButtonAdapter(objectToAdapt);
            
        } else if (objectToAdapt instanceof JMenuBar) {
        
            returnvalue = new JMenuBarAdapter(objectToAdapt); 
            
        } else if (objectToAdapt instanceof JMenuItem) {
            returnvalue = new JMenuItemAdapter(objectToAdapt);            
            
        } else if (objectToAdapt instanceof JTree) {
            returnvalue = new JTreeAdapter(objectToAdapt);
            
        } else if (objectToAdapt instanceof JTable) {
            returnvalue = new JTableAdapter(objectToAdapt);
            
        } else if (objectToAdapt instanceof JPopupMenu) {
            returnvalue = new JPopupMenuAdapter(objectToAdapt);
        
        }
        
        return returnvalue;
    }

}

Lines 15-20 import java.lang.reflect.InvocationTargetException; Link Here

(-)a/org.eclipse.jubula.rc.swt/src/org/eclipse/jubula/rc/swt/SwtAUTServer.java (-1 / +9 lines)
15	import org.eclipse.jubula.rc.common.AUTServer;	15	import org.eclipse.jubula.rc.common.AUTServer;
16	import org.eclipse.jubula.rc.common.driver.IRobot;	16	import org.eclipse.jubula.rc.common.driver.IRobot;
17	import org.eclipse.jubula.rc.common.listener.BaseAUTListener;	17	import org.eclipse.jubula.rc.common.listener.BaseAUTListener;
		18	import org.eclipse.jubula.rc.common.uiadapter.factory.GUIAdapterFactoryRegistry;
18	import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;	19	import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;
19	import org.eclipse.jubula.rc.swt.driver.RobotFactorySwtImpl;	20	import org.eclipse.jubula.rc.swt.driver.RobotFactorySwtImpl;
20	import org.eclipse.jubula.rc.swt.driver.RobotSwtImpl;	21	import org.eclipse.jubula.rc.swt.driver.RobotSwtImpl;
Lines 25-30 import org.eclipse.jubula.rc.swt.listener.FocusTracker; Link Here
25	import org.eclipse.jubula.rc.swt.listener.MappingListener;	26	import org.eclipse.jubula.rc.swt.listener.MappingListener;
26	import org.eclipse.jubula.rc.swt.listener.RecordListener;	27	import org.eclipse.jubula.rc.swt.listener.RecordListener;
27	import org.eclipse.jubula.rc.swt.listener.TableSelectionTracker;	28	import org.eclipse.jubula.rc.swt.listener.TableSelectionTracker;
		29	import org.eclipse.jubula.rc.swt.uiadapter.factory.SWTAdapterFactory;
28	import org.eclipse.jubula.tools.constants.AUTServerExitConstants;	30	import org.eclipse.jubula.tools.constants.AUTServerExitConstants;
29	import org.eclipse.jubula.tools.constants.DebugConstants;	31	import org.eclipse.jubula.tools.constants.DebugConstants;
30	import org.eclipse.swt.widgets.Display;	32	import org.eclipse.swt.widgets.Display;
Lines 215-225 public class SwtAUTServer extends AUTServer { Link Here
215	*/	217	*/
216	protected void startTasks() throws ExceptionInInitializerError,	218	protected void startTasks() throws ExceptionInInitializerError,
217	InvocationTargetException, NoSuchMethodException {	219	InvocationTargetException, NoSuchMethodException {
218		220
		221	// FIXME Better place to put the registration of the factory
		222	GUIAdapterFactoryRegistry.getInstance().
		223	registerFactory(new SWTAdapterFactory());
		224	System.out.println("AdapterFactory registered"); //$NON-NLS-1$
		225
219	super.invokeAUT();	226	super.invokeAUT();
220	if (getCommunicator() != null) {	227	if (getCommunicator() != null) {
221	getCommunicator().close();	228	getCommunicator().close();
222	}	229	}
		230
223	}	231	}
224		232
225	/**	233	/**




/*******************************************************************************
 * 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 org.eclipse.jubula.rc.common.caps.AbstractButtonCAPs;
import org.eclipse.jubula.rc.common.driver.IRobotFactory;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IButtonAdapter;
import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;
import org.eclipse.jubula.rc.swt.utils.SwtUtils;


/**
 * The Toolkit specific implementation for <code>SWTButton</code> and subclasses.
 *
 * @author BREDEX GmbH
 */
public class ButtonCAPs extends AbstractButtonCAPs {
    
    /** The robot factory. */
    private IRobotFactory m_robotFactory;
    
    /**
     * {@inheritDoc}
     */
    public String[] getTextArrayFromComponent() {
        return new String[] {
                SwtUtils.removeMnemonics(
                        ((IButtonAdapter)getComponent()).getText())};
    }
    
    /**
     * Gets the Robot factory. The factory is created once per instance.
     * @return The Robot factory.
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }


}




/*******************************************************************************
 * 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.Point;
import java.util.StringTokenizer;

import org.eclipse.jubula.rc.common.AUTServer;
import org.eclipse.jubula.rc.common.driver.IRobot;
import org.eclipse.jubula.rc.common.exception.RobotException;
import org.eclipse.jubula.rc.common.util.KeyStrokeUtil;
import org.eclipse.jubula.rc.swt.driver.KeyCodeConverter;
import org.eclipse.jubula.rc.swt.driver.SwtRobot;
import org.eclipse.jubula.tools.utils.EnvironmentUtils;
import org.eclipse.jubula.tools.utils.TimeUtil;
import org.eclipse.swt.widgets.Display;
/**
 * Util class for some swt specific commands.
 * 
 * @author BREDEX GmbH
 */
public class CAPUtil {

       
    /**
     * 
     */
    private CAPUtil() { }
    
    
    /**
     * Gets the Robot. 
     * @return The Robot
     * @throws RobotException If the Robot cannot be created.
     */
    public static IRobot getRobot() throws RobotException {
        return AUTServer.getInstance().getRobot();
    }
    
    /**
     * Waits the given amount of time. Logs a drop-related error if interrupted.
     * 
     * @param delayBeforeDrop the amount of time (in milliseconds) to wait
     *                        between moving the mouse to the drop point and
     *                        releasing the mouse button                       
     */
    public static void waitBeforeDrop(int delayBeforeDrop) {
        TimeUtil.delay(delayBeforeDrop);
    }
    
    /**
     * Move the mouse pointer from its current position to a few points in
     * its proximity. This is used to initiate a drag operation.
     * 
     */
    public static void shakeMouse() {
        /** number of pixels by which a "mouse shake" offsets the mouse cursor */
        final int mouseShakeOffset = 10;
        
        Point origin = getRobot().getCurrentMousePosition();
        SwtRobot lowLevelRobot = new SwtRobot(Display.getDefault());
        lowLevelRobot.mouseMove(
                origin.x + mouseShakeOffset, 
                origin.y + mouseShakeOffset);
        lowLevelRobot.mouseMove(
                origin.x - mouseShakeOffset, 
                origin.y - mouseShakeOffset);
        lowLevelRobot.mouseMove(origin.x, origin.y);
        if (!EnvironmentUtils.isWindowsOS() 
                && !EnvironmentUtils.isMacOS()) {
            boolean moreEvents = true;
            while (moreEvents) {
                moreEvents = Display.getDefault().readAndDispatch();
            }
        }
    }
    
    /**
     * Presses or releases the given modifier.
     * @param modifier the modifier.
     * @param press if true, the modifier will be pressed.
     * if false, the modifier will be released.
     */
    public static void pressOrReleaseModifiers(String modifier, boolean press) {
        final IRobot robot = getRobot();
        final StringTokenizer modTok = new StringTokenizer(
                KeyStrokeUtil.getModifierString(modifier), " "); //$NON-NLS-1$
        while (modTok.hasMoreTokens()) {
            final String mod = modTok.nextToken();
            final int keyCode = KeyCodeConverter.getKeyCode(mod);
            if (press) {
                robot.keyPress(null, keyCode);
            } else {
                robot.keyRelease(null, keyCode);
            }
        }
    }
    

}




/*******************************************************************************
 * 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 org.apache.commons.lang.Validate;
import org.eclipse.jubula.rc.common.caps.AbstractMenuCAPs;
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.RobotException;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.implclasses.IBaseImplementationClass;
import org.eclipse.jubula.rc.common.implclasses.MenuUtilBase;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;
import org.eclipse.jubula.rc.swt.driver.EventThreadQueuerSwtImpl;
import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;
import org.eclipse.jubula.rc.swt.driver.RobotSwtImpl;
import org.eclipse.jubula.rc.swt.uiadapter.MenuItemAdapter;
import org.eclipse.jubula.tools.i18n.I18n;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MenuEvent;
import org.eclipse.swt.events.MenuListener;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Shell;
/**
 * Toolkit specific commands for the <code>Menu</code>
 * 
 * @author BREDEX GmbH
 */
public class MenuCAPs extends AbstractMenuCAPs 
    implements IBaseImplementationClass {
    /** the RobotFactory from the AUT */
    private IRobotFactory m_robotFactory;
    
    /** Test variable for contextMenus*/
    private boolean m_isCM = false;
    /**
     * Gets the IEventThreadQueuer.
     * 
     * @return The Robot
     * @throws RobotException
     *             If the Robot cannot be created.
     */
    protected IRobot getRobot() throws RobotException {
        return getRobotFactory().getRobot();
    }

    /**
     * @return The event thread queuer.
     */
    public IEventThreadQueuer getEventThreadQueuer() {
        return getRobotFactory().getEventThreadQueuer();
    }
    
    /**
     * {@inheritDoc}
     */
    public IComponentAdapter getComponent() {
        if (m_isCM) {
            return super.getComponent();
        }
        final Shell shell = ((RobotSwtImpl)getRobot()).getActiveWindow();
        if (shell == null) {
            setComponent(null);
        } else {
            final IEventThreadQueuer queuer = new EventThreadQueuerSwtImpl();
            
            queuer.invokeAndWait("setMenuBarComponent", new IRunnable() { //$NON-NLS-1$
                public Object run() {
                    Menu menu = shell.getMenuBar();
                    setComponent(menu);
                    
                    return null;
                }
            });
        }
        return super.getComponent();
    }
    
    /**
     * {@inheritDoc}
     */
    public String[] getTextArrayFromComponent() {
        return null;
    }
    /**
     * {@inheritDoc}
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }
    
    /**
     * Tries to select a menu item in a menu defined by a Text-Path
     * @param namePath the menu item to select
     * @param operator operator used for matching
     */
    public void selectMenuItem(String namePath, final String operator) {        
        final String[] pathItems = MenuUtilBase.splitPath(namePath);
        if (pathItems.length == 0) {
            throw new StepExecutionException("empty path to menuitem not allowed", //$NON-NLS-1$
                EventFactory.createActionError());
        }
        
        try {

            final MenuItemAdapter itemAdapter = 
                    (MenuItemAdapter) navigateToMenuItem(
                            getAndCheckMenu(), pathItems, operator);
            if (itemAdapter.getRealComponent() == null) {
                throwMenuItemNotFound();
            }
            
            Rectangle bounds = itemAdapter.getMenuItemBounds();
            Rectangle nullBounds = new Rectangle(0, 0, 0, 0);
            
            if (bounds.equals(nullBounds)) {
                itemAdapter.selectProgramatically();
            } else {
                itemAdapter.selectMenuItem();
            }
        } catch (StepExecutionException e) {
            try {
                closeMenu(getAndCheckMenu(), pathItems, operator);
            } catch (StepExecutionException e1) {
                if (getLog().isInfoEnabled()) {
                    getLog().info("Tried to close a disabled or already closed menu."); //$NON-NLS-1$
                }
            }
            throw e;
        }
        
    }
    
    /**
     * Tries to select a menu item in a menu defined by an Index-Path
     * @param indexPath the menu item to select
     */
    public void selectMenuItemByIndexpath(String indexPath) {
        final int[] indexItems = MenuUtilBase.splitIndexPath(indexPath);
        if (indexItems.length == 0) {
            throw new StepExecutionException("empty path to menuitem not allowed", //$NON-NLS-1$
                EventFactory.createActionError());
        }

        try {
            MenuItemAdapter menuItemAdapter = (MenuItemAdapter) 
                    navigateToMenuItem(getAndCheckMenu(), indexItems);
            if (menuItemAdapter.getRealComponent() == null) {
                throwMenuItemNotFound();
            }
            
            Rectangle bounds = menuItemAdapter.getMenuItemBounds();
            Rectangle nullBounds = new Rectangle(0, 0, 0, 0);
            
            if (bounds.equals(nullBounds)) {
                menuItemAdapter.selectProgramatically();
            } else {
                menuItemAdapter.selectMenuItem();
            }
        } catch (StepExecutionException e) {
            try {
                closeMenu(getAndCheckMenu(), indexItems);
            } catch (StepExecutionException e1) {
                if (getLog().isInfoEnabled()) {
                    getLog().info("Tried to close a disabled or already closed menu."); //$NON-NLS-1$
                }
            }
            throwMenuItemNotFound();
        }
    }

    /**
     * 
     * @return the IMenuAdapter.
     * @throws StepExecutionException
     *             if the active window has no menu bar.
     */
    protected IMenuAdapter getAndCheckMenu() throws StepExecutionException {
        // Verify that there is an active window
        if (((RobotSwtImpl)getRobot()).getActiveWindow() == null) {
            throw new StepExecutionException(
                I18n.getString(TestErrorEvent.NO_ACTIVE_WINDOW), 
                EventFactory.createActionError(
                    TestErrorEvent.NO_ACTIVE_WINDOW));
        }
        return super.getAndCheckMenu();
    }
    
    
    /**
     * 
     */
    private void throwMenuItemNotFound() {
        throw new StepExecutionException("no such menu item found", //$NON-NLS-1$
            EventFactory.createActionError(TestErrorEvent.NOT_FOUND));
    }
 
    /**
     * {@inheritDoc}
     */
    protected IMenuItemAdapter newMenuItemAdapter(Object component) {
        return new MenuItemAdapter(component);
    }
    
    /**
     * {@inheritDoc}
     */
    protected void closeMenu(IMenuAdapter menuBar, int[] path) {
        Validate.notNull(getMenu(menuBar));
        closeMenu(menuBar, path.length);
        
    }
    
    /**
     * {@inheritDoc}
     */
    protected void closeMenu(IMenuAdapter menuBar, String[] textPath,
            String operator) {
        Validate.notNull(getMenu(menuBar));
        closeMenu(menuBar, textPath.length);
    }
    
    /**
     * Closes the menu cascade with the KEY ESC
     * @param menuBar menu
     * @param maxCascadeLength an integer so that the closing operation is not infinite
     */
    private void closeMenu(final IMenuAdapter menuBar, int maxCascadeLength) {
        final MenuHiddenListener menuListener = 
                new MenuHiddenListener();
        getMenu(menuBar).getDisplay().syncExec(new Runnable() {
            public void run() {
                getMenu(menuBar).addMenuListener(menuListener);
            }
        });
        // Press 'ESC' key until the first menu is gone or we reach
        // the maxCascadeLength. This prevents infinite loops if this
        // is used on a platform that does not use 'ESC' to close menus.
        for (int i = 0; 
            i < maxCascadeLength && !menuListener.isMenuHidden();
            i++) {

            getRobot().keyType(getMenu(menuBar), SWT.ESC);
        }
        
    }

    /**
     * 
     * @param menu the menu adapter
     * @return the real SWT menu 
     */
    private Menu getMenu(final IMenuAdapter menu) {
        return (Menu) menu.getRealComponent();
    }
    /**
     * 
     * @return -
     */
    public boolean isContextMenu() {
        return m_isCM;
    }
    /**
     * 
     * @param isCM 
     */
    public void setContextMenu(boolean isCM) {
        this.m_isCM = isCM;
    }

    /**
     * Listens for a menu to be hidden, the removes itself from the menu's
     * listener list.
     * 
     * @author BREDEX GmbH
     * @created Nov 01, 2011
     */
    private static final class MenuHiddenListener implements MenuListener {

        /** whether the expected event has occurred */
        private boolean m_eventOccurred = false;
        
        /**
         * 
         * {@inheritDoc}
         */
        public void menuHidden(MenuEvent e) {
            m_eventOccurred = true;
            ((Menu)e.widget).removeMenuListener(this);
        }

        /**
         * 
         * {@inheritDoc}
         */
        public void menuShown(MenuEvent e) {
            // no-op
        }

        /**
         * 
         * @return <code>true</code> if the menu has been hidden since this 
         *         listener was registered. Otherwise, <code>false</code>.
         */
        public boolean isMenuHidden() {
            return m_eventOccurred;
        }
    }
    
}




/*******************************************************************************
 * 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.Point;
import java.awt.Rectangle;

import org.eclipse.jubula.rc.common.CompSystemConstants;
import org.eclipse.jubula.rc.common.caps.AbstractTableCAPs;
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.table.Cell;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.ITableAdapter;
import org.eclipse.jubula.rc.swt.driver.DragAndDropHelperSwt;
import org.eclipse.jubula.rc.swt.driver.KeyCodeConverter;
import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;
import org.eclipse.jubula.rc.swt.uiadapter.TableAdapter;
import org.eclipse.jubula.rc.swt.utils.SwtUtils;
import org.eclipse.jubula.tools.constants.InputConstants;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.FontMetrics;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Widget;
/**
 * Toolkit specific commands for the <code>Table</code>
 *
 * @author BREDEX GmbH
 */
public class TableCAPs extends AbstractTableCAPs {
    
    /**  */
    private IRobotFactory m_robotFactory;

    /**
     *  Gets the real table component
     * @return the table
     */
    private Table getTable() {
        return (Table)getComponent().getRealComponent();
    }
    
    /**
     * @return The event thread queuer.
     */
    public IEventThreadQueuer getEventThreadQueuer() {
        return getRobotFactory().getEventThreadQueuer();
    }
    
    /**
     * {@inheritDoc}
     */
    public String[] getTextArrayFromComponent() {
        final String[] componentTextArray;
        Item[] itemArray = getTable().getColumns();
        componentTextArray = getTextArrayFromItemArray(itemArray);         
        return componentTextArray;
    }

    /**
     * {@inheritDoc}
     */
    protected int getKeyCode(String mod) {
        return KeyCodeConverter.getKeyCode(mod);
    }
    
    /**
     * {@inheritDoc}
     */
    protected Object setEditorToReplaceMode(Object editor, boolean replace) {
        if (replace) {
            getRobot().clickAtCurrentPosition(editor, 3, 
                    InputConstants.MOUSE_BUTTON_LEFT);
        } else {
            getRobot().clickAtCurrentPosition(editor, 1, 
                    InputConstants.MOUSE_BUTTON_LEFT);
        }
        return editor;
    }

    /**
     * {@inheritDoc}
     */
    protected Object activateEditor(Cell cell, Rectangle rectangle) {
        TableAdapter table = (TableAdapter) getComponent();
        return table.activateEditor(cell);
    }

    /**
     * {@inheritDoc}
     */
    protected Rectangle scrollCellToVisible(final int row, final int col)
        throws StepExecutionException {
        final Table table = getTable();
        getEventThreadQueuer().invokeAndWait("scrollCellToVisible", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        if (table.getColumnCount() > 0 || col > 0) {
                            table.showColumn(table.getColumn(col));
                        }
                        table.showItem(table.getItem(row));
                        return null;
                    }
                });

        final Rectangle cellBoundsRelativeToParent = getCellBounds(row, col);
            
        getEventThreadQueuer().invokeAndWait("getCellBoundsRelativeToParent", //$NON-NLS-1$
            new IRunnable() {
                public Object run() {
                    org.eclipse.swt.graphics.Point cellOriginRelativeToParent = 
                        table.getDisplay().map(
                                table, table.getParent(), 
                                new org.eclipse.swt.graphics.Point(
                                        cellBoundsRelativeToParent.x, 
                                        cellBoundsRelativeToParent.y));
                    cellBoundsRelativeToParent.x = 
                        cellOriginRelativeToParent.x;
                    cellBoundsRelativeToParent.y = 
                        cellOriginRelativeToParent.y;
                    return null;
                }
            });

        Control parent = (Control)getEventThreadQueuer().invokeAndWait("getParent", //$NON-NLS-1$
                new IRunnable() {
                public Object run() {
                    table.getParent();
                    return null;
                }
            });

            
        getRobot().scrollToVisible(
                parent, cellBoundsRelativeToParent);
        
        return getVisibleBounds(getCellBounds(row, col));
    }

    /**
     * {@inheritDoc}
     */
    protected int getExtendSelectionModifier() {
        return SWT.MOD1;
    }

    /**
     * {@inheritDoc}
     */
    protected Cell getCellAtMousePosition() throws StepExecutionException {
        
        final Table table = getTable();
        final Point awtMousePos = getRobot().getCurrentMousePosition();
        Cell returnvalue = (Cell) getEventThreadQueuer().invokeAndWait(
                "getCellAtMousePosition",  //$NON-NLS-1$
                new IRunnable() {
                    public Object run() throws StepExecutionException {
                        Cell cell = null;
                        final int itemCount = table.getItemCount();
                        for (int rowCount = table.getTopIndex(); 
                                rowCount < itemCount; rowCount++) {
                            if (cell != null) {
                                break;
                            }
                            final int columnCount = table.getColumnCount();
                            if (columnCount > 0) {
                                for (int col = 0; col < columnCount; col++) {
                                    final Rectangle itemBounds = getCellBounds(
                                            rowCount, col);
                                    final org.eclipse.swt.graphics.Point 
                                        absItemBounds = table
                                            .toDisplay(itemBounds.x,
                                                    itemBounds.y);
                                    final Rectangle absRect = new Rectangle(
                                            absItemBounds.x, absItemBounds.y,
                                            itemBounds.width,
                                            itemBounds.height);
                                    if (absRect.contains(awtMousePos)) {
                                        cell = new Cell(rowCount, col);
                                        break;
                                    }
                                }
                            } else {
                                final Rectangle itemBounds = getCellBounds(
                                        rowCount, 0);
                                final org.eclipse.swt.graphics.Point 
                                    absItemBounds = table
                                        .toDisplay(itemBounds.x, itemBounds.y);
                                final Rectangle absRect = new Rectangle(
                                        absItemBounds.x, absItemBounds.y,
                                        itemBounds.width, itemBounds.height);
                                if (absRect.contains(awtMousePos)) {
                                    cell = new Cell(rowCount, 0);
                                }
                            }
                        }
                        if (cell == null) {
                            throw new StepExecutionException(
                                    "No cell under mouse position found!", //$NON-NLS-1$
                                    EventFactory
                                            .createActionError(
                                                    TestErrorEvent.NOT_FOUND));
                        }
                        return cell;
                    }
                });
        return returnvalue;
    }

    /**
     * {@inheritDoc}
     */
    protected boolean isMouseOnHeader() {
        final Table table = getTable();
        final ITableAdapter adapter = (ITableAdapter)getComponent();
        Boolean isVisible;
        isVisible = (Boolean)getEventThreadQueuer().invokeAndWait(
                "isMouseOnHeader", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        return new Boolean(table.getHeaderVisible());
                    }
                });
        
        if (!(isVisible.booleanValue())) {
            return false;
        }
        
        Boolean isOnHeader = new Boolean(false);
        isOnHeader = (Boolean)getEventThreadQueuer().invokeAndWait(
                "isMouseOnHeader", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        final Point awtMousePos = getRobot()
                            .getCurrentMousePosition();
                        org.eclipse.swt.graphics.Point mousePos =
                            new org.eclipse.swt.graphics.Point(
                                awtMousePos.x, awtMousePos.y);

                        for (int j = 0; j < table.getColumnCount(); j++) {
                            final Rectangle constraints = 
                                    adapter.getHeaderBounds(j);
                            
                            org.eclipse.swt.graphics.Rectangle bounds = 
                                    SwtUtils.getWidgetBounds(
                                    table);
                            
                            if (constraints != null) {
                                // Use SWT's mapping function, if possible, as it is more
                                // multi-platform than simply adding the x and y values.
                                org.eclipse.swt.graphics.Point
                                convertedLocation = getConvertedLocation(
                                        constraints);
                                bounds.x = convertedLocation.x;
                                bounds.y = convertedLocation.y;
                                
                                bounds.height = constraints.height;
                                bounds.width = constraints.width;
                            }

                            if (bounds.contains(mousePos)) {
                                return new Boolean(true);
                            }
                        }      
                        return new Boolean(false);
                    }
                });                  
        
        return isOnHeader.booleanValue();
    }

    /**
     * {@inheritDoc}
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }

    
    /**
     * Returns an array of representation strings that corresponds to the given
     * array of items or null if the given array is null;
     * @param itemArray the item array whose item texts have to be read
     * @return array of item texts corresponding to the given item array
     */
    protected final String[] getTextArrayFromItemArray(Item[] itemArray) {
        final String[] itemTextArray;
        if (itemArray == null) {
            itemTextArray = null;
        } else {
            itemTextArray = new String[itemArray.length];
            for (int i = 0; i < itemArray.length; i++) {
                Item item = itemArray[i];
                if (item == null) {
                    itemTextArray[i] = null;
                } else {
                    itemTextArray[i] = SwtUtils.removeMnemonics(item.getText());
                }
            }
        }
        
        return itemTextArray;
    }
    
    /**
     * Computes the visible cellBounds inside the visible bounds of the table.<br>
     * The result is the intersection of the visible bounds of the table and the 
     * bounds of the cell.
     * @param cellBounds the bounds of the cell to click in. These bounds must
     *                  be relative to the table's location.
     * @return the visible cell bounds, relative to the table's location.
     */
    private Rectangle getVisibleBounds(Rectangle cellBounds) {
        org.eclipse.swt.graphics.Rectangle r = 
            (org.eclipse.swt.graphics.Rectangle)
            getEventThreadQueuer().invokeAndWait("getVisibleCellBounds: " + cellBounds,  //$NON-NLS-1$
                    new IRunnable() {

                    public Object run() {
                        return getTable().getClientArea();
                    }
                });
        
        Rectangle visibleTableBounds = new Rectangle(
            r.x, r.y, r.width, r.height);
        Rectangle visibleCellBounds = 
            visibleTableBounds.intersection(cellBounds);
        return visibleCellBounds;
    }
    
    /**
     * @param constraints Rectangle
     * @return converted Location of table
     */
    private org.eclipse.swt.graphics.Point getConvertedLocation(
            final Rectangle constraints) {
        org.eclipse.swt.graphics.Point convertedLocation =
            (org.eclipse.swt.graphics.Point)getEventThreadQueuer()
                .invokeAndWait("toDisplay", new IRunnable() { //$NON-NLS-1$
                    public Object run() throws StepExecutionException {
                        return getTable().toDisplay(
                                constraints.x, constraints.y);
                    }
                });
        return convertedLocation;
    }
        
    /**
     * 
     * @param row   The row of the cell
     * @param col   The column of the cell
     * @return The bounding rectangle for the cell, relative to the table's 
     *         location.
     */
    private Rectangle getCellBounds(final int row, final int col) {
        final Table table = getTable();
        Rectangle cellBounds = (Rectangle)getEventThreadQueuer().invokeAndWait(
                "evaluateCellBounds", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        checkRowColBounds(row, col);
                        TableItem ti = table.getItem(row);
                        int column = (table.getColumnCount() > 0 || col > 0) 
                            ? col : 0;
                        org.eclipse.swt.graphics.Rectangle r = 
                                ti.getBounds(column);
                        String text = ti.getText(column);
                        Image image = ti.getImage(column);
                        if (text != null && text.length() != 0) {
                            GC gc = new GC(table);
                            int charWidth = 0; 
                            try {
                                FontMetrics fm = gc.getFontMetrics();
                                charWidth = fm.getAverageCharWidth();
                            } finally {
                                gc.dispose();
                            }
                            r.width = text.length() * charWidth;
                            if (image != null) {
                                r.width += image.getBounds().width;
                            }
                        } else if (image != null) {
                            r.width = image.getBounds().width;
                        }
                        if (column > 0) {
                            TableColumn tc = table.getColumn(column);
                            int alignment = tc.getAlignment();
                            if (alignment == SWT.CENTER) {
                                r.x += ((double)tc.getWidth() / 2) 
                                        - ((double)r.width / 2);
                            }
                            if (alignment == SWT.RIGHT) {
                                r.x += tc.getWidth() - r.width;
                            }
                        }
                        
                        return new Rectangle(r.x, r.y, r.width, r.height);
                    }
                });
        return cellBounds;
    }
    /**
     * {@inheritDoc}
     */
    protected Object getSpecificRectangle(Rectangle rectangle) {
        return new org.eclipse.swt.graphics.Rectangle(rectangle.x, rectangle.y,
                rectangle.width, rectangle.height);
    }
    
    /**
     * {@inheritDoc}
     */
    public void gdClickDirect(int count, int button, int xPos, String xUnits, 
        int yPos, String yUnits) throws StepExecutionException {
        
        int correctedYPos = correctYPos(yPos, yUnits);
        super.gdClickDirect(count, button, xPos, xUnits, correctedYPos, yUnits);
    }
    
    /**
     * Corrects the given Y position based on the height of the table's header.
     * This ensures, for example, that test steps don't try to click within the
     * table header (where we receive no confirmation events).
     * 
     * @param pos The Y position to correct.
     * @param units The units used for the Y position.
     * @return The corrected Y position.
     */
    private int correctYPos(int pos, String units) {
        int correctedPos = pos;
        int headerHeight = ((Integer)getEventThreadQueuer().invokeAndWait(
                "getHeaderHeight", new IRunnable() { //$NON-NLS-1$

                    public Object run() throws StepExecutionException {
                        return new Integer(
                            ((Table)getComponent().getRealComponent())
                            .getHeaderHeight());
                    }
            
                })).intValue();

        if (POS_UNIT_PIXEL.equalsIgnoreCase(units)) {
            // Pixel units
            correctedPos += headerHeight;
        } else {
            // Percentage units
            int totalHeight = ((Integer)getEventThreadQueuer().invokeAndWait(
                    "getWidgetBounds", new IRunnable() { //$NON-NLS-1$

                        public Object run() throws StepExecutionException {
                            return new Integer(
                                SwtUtils.getWidgetBounds(
                                    (Widget) getComponent().
                                        getRealComponent()).height);
                        }
            
                    })).intValue();
            long targetHeight = totalHeight - headerHeight;
            long targetPos = Math.round((double)targetHeight * (double)pos
                / 100.0);
            targetPos += headerHeight;
            double heightPercentage = 
                (double)targetPos / (double)totalHeight * 100.0;
            correctedPos = (int)Math.round(heightPercentage);
            if (correctedPos > 100) { // rounding error
                correctedPos = 100;
            }
        }
        return correctedPos;
    }
    
    /**
     * Drags the cell of the Table.<br>
     * With the xPos, yPos, xunits and yUnits the click position inside the 
     * cell can be defined.
     * 
     * @param mouseButton the mouseButton.
     * @param modifier the modifier.
     * @param row The row of the cell.
     * @param rowOperator the row header operator
     * @param col The column of the cell.
     * @param colOperator the column header operator
     * @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
     *             If the row or the column is invalid
     */
    public void gdDragCell(final int mouseButton, final String modifier, 
            final String row, String rowOperator, final String col,
            final String colOperator, final int xPos, final String xUnits,
            final int yPos, final String yUnits) 
        throws StepExecutionException {
        
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        dndHelper.setMouseButton(mouseButton);
        dndHelper.setModifier(modifier);
        dndHelper.setDragComponent(null);
        
        gdSelectCell(row, rowOperator, col, colOperator, 0, xPos,
                xUnits, yPos, yUnits, 
                CompSystemConstants.EXTEND_SELECTION_NO, 1);
    }
    
    /**
     * Drops on the cell of the JTable.<br>
     * With the xPos, yPos, xunits and yUnits the click position inside the 
     * cell can be defined.
     * 
     * @param row The row of the cell.
     * @param rowOperator The row operator
     * @param col The column of the cell.
     * @param colOperator The column operator
     * @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
     * @param delayBeforeDrop the amount of time (in milliseconds) to wait
     *                        between moving the mouse to the drop point and
     *                        releasing the mouse button                       
     * @throws StepExecutionException
     *             If the row or the column is invalid
     */
    public void gdDropCell(final String row, final String rowOperator,
            final String col, final String colOperator, final int xPos, 
            final String xUnits, final int yPos, final String yUnits,
            int delayBeforeDrop) throws StepExecutionException {
        
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        final IRobot robot = getRobot();
        
        pressOrReleaseModifiers(dndHelper.getModifier(), true);
        try {
            getEventThreadQueuer().invokeAndWait("gdDropCell", new IRunnable() { //$NON-NLS-1$

                public Object run() throws StepExecutionException {
                    // drag
                    robot.mousePress(dndHelper.getDragComponent(), null, 
                            dndHelper.getMouseButton());

                    CAPUtil.shakeMouse();

                    // drop
                    gdSelectCell(row, rowOperator, col, colOperator, 0, xPos,
                            xUnits, yPos, yUnits, 
                            CompSystemConstants.EXTEND_SELECTION_NO, 1);
                    return null;
                }            
            });

            CAPUtil.waitBeforeDrop(delayBeforeDrop);
            
        } finally {
            robot.mouseRelease(dndHelper.getDragComponent(), null, 
                    dndHelper.getMouseButton());
            pressOrReleaseModifiers(dndHelper.getModifier(), false);
        }
    }
    
    /**
     * Finds the first row which contains the value <code>value</code>
     * in column <code>col</code> and drags this row.
     * 
     * @param mouseButton the mouse button
     * @param modifier the modifier
     * @param col the column
     * @param colOperator the column header operator
     * @param value the value
     * @param regexOp the regex operator
     * @param searchType Determines where the search begins ("relative" or "absolute")
     */
    public void gdDragRowByValue(int mouseButton, String modifier, String col,
            String colOperator, final String value, final String regexOp,
            final String searchType) {
        
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        dndHelper.setMouseButton(mouseButton);
        dndHelper.setModifier(modifier);
        dndHelper.setDragComponent(null);
        
        gdSelectRowByValue(col, colOperator, value, regexOp, 1, 
                CompSystemConstants.EXTEND_SELECTION_NO,
                searchType, 1);
    }
    
    /**
     * Finds the first row which contains the value <code>value</code>
     * in column <code>col</code> and drops on this row.
     * 
     * @param col the column
     * @param colOperator the column operator
     * @param value the value
     * @param regexOp the regex operator
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param delayBeforeDrop the amount of time (in milliseconds) to wait
     *                        between moving the mouse to the drop point and
     *                        releasing the mouse button                       
     */
    public void gdDropRowByValue(final String col, final String colOperator,
            final String value, final String regexOp, final String searchType, 
            int delayBeforeDrop) {
        
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        final IRobot robot = getRobot();
        pressOrReleaseModifiers(dndHelper.getModifier(), true);
        
        try {
            getEventThreadQueuer().invokeAndWait("gdDropRowByValue", new IRunnable() { //$NON-NLS-1$

                public Object run() throws StepExecutionException {
                    // drag
                    robot.mousePress(dndHelper.getDragComponent(), null, 
                            dndHelper.getMouseButton());

                    CAPUtil.shakeMouse();

                    // drop
                    gdSelectRowByValue(col, colOperator, value, regexOp,
                            CompSystemConstants.EXTEND_SELECTION_NO, 
                            searchType, 
                            ClickOptions.create().setClickCount(0));
                    return null;
                }            
            });
            
            CAPUtil.waitBeforeDrop(delayBeforeDrop);
            
        } finally {
            robot.mouseRelease(dndHelper.getDragComponent(), null, 
                    dndHelper.getMouseButton());
            pressOrReleaseModifiers(dndHelper.getModifier(), false);
        }
    }
    
    /**
     * Finds the first column which contains the value <code>value</code>
     * in the given row and drags the cell.
     * 
     * @param mouseButton the mouse button
     * @param modifier the modifiers
     * @param row the row
     * @param rowOperator the row header operator
     * @param value the value
     * @param regex search using regex
     * @param searchType Determines where the search begins ("relative" or "absolute")
     */
    public void gdDragCellByColValue(int mouseButton, String modifier,
            String row, String rowOperator, final String value,
            final String regex, final String searchType) {
        
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        dndHelper.setMouseButton(mouseButton);
        dndHelper.setModifier(modifier);
        dndHelper.setDragComponent(null);
        gdSelectCellByColValue(row, rowOperator, value, regex, 
                CompSystemConstants.EXTEND_SELECTION_NO,
                searchType, ClickOptions.create().setClickCount(0));
    }
    
    /**
     * Finds the first column which contains the value <code>value</code>
     * in the given row and drops on the cell.
     * 
     * @param row the row
     * @param rowOperator the row header operator
     * @param value the value
     * @param regex search using regex
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param delayBeforeDrop the amount of time (in milliseconds) to wait
     *                        between moving the mouse to the drop point and
     *                        releasing the mouse button                       
     */
    public void gdDropCellByColValue(final String row, final String rowOperator,
            final String value, final String regex, final String searchType,
            int delayBeforeDrop) {
        
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        final IRobot robot = getRobot();
        pressOrReleaseModifiers(dndHelper.getModifier(), true);

        try {
            getEventThreadQueuer().invokeAndWait("gdDropCellByColValue", new IRunnable() { //$NON-NLS-1$

                public Object run() throws StepExecutionException {
                    // drag
                    robot.mousePress(dndHelper.getDragComponent(), null, 
                            dndHelper.getMouseButton());

                    CAPUtil.shakeMouse();

                    // drop
                    gdSelectCellByColValue(row, rowOperator, value, regex,
                            CompSystemConstants.EXTEND_SELECTION_NO, 
                            searchType, 
                            ClickOptions.create().setClickCount(0));
                    return null;
                }            
            });

            CAPUtil.waitBeforeDrop(delayBeforeDrop);
        
        } finally {
            robot.mouseRelease(dndHelper.getDragComponent(), null, 
                    dndHelper.getMouseButton());
            pressOrReleaseModifiers(dndHelper.getModifier(), false);
        }
    }
}




/*******************************************************************************
 * 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.util.StringTokenizer;

import org.apache.commons.lang.Validate;
import org.eclipse.jubula.rc.common.AUTServer;
import org.eclipse.jubula.rc.common.CompSystemConstants;
import org.eclipse.jubula.rc.common.caps.AbstractTreeCAPs;
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.RobotException;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.implclasses.IndexConverter;
import org.eclipse.jubula.rc.common.implclasses.MatchUtil;
import org.eclipse.jubula.rc.common.implclasses.Verifier;
import org.eclipse.jubula.rc.common.implclasses.tree.AbstractTreeNodeOperation;
import org.eclipse.jubula.rc.common.implclasses.tree.AbstractTreeNodeTraverser;
import org.eclipse.jubula.rc.common.implclasses.tree.AbstractTreeOperationContext;
import org.eclipse.jubula.rc.common.implclasses.tree.ChildTraverser;
import org.eclipse.jubula.rc.common.implclasses.tree.ExpandCollapseTreeNodeOperation;
import org.eclipse.jubula.rc.common.implclasses.tree.INodePath;
import org.eclipse.jubula.rc.common.implclasses.tree.ParentTraverser;
import org.eclipse.jubula.rc.common.implclasses.tree.PathBasedTraverser;
import org.eclipse.jubula.rc.common.implclasses.tree.SelectTreeNodeOperation;
import org.eclipse.jubula.rc.common.implclasses.tree.SiblingTraverser;
import org.eclipse.jubula.rc.common.implclasses.tree.StandardDepthFirstTraverser;
import org.eclipse.jubula.rc.common.implclasses.tree.TreeNodeOperation;
import org.eclipse.jubula.rc.common.implclasses.tree.TreeNodeOperationConstraint;
import org.eclipse.jubula.rc.common.util.KeyStrokeUtil;
import org.eclipse.jubula.rc.swt.driver.DragAndDropHelperSwt;
import org.eclipse.jubula.rc.swt.driver.KeyCodeConverter;
import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;
import org.eclipse.jubula.rc.swt.implclasses.TableTreeOperationContext;
import org.eclipse.jubula.rc.swt.implclasses.TreeOperationContext;
import org.eclipse.jubula.rc.swt.implclasses.tree.ToggleCheckboxOperation;
import org.eclipse.jubula.rc.swt.implclasses.tree.VerifyCheckboxOperation;
import org.eclipse.jubula.rc.swt.utils.SwtUtils;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.swt.widgets.Tree;
/**
 * Toolkit specific commands for the <code>Tree</code>
 *
 * @author BREDEX GmbH
 */
public class TreeCAPs extends AbstractTreeCAPs {

    
    /**
     * Finds the item at a given position in the tree.
     *
     * @author BREDEX GmbH
     * @created Jul 28, 2010
     */
    private static final class ItemAtPointTreeNodeOperation 
            extends AbstractTreeNodeOperation {

        /** the item that was found at the given position */
        private TreeItem m_itemAtPoint;
        
        /** the position (in absolute coordinates) at which to find the item */
        private Point m_absPoint;
        
        /** 
         * the bounds (in absolute coordinates) of the tree in which the 
         * search should take place 
         */
        private Rectangle m_absTreeBounds;
        
    
    /**
     * Constructor
     * 
     * @param absPoint The position (in absolute coordinates) at which to 
     *                 find the item.
     * @param absTreeBounds The bounds (in absolute coordinates) of the 
     *                      tree in which the search should take place. 
     */
        public ItemAtPointTreeNodeOperation(Point absPoint, 
            Rectangle absTreeBounds) {
            m_absPoint = absPoint;
            m_absTreeBounds = absTreeBounds;
        }
    
    /**
     * {@inheritDoc}
     */
        public boolean operate(Object node) throws StepExecutionException {
            if (getContext().isVisible(node) && node instanceof TreeItem) {
                TreeItem currentItem = (TreeItem)node;
                final Rectangle absItemBounds = 
                        SwtUtils.getBounds(currentItem);
                absItemBounds.x = m_absTreeBounds.x;
                absItemBounds.width = m_absTreeBounds.width;
                if (SwtUtils.containsInclusive(
                        absItemBounds, m_absPoint)) {
                    m_itemAtPoint = currentItem;
                    return false;
                }
            }
        
            return true;
        }
    
    /**
     * 
     * @return the item found at the given position, or <code>null</code> if
     *         no item was found. Note that this method will always return 
     *         <code>null</code> if called before or during execution of
     *         {@link #operate(Object)}.
     */
        public TreeItem getItemAtPoint() {
            return m_itemAtPoint;
        }
    }
    
    /** The robot factory. */
    private IRobotFactory m_robotFactory;
    
    /**
     * Gets the Robot factory. The factory is created once per instance.
     * @return The Robot factory.
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }
    /**
     * Gets the Robot. 
     * @return The Robot
     * @throws RobotException If the Robot cannot be created.
     */
    protected IRobot getRobot() throws RobotException {
        return AUTServer.getInstance().getRobot();
    }
    
    /**
     * @return The event thread queuer.
     */
    protected IEventThreadQueuer getEventThreadQueuer() {
        return getRobotFactory().getEventThreadQueuer();
    }
    /**
     * 
     * @return the Tree
     */
    private Tree getTree() {
        return (Tree) getComponent().getRealComponent();
    }
    
    /**
     * {@inheritDoc}
     */
    public void gdVerifyTextAtMousePosition(String pattern, String operator) {
        TreeItem itemAtMousePosition = (TreeItem) getNodeAtMousePosition();
        int column = getMouseColumn();
        AbstractTreeOperationContext context;
        
        if (column != -1) {
            context = 
                new TableTreeOperationContext(
                    getEventThreadQueuer(), getRobot(),
                    getTree(), column);
        } else {
            context =
                new TableTreeOperationContext(
                    getEventThreadQueuer(), getRobot(), 
                    getTree());
        }

        Verifier.match(context.getRenderedText(itemAtMousePosition), 
                pattern, operator);

    }
    



    /**
     * {@inheritDoc}
     */
    public void gdDragByTextPath(int mouseButton, String modifier, 
            String pathType, int preAscend, String treePath, String operator) {
        
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        
        dndHelper.setMouseButton(mouseButton);
        dndHelper.setModifier(modifier);
        dndHelper.setDragComponent(null);

        SwtUtils.waitForDisplayIdle(getTree().getDisplay());

        gdSelect(pathType, preAscend, treePath, operator, 0, 1, 
                CompSystemConstants.EXTEND_SELECTION_NO);

        SwtUtils.waitForDisplayIdle(getTree().getDisplay());
    }

    /**
     * {@inheritDoc}
     */
    public void gdDropByTextPath(final String pathType, final int preAscend, 
            final String treePath, final String operator, int delayBeforeDrop) {
        
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        final IRobot robot = getRobot();

        try {
            pressOrReleaseModifiers(dndHelper.getModifier(), true);
            getEventThreadQueuer().invokeAndWait("gdDropByTextPath - perform drag", new IRunnable() { //$NON-NLS-1$

                public Object run() throws StepExecutionException {
                    // drag
                    robot.mousePress(dndHelper.getDragComponent(), null, 
                            dndHelper.getMouseButton());                    
                    
                    CAPUtil.shakeMouse();

                    return null;
                }            
            });

            // Post a MouseMove event in order to break the Display out of its
            // post-drag "freeze". It appears as though the mouse position 
            // change needs to be extreme in order to nudge the Display back 
            // into action (i.e. (<mouse-location> + 1) was insufficient), 
            // so the default Event values (x, y = 0) are used.
            Event wakeEvent = new Event();
            wakeEvent.type = SWT.MouseMove;
            getTree().getDisplay().post(wakeEvent);

            waitForDisplayUpdate();

            // drop
            gdSelect(pathType, preAscend, treePath, operator, 0, 1,
                    CompSystemConstants.EXTEND_SELECTION_NO);

            SwtUtils.waitForDisplayIdle(getTree().getDisplay());
            CAPUtil.waitBeforeDrop(delayBeforeDrop);
            
        } finally {
            robot.mouseRelease(null, null, dndHelper.getMouseButton());
            pressOrReleaseModifiers(
                    dndHelper.getModifier(), false);
            SwtUtils.waitForDisplayIdle(getTree().getDisplay());
        }
    }

    /**
     * {@inheritDoc}
     */
    public void gdDragByIndexPath(int mouseButton, String modifier, 
            String pathType, int preAscend, String indexPath) {
        
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        
        dndHelper.setMouseButton(mouseButton);
        dndHelper.setModifier(modifier);
        dndHelper.setDragComponent(null);
        
        SwtUtils.waitForDisplayIdle(getTree().getDisplay());

        gdSelectByIndices(pathType, preAscend, indexPath, 0, 1, 
                CompSystemConstants.EXTEND_SELECTION_NO);
        
        SwtUtils.waitForDisplayIdle(getTree().getDisplay());
    }

    /**
     * {@inheritDoc}
     */
    public void gdDropByIndexPath(final String pathType, final int preAscend, 
            final String indexPath, int delayBeforeDrop) {
        
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        final IRobot robot = getRobot();
        try {
            pressOrReleaseModifiers(dndHelper.getModifier(), true);
            getEventThreadQueuer().invokeAndWait("gdDropByIndexPath - perform drag", new IRunnable() { //$NON-NLS-1$

                public Object run() throws StepExecutionException {
                    // drag
                    robot.mousePress(dndHelper.getDragComponent(), null, 
                            dndHelper.getMouseButton());

                    CAPUtil.shakeMouse();

                    return null;
                }            
            });

            // Post a MouseMove event in order to break the Display out of its
            // post-drag "freeze". It appears as though the mouse position 
            // change needs to be extreme in order to nudge the Display back 
            // into action (i.e. (<mouse-location> + 1) was insufficient), 
            // so the default Event values (x, y = 0) are used.
            Event wakeEvent = new Event();
            wakeEvent.type = SWT.MouseMove;
            getTree().getDisplay().post(wakeEvent);
            
            waitForDisplayUpdate();

            // drop
            gdSelectByIndices(pathType, preAscend, indexPath, 0, 1, 
                    CompSystemConstants.EXTEND_SELECTION_NO);

            SwtUtils.waitForDisplayIdle(getTree().getDisplay());
            CAPUtil.waitBeforeDrop(delayBeforeDrop);
        } finally {
            robot.mouseRelease(null, null, dndHelper.getMouseButton());
            pressOrReleaseModifiers(dndHelper.getModifier(),
                    false);
            SwtUtils.waitForDisplayIdle(getTree().getDisplay());
        }
    }
    /**
     * {@inheritDoc}
     */
    protected Object getNodeAtMousePosition() throws StepExecutionException {
        return (TreeItem)getEventThreadQueuer().invokeAndWait("getItemAtMousePosition", new IRunnable() { //$NON-NLS-1$
            
            public Object run() throws StepExecutionException {
                Point mousePos = SwtUtils.convertToSwtPoint(
                        getRobot().getCurrentMousePosition());
                ItemAtPointTreeNodeOperation op = 
                    new ItemAtPointTreeNodeOperation(
                            mousePos, SwtUtils.getWidgetBounds(getTree()));

                TreeItem topItem = getTree().getTopItem();
                if (topItem != null) {
                    
                    // FIXME zeb This may be slow for very large trees, as the 
                    //           search may continue long past the
                    //           visible client area of the tree.
                    //           It may also cause problems with regard to 
                    //           lazy/virtual nodes. 
                    StandardDepthFirstTraverser traverser = 
                        new StandardDepthFirstTraverser(
                            new TreeOperationContext(
                                getEventThreadQueuer(), getRobot(), getTree()));
                    traverser.traversePath(op, topItem);
                    if (op.getItemAtPoint() != null) {
                        return op.getItemAtPoint();
                    }
                    
                }

                throw new StepExecutionException("No tree node found at mouse position.", //$NON-NLS-1$
                        EventFactory.createActionError(
                                TestErrorEvent.NOT_FOUND));
            }
        });
    }
    
    /**
     * @return the column where the mouse pointer currently rests. Returns -1 if
     *         the mouse pointer is currently outside of the TableTree or if the
     *         TableTree has no columns.
     */
    private int getMouseColumn() {
        final Tree treeTable = getTree();
        int column = ((Integer)getEventThreadQueuer().invokeAndWait(
                "getMouseColumn", new IRunnable() { //$NON-NLS-1$

                    public Object run() throws StepExecutionException {
                        Rectangle treeTableBounds = 
                            SwtUtils.getWidgetBounds(getTree());
                        Point cursorPosition = 
                            treeTable.getDisplay().getCursorLocation();
                        boolean isCursorInBounds = 
                            treeTableBounds.contains(cursorPosition);
                        if (isCursorInBounds) {
                            int horizontalScrollOffset = 0;
                            ScrollBar horizontalBar = 
                                getTree().getHorizontalBar();
                            if (horizontalBar != null 
                                    && !horizontalBar.isDisposed()) {
                                horizontalScrollOffset = 
                                    horizontalBar.getSelection();
                            }
                            Rectangle columnBounds = new Rectangle(
                                treeTableBounds.x - horizontalScrollOffset, 
                                treeTableBounds.y, 0, treeTableBounds.height);
                            for (int i = 0; 
                                i < treeTable.getColumnCount(); i++) {
                                
                                columnBounds.x += columnBounds.width;
                                columnBounds.width = 
                                    treeTable.getColumn(i).getWidth();
                                if (columnBounds.contains(cursorPosition)) {
                                    return new Integer(i);
                                }
                            }
                        }

                        return new Integer(-1);
                    }

                })).intValue();
        
        return column;
    }
    // 
    // Methods for Table Trees following
    // 
    
    /**
     * Selects a node relative to the currently selected node.
     * @param direction the direction to move.
     *                  directions:
     *                      UP - Navigates through parents
     *                      DOWN - Navigates through children
     *                      NEXT - Navigates to next sibling
     *                      PREVIOUS - Navigates to previous sibling
     * @param distance the distance to move
     * @param clickCount the click count to select the new cell.
     * @throws StepExecutionException if any error occurs
     */
    public void gdMove(String direction, int distance, int clickCount) 
        throws StepExecutionException {

        if (getColumnCount() > 0) {
            TreeOperationContext context;
            int mouseColumn = getMouseColumn();
            
            if (mouseColumn == -1) {
                context = 
                    new TableTreeOperationContext(
                        getEventThreadQueuer(), getRobot(), getTree());
            } else {
                context = 
                    new TableTreeOperationContext(
                        getEventThreadQueuer(), getRobot(), getTree(), 
                        mouseColumn);
            }
            
            TreeItem selectedNode = (TreeItem) getSelectedNode(context);
            
            TreeNodeOperation selectOp = 
                new SelectTreeNodeOperation(
                        ClickOptions.create().setClickCount(clickCount));
            TreeNodeOperationConstraint constraint = 
                new TreeNodeOperationConstraint();
            
            if (CompSystemConstants
                    .TREE_MOVE_UP.equalsIgnoreCase(direction)) {
                AbstractTreeNodeTraverser traverser = 
                    new ParentTraverser(context, distance, constraint);
                traverser.traversePath(selectOp, selectedNode);
            } else if (CompSystemConstants
                    .TREE_MOVE_DOWN.equalsIgnoreCase(direction)) {
                TreeNodeOperation expandOp = 
                    new ExpandCollapseTreeNodeOperation(false);
                AbstractTreeNodeTraverser expandTraverser = 
                    new ChildTraverser(context, distance - 1);
                expandTraverser.traversePath(expandOp, selectedNode);
                
                AbstractTreeNodeTraverser selectTraverser = 
                    new ChildTraverser(context, distance, constraint);
                selectTraverser.traversePath(selectOp, selectedNode);
                
            } else if (CompSystemConstants
                    .TREE_MOVE_NEXT.equalsIgnoreCase(direction)) {
                // Look through siblings
                AbstractTreeNodeTraverser traverser = 
                    new SiblingTraverser(context, distance, true, constraint);
                traverser.traversePath(selectOp, selectedNode);
                
            } else if (CompSystemConstants
                    .TREE_MOVE_PREVIOUS.equalsIgnoreCase(direction)) {
                // Look through siblings
                AbstractTreeNodeTraverser traverser = 
                    new SiblingTraverser(context, distance, false, constraint);
                traverser.traversePath(selectOp, selectedNode);
            }
        } else {
            super.gdMove(direction, distance, clickCount);
        }
    }

        /**
         * Runs in the GUI thread.
         * @return the number of columns in the receivers component.
         */
    private int getColumnCount() {
        return ((Integer)getEventThreadQueuer().invokeAndWait(
                    "getColumnCount", new IRunnable() { //$NON-NLS-1$

                        public Object run() throws StepExecutionException {
                            return new Integer(getTree().getColumnCount());
                        }
                
                    })).intValue();
    }
    
    /**
     * Selects the item at the end of the <code>treepath</code> at column 
     * <code>column</code>.
     * 
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param treePath The tree path.
     * @param operator
     *  If regular expressions are used to match the tree path
     * @param clickCount the click count
     * @param column the column of the item to select
     * @param button what mouse button should be used
     * @throws StepExecutionException If the tree path is invalid, if the
     * double-click to expand the node fails, or if the selection is invalid.
     */
    public void gdSelect(String pathType, int preAscend, String treePath, 
                         String operator, int clickCount, int column,
                         int button)
        throws StepExecutionException {
        final int implCol = IndexConverter.toImplementationIndex(column);
        checkColumnIndex(implCol);
        
        selectByPath(pathType, preAscend, 
            createStringNodePath(splitTextTreePath(treePath), operator), 
            ClickOptions.create()
                .setClickCount(clickCount)
                .setMouseButton(button), implCol);

    }
    /**
     * Selects the last node of the path given by <code>indexPath</code>
     * at column <code>column</code>.
     * 
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param indexPath the index path
     * @param clickCount the number of times to click
     * @param column the column of the item to select
     * @param button what mouse button should be used
     * @throws StepExecutionException if <code>indexPath</code> is not a valid
     * path
     */
    public void gdSelectByIndices(String pathType, int preAscend, 
                                  String indexPath, int clickCount, int column,
                                  int button)
        throws StepExecutionException {
        final int implCol = IndexConverter.toImplementationIndex(column);
        checkColumnIndex(implCol);

        selectByPath(pathType, preAscend, 
            createIndexNodePath(splitIndexTreePath(indexPath)),
                ClickOptions.create()
                    .setClickCount(clickCount)
                    .setMouseButton(button), implCol);
    }
    
    /**
     * Verifies whether the first selection in the tree has a rendered text at 
     * column <code>column</code> that is equal to <code>pattern</code>.
     * 
     * @param pattern The pattern
     * @param column
     *            The column containing the text to verify
     * @throws StepExecutionException If no node is selected or the verification fails.
     */
    public void gdVerifySelectedValue(String pattern, int column)
        throws StepExecutionException {

        gdVerifySelectedValue(pattern, MatchUtil.DEFAULT_OPERATOR, column);
    }
    /**
     * Verifies if the selected node underneath <code>treePath</code> at column
     * <code>column</code> has a rendered text which is equal to 
     * <code>selection</code>.
     * 
     * @param pattern the pattern
     * @param operator
     *            The operator to use when comparing the expected and 
     *            actual values.
     * @param column
     *            The column containing the text to verify
     * @throws StepExecutionException If there is no tree node selected, the tree path contains no
     *             selection or the verification fails
     */
    public void gdVerifySelectedValue(String pattern, String operator, 
        int column) throws StepExecutionException {
        
        final int implCol = IndexConverter.toImplementationIndex(column);
        checkColumnIndex(implCol);

        TableTreeOperationContext context = new TableTreeOperationContext(
            getEventThreadQueuer(), getRobot(), getTree(), implCol);

        String text = context.getNodeTextAtColumn(context.getSelectedNode());
        
        Verifier.match(text, pattern, operator);

    }
    
    /**
     * 
     * @param index The 0-based column index to check.
     * @throws StepExecutionException if the column index is invalid.
     */
    private void checkColumnIndex(final int index) 
        throws StepExecutionException {
       
        int numColumns = ((Integer)getEventThreadQueuer().invokeAndWait(
                "checkColumnIndex",  //$NON-NLS-1$
                new IRunnable() {

                    public Object run() {
                        return new Integer(getTree().getColumnCount());
                    }
            
                })).intValue();

        if ((index < 0 || index >= numColumns) && index != 0) {
            throw new StepExecutionException("Invalid column: " //$NON-NLS-1$
                + IndexConverter.toUserIndex(index), 
                EventFactory.createActionError(
                    TestErrorEvent.INVALID_INDEX));
        }
    }
    
    /**
     * @param pathType pathType
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param objectPath objectPath
     * @param co the click options to use
     * @param column the column
     */
    private void selectByPath(String pathType, int preAscend, 
            INodePath objectPath, ClickOptions co, int column) {

        TreeNodeOperation expOp = 
            new ExpandCollapseTreeNodeOperation(false);
        TreeNodeOperation selectOp = 
            new SelectTreeNodeOperation(co);
        INodePath subPath = objectPath.subPath(0, objectPath.getLength() - 1);

        traverseTreeByPath(subPath, pathType, preAscend, expOp);
        traverseLastElementByPath(
            objectPath, pathType, preAscend, selectOp, column);
            
    }
    
    /**
     * Traverses the tree by searching for the nodes in the tree
     * path entry and calling the given operation on the last element in the path.
     * @param treePath The tree path.
     * @param pathType For example, "relative" or "absolute".
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param operation The tree node operation.
     * @param column The target column for the operation.
     * @throws StepExecutionException If the path traversion fails.
     */
    private void traverseLastElementByPath(INodePath treePath, 
            String pathType, int preAscend, TreeNodeOperation operation,
            int column) 
        throws StepExecutionException {

        Validate.notNull(treePath);
        Validate.notNull(operation);

        TableTreeOperationContext context = new TableTreeOperationContext(
                getEventThreadQueuer(), getRobot(), getTree(), column);
        TreeItem startNode = (TreeItem) getStartNode(pathType,
                preAscend, context);

        AbstractTreeNodeTraverser traverser = new PathBasedTraverser(
                context, treePath, new TreeNodeOperationConstraint());
        traverser.traversePath(operation, startNode);
    }
    
    /**
     * {@inheritDoc}
     */
    public String gdStoreValueAtMousePosition(String variable) {
        TreeItem itemAtMousePosition = (TreeItem) getNodeAtMousePosition();
        int column = getMouseColumn();
        AbstractTreeOperationContext context;
        
        if (column != -1) {
            context = 
                new TableTreeOperationContext(
                    getEventThreadQueuer(), getRobot(), getTree(), column);
        } else {
            context =
                new TableTreeOperationContext(
                    getEventThreadQueuer(), getRobot(), getTree());
        }

        return context.getRenderedText(itemAtMousePosition);
    }
    
    /**
     * Selects Checkbox of last node of the path given by <code>treepath</code>.
     * 
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param treePath The tree path.
     * @param operator
     *  If regular expressions are used to match the tree path
     * @throws StepExecutionException If the tree path is invalid, if the
     * double-click to expand the node fails, or if the selection is invalid.
     */
    public void gdToggleCheckbox(String pathType, int preAscend, String
            treePath, String operator)
        throws StepExecutionException {
        toggleCheckBoxByPath(pathType, preAscend, 
                createStringNodePath(splitTextTreePath(treePath), operator));
    }
    
    /**
     * Selects Checkbox of last node of the path given by <code>indexPath</code>
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param indexPath the index path
     * @throws StepExecutionException if <code>indexPath</code> is not a valid
     * path
     */
    public void gdToggleCheckboxByIndices(String pathType, int preAscend, 
                    String indexPath)
        throws StepExecutionException {
    
        toggleCheckBoxByPath(pathType, preAscend,
                createIndexNodePath(splitIndexTreePath(indexPath)));
    }
    
    /**
     * Verify Selection of checkbox of the node at the end of the <code>treepath</code>.
     * 
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param treePath The tree path.
     * @param operator
     *  If regular expressions are used to match the tree path
     * @param checked true if checkbox of tree node is selected, false otherwise
     * @throws StepExecutionException If the tree path is invalid, if the
     * double-click to expand the node fails, or if the selection is invalid.
     */
    public void gdVerifyCheckbox(String pathType, int preAscend, String
            treePath, String operator, boolean checked)
        throws StepExecutionException {
        verifyCheckBoxByPath(pathType, preAscend, 
                createStringNodePath(splitTextTreePath(treePath), operator), 
                checked);    
    }
    
    /**
     * Verify Selection of checkbox of last node of the path given by <code>indexPath</code>
     * @param pathType whether the path is relative or absolute
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param indexPath the index path
     * @param checked true if checkbox of tree node is selected, false otherwise
     * @throws StepExecutionException if <code>indexPath</code> is not a valid
     * path
     */
    public void gdVerifyCheckboxByIndices(String pathType, int preAscend, 
                    String indexPath, boolean checked)
        throws StepExecutionException {
    
        verifyCheckBoxByPath(pathType, preAscend,
                createIndexNodePath(splitIndexTreePath(indexPath)), 
                    checked);    
    }
    
    /**
     * Verifies whether the checkbox of the first selection in the tree is checked
     * 
     * @param checked true if checkbox of node is selected, false otherwise
     * @throws StepExecutionException If no node is selected or the verification fails.
     */
    public void gdVerifySelectedCheckbox(boolean checked)
        throws StepExecutionException {        
        Boolean checkSelected = ((Boolean)getEventThreadQueuer().invokeAndWait(
                "gdVerifyTreeCheckbox", new IRunnable() { //$NON-NLS-1$
                    public Object run() {             
                        TreeItem node = getTree().getSelection()[0];
                        return new Boolean(node.getChecked());
                    }            
                }));       
        
        Verifier.equals(checked, checkSelected.booleanValue());
    }

    /**
     * @param pathType pathType
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param objectPath objectPath
     * @param checked true if Checkbox should be enabled, false otherwise
     */
    private void verifyCheckBoxByPath(String pathType, int preAscend, 
            INodePath objectPath, final boolean checked) {

        TreeNodeOperation expOp = 
            new ExpandCollapseTreeNodeOperation(false);
        TreeOperationContext context = new TreeOperationContext(
                getEventThreadQueuer(), getRobot(), getTree());
        TreeNodeOperation checkboxOp = new VerifyCheckboxOperation(
                checked, context);
        INodePath subPath = objectPath.subPath(0, objectPath.getLength() - 1);
        
        traverseTreeByPath(subPath, pathType, preAscend, expOp);
        traverseLastElementByPath(objectPath, pathType, preAscend, checkboxOp);
    }
    
    /**
     * @param pathType pathType
     * @param preAscend
     *            Relative traversals will start this many parent nodes 
     *            above the current node. Absolute traversals ignore this 
     *            parameter.
     * @param objectPath objectPath
     */
    private void toggleCheckBoxByPath(String pathType, int preAscend, 
            INodePath objectPath) {

        TreeNodeOperation expOp = 
            new ExpandCollapseTreeNodeOperation(false);
        TreeOperationContext context = new TreeOperationContext(
                getEventThreadQueuer(), getRobot(), getTree());
        TreeNodeOperation selCheckboxOp = new ToggleCheckboxOperation(context);
        INodePath subPath = objectPath.subPath(0, objectPath.getLength() - 1);
        
        traverseTreeByPath(subPath, pathType, preAscend, expOp);
        traverseLastElementByPath(objectPath, pathType, preAscend,
                selCheckboxOp);      
    }
    
    /**
     * {@inheritDoc}
     */
    public void gdClick(int count, int button) {
        super.gdClick(count, button);
        
    }
    

    
    /**
     * Forces all outstanding paint requests for the receiver's component's 
     * display to be processed before this method returns.
     * 
     * @see Display#update()
     */
    protected void waitForDisplayUpdate() {
        ((Control)getComponent().getRealComponent())
        .getDisplay().syncExec(new Runnable() {
            public void run() {
                ((Control)getComponent()
                        .getRealComponent()).getDisplay().update();
            }
        });
    }
    
    /**
     * Presses or releases the given modifier.
     * @param modifier the modifier.
     * @param press if true, the modifier will be pressed.
     * if false, the modifier will be released.
     */
    public void pressOrReleaseModifiers(String modifier, boolean press) {
        final IRobot robot = getRobot();
        final StringTokenizer modTok = new StringTokenizer(
                KeyStrokeUtil.getModifierString(modifier), " "); //$NON-NLS-1$
        while (modTok.hasMoreTokens()) {
            final String mod = modTok.nextToken();
            final int keyCode = KeyCodeConverter.getKeyCode(mod);
            if (press) {
                robot.keyPress(null, keyCode);
            } else {
                robot.keyRelease(null, keyCode);
            }
        }
    }

}




/*******************************************************************************
 * 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.uiadapter;

import org.eclipse.jubula.rc.common.driver.IRunnable;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IButtonAdapter;
import org.eclipse.swt.widgets.Button;
/**
 * Implements the Button interface for adapting a <code>SWT.Button</code>
 * 
 *  @author BREDEX GmbH
 */
public class ButtonAdapter extends WidgetAdapter implements IButtonAdapter {
    
    /** the Button from the AUT */
    private Button m_button;
    
    /**
     * 
     * @param objectToAdapt graphics component which will be adapted
     */
    public ButtonAdapter(Object objectToAdapt) {
        super(objectToAdapt);
        m_button = (Button) objectToAdapt;
    }

    /**
     * {@inheritDoc}
     */
    public String getText() {
        
        return (String)getEventThreadQueuer()
                .invokeAndWait("getText", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_button.getText(); // see findBugs;
                    }
                });
    }

    /**
     * {@inheritDoc}
     */
    public boolean isSelected() {
        Boolean actual = (Boolean)getEventThreadQueuer()
                .invokeAndWait("isSelected", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_button.getSelection() 
                            ? Boolean.TRUE : Boolean.FALSE; // see findBugs;
                    }
                });
        return actual.booleanValue();
    }
    
    /**
     * {@inheritDoc}
     * 
     */
    public String readValue(String variable) {
        
        return getText();
    }
}




/*******************************************************************************
 * 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.uiadapter;

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.RobotException;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;
import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;

/**
 * Implements the Menu interface for adapting a <code>SWT.Menu</code>
 * 
 * @author BREDEX GmbH
 */
public class MenuAdapter implements IMenuAdapter {
    /** the Menu from the AUT */
    private Menu m_menu;
    
    /** the RobotFactory from the AUT */
    private IRobotFactory m_robotFactory;

    /**
     * 
     * @param component graphics component which will be adapted
     */
    public MenuAdapter(Object component) {
        m_menu = (Menu) component;
    }

    /**
     * Gets the Robot factory. The factory is created once per instance.
     * 
     * @return The Robot factory.
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }

    /**
     * Gets the IEventThreadQueuer.
     * 
     * @return The Robot
     * @throws RobotException
     *             If the Robot cannot be created.
     */
    protected IRobot getRobot() throws RobotException {
        return getRobotFactory().getRobot();
    }

    /**
     * @return The event thread queuer.
     */
    public IEventThreadQueuer getEventThreadQueuer() {
        return getRobotFactory().getEventThreadQueuer();
    }
    /**
     * {@inheritDoc}
     */   
    public Object getRealComponent() {
        return m_menu;
    }
    /**
     * {@inheritDoc}
     */  
    public void setComponent(Object element) {
        m_menu = (Menu) element;
        
    }
    /**
     * {@inheritDoc}
     */
    public IMenuItemAdapter[] getItems() {
        
        MenuItem[] items =
                (MenuItem[]) getEventThreadQueuer().invokeAndWait(
                        "getItems", new IRunnable() { //$NON-NLS-1$
                            public Object run() {
                                return m_menu.getItems();
                            }
                        });
        IMenuItemAdapter[] adapters = new IMenuItemAdapter[items.length];
        for (int i = 0; i < items.length; i++) {
            IMenuItemAdapter menuItem = new MenuItemAdapter(items[i]);
            adapters[i] = menuItem;
        }
        return adapters;
    }
    /**
     * {@inheritDoc}
     */
    public int getItemCount() {
        Integer itemCount = (Integer) getEventThreadQueuer().invokeAndWait(
                "getItemCount", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return new Integer(m_menu.getItemCount());
                    }
                });
        return itemCount.intValue();
    }


    

}




/*******************************************************************************
 * 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.uiadapter;

import org.eclipse.jubula.rc.common.driver.ClickOptions;
import org.eclipse.jubula.rc.common.driver.IEventMatcher;
import org.eclipse.jubula.rc.common.driver.IEventThreadQueuer;
import org.eclipse.jubula.rc.common.driver.IRobot;
import org.eclipse.jubula.rc.common.driver.IRobotEventConfirmer;
import org.eclipse.jubula.rc.common.driver.IRobotEventInterceptor;
import org.eclipse.jubula.rc.common.driver.IRobotFactory;
import org.eclipse.jubula.rc.common.driver.IRunnable;
import org.eclipse.jubula.rc.common.driver.InterceptorOptions;
import org.eclipse.jubula.rc.common.exception.RobotException;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.listener.EventLock;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;
import org.eclipse.jubula.rc.swt.driver.EventThreadQueuerSwtImpl;
import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;
import org.eclipse.jubula.rc.swt.driver.RobotFactorySwtImpl;
import org.eclipse.jubula.rc.swt.driver.SelectionSwtEventMatcher;
import org.eclipse.jubula.rc.swt.driver.ShowSwtEventMatcher;
import org.eclipse.jubula.rc.swt.implclasses.EventListener;
import org.eclipse.jubula.rc.swt.implclasses.EventListener.Condition;
import org.eclipse.jubula.rc.swt.utils.SwtUtils;
import org.eclipse.jubula.tools.constants.TimeoutConstants;
import org.eclipse.jubula.tools.i18n.I18n;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;

/**
 * Implements the MenuItem interface for adapting a <code>SWT.MenuItem</code>
 * 
 *  @author BREDEX GmbH
 */
public class MenuItemAdapter implements IMenuItemAdapter {

    /** the MenuItem from the AUT*/
    private MenuItem m_menuItem;
    

    /** the RobotFactory from the AUT */
    private IRobotFactory m_robotFactory;

    /**
     * 
     * @param component graphics component which will be adapted
     */
    public MenuItemAdapter(Object component) {
        super();
        m_menuItem = (MenuItem) component;
    }
    
    /**
     * Gets the Robot factory. The factory is created once per instance.
     * 
     * @return The Robot factory.
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }

    /**
     * Gets the IEventThreadQueuer.
     * 
     * @return The Robot
     * @throws RobotException
     *             If the Robot cannot be created.
     */
    protected IRobot getRobot() throws RobotException {
        return getRobotFactory().getRobot();
    }

    /**
     * @return The event thread queuer.
     */
    public IEventThreadQueuer getEventThreadQueuer() {
        return getRobotFactory().getEventThreadQueuer();
    }
    
    
    /**
     * {@inheritDoc}
     */
    public Object getRealComponent() {
       
        return m_menuItem;
    }
    /**
     * {@inheritDoc}
     */
    public void setComponent(Object element) {
        m_menuItem = (MenuItem) element;

    }
    /**
     * {@inheritDoc}
     */
    public String getText() {
        return (String) getEventThreadQueuer().invokeAndWait(
                "getText", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_menuItem.getText();
                    }
                });
    }

    /**
     * {@inheritDoc}
     */
    public boolean isEnabled() {
        final Boolean isEnabled = (Boolean) getEventThreadQueuer()
                .invokeAndWait("isEnabled", new IRunnable() { //$NON-NLS-1$
                        public Object run() throws StepExecutionException {
                            return m_menuItem.isEnabled() ? Boolean.TRUE
                                        : Boolean.FALSE;
                        }
                    });
        return isEnabled.booleanValue();

    }
    /**
     * {@inheritDoc}
     */
    public boolean isExisting() {
        if (m_menuItem != null) {
            return true;
        }
        return false;
    }
    /**
     * {@inheritDoc}
     */
    public boolean isSelected() {
        final Boolean isSelected = (Boolean)getEventThreadQueuer()
                .invokeAndWait("isSelected", new IRunnable() { //$NON-NLS-1$
                    public Object run() throws StepExecutionException {
                        return m_menuItem.getSelection() 
                            ? Boolean.TRUE : Boolean.FALSE;
                    }
                });
        return isSelected.booleanValue();
    }

    /**
     * @return -
     */
    public boolean isShowing() {

        return true; //FIXME is here a Showing implementation?
    }
    /**
     * {@inheritDoc}
     */
    public IMenuAdapter getMenu() {
        
        Menu menu =
                (Menu) getEventThreadQueuer().invokeAndWait(
                        "getItems", new IRunnable() { //$NON-NLS-1$
                            public Object run() {
                                return m_menuItem.getMenu();
                            }
                        });
        
        
        return new MenuAdapter(menu);
    }
    /**
     * {@inheritDoc}
     */
    public boolean hasSubMenu() {
        

        
        if (getMenu() != null) {
            return true;
        }
        return false;
    }


    /**
     * Checks whether the given menu item is a separator. 
     * This method runs in the GUI thread.
     * @return <code>true</code> if <code>menuItem</code> is a separator item.
     *         Otherwise <code>false</code>.
     */
    public boolean isSeparator() {
        final Boolean isSeparator = (Boolean)getEventThreadQueuer()
                .invokeAndWait(
                ".isSeparator", new IRunnable() { //$NON-NLS-1$
                    public Object run() throws StepExecutionException {
                        return (m_menuItem.getStyle() & SWT.SEPARATOR) != 0 
                                            ? Boolean.TRUE : Boolean.FALSE;
                    }
                });
        return isSeparator.booleanValue();
    }
    
    /**
     * {@inheritDoc}
     */
    public void selectMenuItem() {
        Rectangle bounds = getMenuItemBounds();
        Rectangle nullBounds = new Rectangle(0, 0, 0, 0);
        
        if (bounds.equals(nullBounds)) {
            selectProgramatically();
        } else {
            clickMenuItem(getRobot(), m_menuItem, 1);
        }
        
    }
    
    /**
     * {@inheritDoc}
     */
    public IMenuAdapter openSubMenu() {
        final MenuItem menuItem = m_menuItem;
        MenuShownCondition cond = new MenuShownCondition(menuItem);
        EventLock lock = new EventLock();
        final EventListener listener = new EventListener(lock, cond);
        final Display d = menuItem.getDisplay();
        final IEventThreadQueuer queuer = new EventThreadQueuerSwtImpl();
        
        queuer.invokeAndWait("addMenuShownListeners", new IRunnable() { //$NON-NLS-1$
            public Object run() {
                d.addFilter(SWT.Show, listener);
                
                return null;
            }
        });
        try {
            // Menu bar items require a click in order to open the submenu.
            // Cascading menus are opened with a mouse-over and 
            // may be closed by a click.
            int clickCount = isMenuBarItem(menuItem) ? 1 : 0;
            Menu menu = (Menu)getEventThreadQueuer().invokeAndWait(
                    "openSubMenu", new IRunnable() { //$NON-NLS-1$
                        public Object run() {
                            return menuItem.getMenu();
                        }            
                    });
            Rectangle bounds = getMenuItemBounds();
            Rectangle nullBounds = new Rectangle(0, 0, 0, 0);            
            if (bounds.equals(nullBounds)) {                               
                openSubMenuProgramatically(menu);
            } else {
                clickMenuItem(getRobot(), menuItem, clickCount);
            }
            synchronized (lock) {
                long timeout = TimeoutConstants.SERVER_TIMEOUT_WAIT_FOR_POPUP;
                long done = System.currentTimeMillis() + timeout; 
                long now;                
                while (!lock.isReleased() && timeout > 0) {
                    lock.wait(timeout);
                    now = System.currentTimeMillis();
                    timeout = done - now;
                }
            } 
        } catch (InterruptedException e) { // ignore
        } finally {
            queuer.invokeAndWait("removeMenuShownListeners", new IRunnable() { //$NON-NLS-1$
                public Object run() {
                    d.removeFilter(SWT.Show, listener);
                    
                    return null;
                }
            });
        }
        if (!lock.isReleased()) {
            String itemText = (String)getEventThreadQueuer().invokeAndWait(
                    "getItemText", new IRunnable() { //$NON-NLS-1$

                        public Object run() throws StepExecutionException {
                            if (menuItem != null && !menuItem.isDisposed()) {
                                return menuItem.getText();
                            }
                            return "unknown menu item"; //$NON-NLS-1$
                        }
                
                    });
            itemText = SwtUtils.removeMnemonics(itemText);
            throw new StepExecutionException(
                    I18n.getString("TestErrorEvent.MenuDidNotAppear",  //$NON-NLS-1$
                            new String [] {itemText}), 
                    EventFactory.createActionError(
                            "TestErrorEvent.MenuDidNotAppear", //$NON-NLS-1$ 
                            new String [] {itemText}));
        }        
        return new MenuAdapter(cond.getMenu());
    }
    
    /**
     * @param menuItem the menu item to check
     * @return <code>true</code> of the given menu item is part of a menu
     *         bar. Otherwise, <code>false</code>.
     */
    private boolean isMenuBarItem(final MenuItem menuItem) {
        return ((Boolean)getEventThreadQueuer().invokeAndWait(
                "isMenuBarItem", new IRunnable() { //$NON-NLS-1$

                    public Object run() throws StepExecutionException {
                        if (menuItem != null && !menuItem.isDisposed()) {
                            Menu parent = menuItem.getParent();
                            if (parent != null && !parent.isDisposed()) {
                                return (parent.getStyle() & SWT.BAR) != 0 
                                    ? Boolean.TRUE : Boolean.FALSE;
                            }
                        }
                        return Boolean.FALSE;
                    }
            
                })).booleanValue();
    }
    
    
    /**
     * Waits for a submenu to appear. Examples of submenus are cascading menus
     * and pulldown menus.
     *
     * @author BREDEX GmbH
     * @created Oct 30, 2008
     */
    public static class MenuShownCondition implements Condition {
        /** the menu that was shown */
        private Menu m_shownMenu = null;

        /** the parent item of the expected menu */
        private MenuItem m_parentItem;

        /**
         * Constructor
         *  
         * @param parentItem The parent item of the expected menu. This 
         *                   condition only matches if a menu with parent item
         *                   <code>parentItem</code> appears.
         */
        MenuShownCondition(MenuItem parentItem) {
            m_parentItem = parentItem;
        }
        
        /**
         * 
         * @return the menu that appeared
         */
        public Menu getMenu() {
            return m_shownMenu;
        }
        
        /**
         * 
         * {@inheritDoc}
         */
        public boolean isTrue(Event event) {
            if (event.type == SWT.Show && event.widget instanceof Menu
                    && ((Menu)(event.widget)).getParentItem() == m_parentItem) {
                m_shownMenu = (Menu)event.widget;
                return true;
            } 
            
            return false;
        }
    }
    
    /**
     * Clicks on a menu item
     * 
     * @param robot the robot
     * @param item the menu item
     * @param clickCount the number of times to click the menu item
     */
    public static void clickMenuItem(IRobot robot, final MenuItem item, 
            int clickCount) {
        // FIXME existiert so schon und kann man benutzen
//        if (!isMenuItemEnabled(item)) {
//            throw new StepExecutionException("menu item not enabled", //$NON-NLS-1$
//                    EventFactory.createActionError(
//                            TestErrorEvent.MENU_ITEM_NOT_ENABLED));
//        }

        robot.click(item, null, 
            ClickOptions.create()
                .setClickType(ClickOptions.ClickType.RELEASED)
                .setStepMovement(false).setClickCount(clickCount));
        
    }
    /**
     * 
     * @return bounds of MenuItem
     */
    public Rectangle getMenuItemBounds() {
        Rectangle bounds = (Rectangle)getEventThreadQueuer().invokeAndWait(
                "getMenuItemBounds", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return SwtUtils.getBounds(m_menuItem);
                    }            
                });        
        return bounds;
    }
    
    /**
     * open SubMenu programatically (for Mac OS)
     * @param menu the Menu
     */
    public void openSubMenuProgramatically(final Menu menu) {
//        if (!isMenuEnabled(menu)) {
//            throw new StepExecutionException("menu item not enabled", //$NON-NLS-1$
//                    EventFactory.createActionError(
//                            TestErrorEvent.MENU_ITEM_NOT_ENABLED));
//        }
        
        final InterceptorOptions options = new InterceptorOptions(
                new long[]{SWT.Show});
        final IEventMatcher matcher = 
            new ShowSwtEventMatcher();  
        RobotFactorySwtImpl robotSwt = new RobotFactorySwtImpl();
        IRobotEventInterceptor interceptor =
            robotSwt.getRobotEventInterceptor();
        final IRobotEventConfirmer confirmer = interceptor
            .intercept(options);
        
        final Event event = new Event();
        event.time = (int) System.currentTimeMillis();
        event.widget = menu;
        event.display = menu.getDisplay();
        event.type = SWT.Show;
        
        getEventThreadQueuer().invokeAndWait(
                "openSubMenuProgramatically", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        
                        menu.notifyListeners(SWT.Show, event);
                        
                        return null;
                    }            
                });

        try {
            confirmer.waitToConfirm(menu, matcher);
        } catch (RobotException re) {
            final StringBuffer sb = new StringBuffer(
                "Robot exception occurred while clicking...\n"); //$NON-NLS-1$
//            logRobotException(menuItem, re, sb);
            sb.append("Component: "); //$NON-NLS-1$

            getEventThreadQueuer().invokeAndWait(
                    "getBounds", new IRunnable() { //$NON-NLS-1$
                        public Object run()
                            throws StepExecutionException {
                            sb.append(menu);
                            // Return value not used
                            return null;
                        }
                    });
//            log.error(sb.toString(), re);
            throw re;
        }
    }
    
    /**
     * select MenuItem programatically (for Mac OS)
     */
    public void selectProgramatically() {
//        FIXME must implement this check case
//        if (!isMenuItemEnabled(menuItem)) {
//            throw new StepExecutionException("menu item not enabled", //$NON-NLS-1$
//                    EventFactory.createActionError(
//                            TestErrorEvent.MENU_ITEM_NOT_ENABLED));
//        }
        final MenuItem menuItem = m_menuItem;
        final InterceptorOptions options = new InterceptorOptions(
                new long[]{SWT.Selection});
        final IEventMatcher matcher = 
            new SelectionSwtEventMatcher();        
        RobotFactorySwtImpl robotSwt = new RobotFactorySwtImpl();
        IRobotEventInterceptor interceptor =
            robotSwt.getRobotEventInterceptor();        
        final IRobotEventConfirmer confirmer = interceptor
            .intercept(options);
        
        final Event event = new Event();
        event.time = (int) System.currentTimeMillis();
        event.widget = menuItem;
        event.display = menuItem.getDisplay();
        event.type = SWT.Selection;
        
        getEventThreadQueuer().invokeLater(
                "selectProgramatically", new Runnable() { //$NON-NLS-1$
                    public void run() {  
                        //if menuitem is checkbox or radiobutton set Selection
                        if ((menuItem.getStyle() & SWT.CHECK) == 0
                                || (menuItem.getStyle() & SWT.RADIO) == 0) {
                            if (menuItem.getSelection()) {
                                menuItem.setSelection(false);
                            } else {
                                menuItem.setSelection(true);
                            }                            
                        }

                        menuItem.notifyListeners(SWT.Selection, event);
                        
                    }            
                });

        try {
            confirmer.waitToConfirm(menuItem, matcher);
        } catch (RobotException re) {
            final StringBuffer sb = new StringBuffer(
                "Robot exception occurred while clicking...\n"); //$NON-NLS-1$
            //logRobotException(menuItem, re, sb);
            sb.append("Component: "); //$NON-NLS-1$

            getEventThreadQueuer().invokeAndWait(
                "getBounds", new IRunnable() { //$NON-NLS-1$
                    public Object run()
                        throws StepExecutionException {
                        sb.append(menuItem);
                        // Return value not used
                        return null;
                    }
                });
//  FIXME LOG IS MISSING HERE
//            log.error(sb.toString(), re);
            throw re;
        }
    
    }
    
    
}




/*******************************************************************************
 * 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.uiadapter;

import java.awt.Rectangle;

import org.eclipse.jubula.rc.common.driver.ClickOptions;
import org.eclipse.jubula.rc.common.driver.IRunnable;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.implclasses.IndexConverter;
import org.eclipse.jubula.rc.common.implclasses.MatchUtil;
import org.eclipse.jubula.rc.common.implclasses.table.Cell;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.ITableAdapter;
import org.eclipse.jubula.rc.swt.listener.TableSelectionTracker;
import org.eclipse.jubula.rc.swt.utils.SwtUtils;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TableCursor;
import org.eclipse.swt.graphics.FontMetrics;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
/**
 * Implements the Table interface for adapting a <code>SWT.Table</code>
 * 
 * @author BREDEX GmbH
 */
public class TableAdapter extends WidgetAdapter implements ITableAdapter {
    /**   */
    private Table m_table;
    
    /**
     * 
     * @param objectToAdapt graphics component which will be adapted
     */
    public TableAdapter(Object objectToAdapt) {
        super(objectToAdapt);
        m_table = (Table) objectToAdapt;
    }

    /** {@inheritDoc} */
    public int getColumnCount() {
        Integer returnvalue = (Integer) getEventThreadQueuer().invokeAndWait(
                "getColumnCount", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return  new Integer(m_table.getColumnCount());
                    }
                });
        return returnvalue.intValue();
    }

    /** {@inheritDoc} */
    public int getRowCount() {
        Integer returnvalue = (Integer) getEventThreadQueuer().invokeAndWait(
                "getRowCount", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return new Integer(m_table.getItemCount());
                    }
                });
        return returnvalue.intValue();
    }

    /** {@inheritDoc} */
    public String getCellText(final int row, final int column) {
        String current = (String)getEventThreadQueuer().invokeAndWait("getCellText", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        String value = m_table.getItem(row).getText(column);
//                        if (log.isDebugEnabled()) {
//                            log.debug("Getting cell text:"); //$NON-NLS-1$
//                            log.debug("Row, col: " + row + ", " + col); //$NON-NLS-1$ //$NON-NLS-2$
//                            log.debug("Value: " + value); //$NON-NLS-1$
//                        }
                        return value;
                    }
                });
        return current;
    }

    /** {@inheritDoc} */
    public String getColumnName(final int column) {
        String current = (String)getEventThreadQueuer().invokeAndWait("getColumnName", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        String value = m_table.getColumn(column).getText();
                        return value;
                    }
                });
        return current;
    }

    /** {@inheritDoc} */
    public int getColumnFromString(final String col, final String operator) {
        int column = -2;
        try {
            int usrIdxCol = Integer.parseInt(col);
            if (usrIdxCol == 0) {
                usrIdxCol = usrIdxCol + 1;
            }
            column = IndexConverter.toImplementationIndex(
                    usrIdxCol);
        } catch (NumberFormatException nfe) {
            try {
                Boolean isVisible;
                isVisible = (Boolean)getEventThreadQueuer().invokeAndWait(
                        "getColumnFromString", //$NON-NLS-1$
                        new IRunnable() {
                            public Object run() {
                                return new Boolean(m_table.getHeaderVisible());
                            }
                        });  
                if (!(isVisible.booleanValue())) {
                    throw new StepExecutionException("No Header", //$NON-NLS-1$
                            EventFactory.createActionError(
                                TestErrorEvent.NO_HEADER));
                }
                
                Integer implCol;
                implCol = (Integer)getEventThreadQueuer().invokeAndWait(
                    "getColumnFromString", new IRunnable() { //$NON-NLS-1$
                        public Object run() throws StepExecutionException {
                            for (int i = 0; i < m_table.getColumnCount(); i++) {
                                TableColumn tblCol = m_table.getColumn(i);
                                if (MatchUtil.getInstance().match(
                                        tblCol.getText(), col, operator)) {
                                    return new Integer (i);
                                }
                            }
                            return new Integer (-2);
                        }
                    });                
                column = implCol.intValue();                
            } catch (IllegalArgumentException iae) {
                //do nothing here
            }
        }        
        return column;
    }

    /** {@inheritDoc} */
    public String getRowName(final int row) {
        String current = (String)getEventThreadQueuer().invokeAndWait("getRowName", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        String value = m_table.getItem(row).getText();
                        return value;
                    }
                });
        return current;
    }

    /** {@inheritDoc} */
    public int getRowFromString(final String row, final String operator) {
        int rowInt = -2;        
        try {
            rowInt = IndexConverter.toImplementationIndex(
                    Integer.parseInt(row));                       
            if (rowInt == -1) {
                Boolean isVisible;
                isVisible = (Boolean)getEventThreadQueuer().invokeAndWait(
                        "getRowFromString", //$NON-NLS-1$
                        new IRunnable() {
                            public Object run() {
                                return new Boolean(m_table.getHeaderVisible());
                            }
                        }); 
                if (!(isVisible.booleanValue())) {
                    throw new StepExecutionException("Header not visible", //$NON-NLS-1$
                            EventFactory.createActionError(
                                TestErrorEvent.NO_HEADER));
                }                
            }
        } catch (NumberFormatException nfe) {
            Integer implRow;
            implRow = (Integer)getEventThreadQueuer().invokeAndWait(
                "getRowFromString", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() throws StepExecutionException {
                        for (int i = 0; i < m_table.getItemCount(); i++) {
                            String cellTxt = getCellText(i, 0);
                            if (MatchUtil.getInstance().match(
                                    cellTxt, row, operator)) {
                                return new Integer(i);
                            }
                        }
                        return new Integer(-2);
                    }
                });
            rowInt = implRow.intValue();
        }        
        return rowInt;
    }

    /** {@inheritDoc} */
    public Rectangle getBounds() {
        Rectangle returnvalue = (Rectangle) getEventThreadQueuer()
                .invokeAndWait("getBounds", //$NON-NLS-1$
                    new IRunnable() {                     
                        public Object run() throws StepExecutionException {
                            return m_table.getBounds();
                        }
                    });
        
        return returnvalue;
    }

    /** {@inheritDoc} */
    public Rectangle getHeaderBounds(final int col) {
        Rectangle cellBounds;
        cellBounds = (Rectangle)getEventThreadQueuer().invokeAndWait(
            "getHeaderBounds", //$NON-NLS-1$
            new IRunnable() {
                public Object run() throws StepExecutionException {
                    org.eclipse.swt.graphics.Rectangle rect =
                            m_table.getItem(0).getBounds(col);
                    rect.y = m_table.getClientArea().y;
                    return new Rectangle(rect.x, rect.y, rect.width,
                            rect.height);
                }
            });
        return cellBounds;
    }

    /** {@inheritDoc} */
    public Cell getSelectedCell() throws StepExecutionException {
        Cell cell = (Cell) getEventThreadQueuer().invokeAndWait(
                "getSelectedSell", new IRunnable() {   //$NON-NLS-1$         
                    public Object run() throws StepExecutionException {
                        return TableSelectionTracker.getInstance()
                                .getSelectedCell(m_table);
                    }
                });
        return cell;
    } 

    /** {@inheritDoc} */
    public boolean isHeaderVisible() {
        Boolean isVisible;
        isVisible = (Boolean)getEventThreadQueuer().invokeAndWait(
                "isHeaderVisible", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        return new Boolean(m_table.getHeaderVisible());
                    }
                });
        return isVisible.booleanValue();
    }

    /** {@inheritDoc} */
    public boolean isCellEditable(final int row, final int col) {
        final Control cellEditor = (Control) 
                activateEditor(new Cell(row, col));
        boolean isEditable = ((Boolean)getEventThreadQueuer().invokeAndWait(
                "isCellEditable", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {

                        return isEditable(cellEditor) 
                            ? Boolean.TRUE : Boolean.FALSE;
                    }
                })).booleanValue();
        return isEditable;
    }

    /** {@inheritDoc} */
    public boolean hasCellSelection() {
        TableItem[] selItems = (TableItem[])getEventThreadQueuer()
                .invokeAndWait("hasCellSelection", //$NON-NLS-1$
                    new IRunnable() {
                        public Object run() {
                            return m_table.getSelection();
                        }
                    });
        return selItems.length > 0;
    }
    
    /**
     * {@inheritDoc}
     */
    public Rectangle scrollCellToVisible(final int row, final int col)
        throws StepExecutionException {
        final Table table = m_table;
        getEventThreadQueuer().invokeAndWait("scrollCellToVisible", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        if (table.getColumnCount() > 0 || col > 0) {
                            table.showColumn(table.getColumn(col));
                        }
                        table.showItem(table.getItem(row));
                        return null;
                    }
                });

        final Rectangle cellBoundsRelativeToParent = getCellBounds(row, col);
            
        getEventThreadQueuer().invokeAndWait("getCellBoundsRelativeToParent", //$NON-NLS-1$
            new IRunnable() {
                public Object run() {
                    org.eclipse.swt.graphics.Point cellOriginRelativeToParent = 
                        table.getDisplay().map(
                                table, table.getParent(), 
                                new org.eclipse.swt.graphics.Point(
                                        cellBoundsRelativeToParent.x, 
                                        cellBoundsRelativeToParent.y));
                    cellBoundsRelativeToParent.x = 
                        cellOriginRelativeToParent.x;
                    cellBoundsRelativeToParent.y = 
                        cellOriginRelativeToParent.y;
                    return null;
                }
            });

        Control parent = (Control)getEventThreadQueuer().invokeAndWait("getParent", //$NON-NLS-1$
                new IRunnable() {
                public Object run() {
                    table.getParent();
                    return null;
                }
            });

            
        getRobot().scrollToVisible(
                parent, cellBoundsRelativeToParent);
        
        return getVisibleBounds(getCellBounds(row, col));
    }
    
    /**
     * 
     * @param row   The row of the cell
     * @param col   The column of the cell
     * @return The bounding rectangle for the cell, relative to the table's 
     *         location.
     */
    private Rectangle getCellBounds(final int row, final int col) {
        Rectangle cellBounds = (Rectangle)getEventThreadQueuer().invokeAndWait(
                "evaluateCellBounds", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        checkRowColBounds(row, col);
                        TableItem ti = m_table.getItem(row);
                        int column = (m_table.getColumnCount() > 0 || col > 0) 
                            ? col : 0;
                        org.eclipse.swt.graphics.Rectangle r = 
                                ti.getBounds(column);
                        String text = ti.getText(column);
                        Image image = ti.getImage(column);
                        if (text != null && text.length() != 0) {
                            GC gc = new GC(m_table);
                            int charWidth = 0; 
                            try {
                                FontMetrics fm = gc.getFontMetrics();
                                charWidth = fm.getAverageCharWidth();
                            } finally {
                                gc.dispose();
                            }
                            r.width = text.length() * charWidth;
                            if (image != null) {
                                r.width += image.getBounds().width;
                            }
                        } else if (image != null) {
                            r.width = image.getBounds().width;
                        }
                        if (column > 0) {
                            TableColumn tc = m_table.getColumn(column);
                            int alignment = tc.getAlignment();
                            if (alignment == SWT.CENTER) {
                                r.x += ((double)tc.getWidth() / 2) 
                                        - ((double)r.width / 2);
                            }
                            if (alignment == SWT.RIGHT) {
                                r.x += tc.getWidth() - r.width;
                            }
                        }
                        
                        return new Rectangle(r.x, r.y, r.width, r.height);
                    }
                });
        return cellBounds;
    }

    /**
     * Checks wether <code>0 <= value < count</code>. 
     * @param value The value to check.
     * @param count The upper bound.
     */
    private void checkBounds(int value, int count) {
        if (value < 0 || value >= count) {
            throw new StepExecutionException("Invalid row/column: " + value, //$NON-NLS-1$
                EventFactory.createActionError(
                        TestErrorEvent.INVALID_INDEX_OR_HEADER));
        }
    }
    
    /**
     * Checks if the passed row and column are inside the bounds of the Table. 
     * @param row The row
     * @param column The column
     * @throws StepExecutionException If the row or the column is outside of the Table's bounds.
     */
    protected void checkRowColBounds(int row, int column)
        throws StepExecutionException {
        checkBounds(row, getRowCount());
        
        // Corner case: Only check the bounds if the table is not being
        //              used as a list or anything other than the first column
        //              is being checked.
        int colCount = getColumnCount();
        if (colCount > 0 || column > 0) {
            checkBounds(column, colCount);
        }
    }
    
    /**
     * Computes the visible cellBounds inside the visible bounds of the table.<br>
     * The result is the intersection of the visible bounds of the table and the 
     * bounds of the cell.
     * @param cellBounds the bounds of the cell to click in. These bounds must
     *                  be relative to the table's location.
     * @return the visible cell bounds, relative to the table's location.
     */
    private Rectangle getVisibleBounds(Rectangle cellBounds) {
        org.eclipse.swt.graphics.Rectangle r = 
            (org.eclipse.swt.graphics.Rectangle)
            getEventThreadQueuer().invokeAndWait("getVisibleCellBounds: " + cellBounds,  //$NON-NLS-1$
                    new IRunnable() {

                    public Object run() {
                        return m_table.getClientArea();
                    }
                });
        
        Rectangle visibleTableBounds = new Rectangle(
            r.x, r.y, r.width, r.height);
        Rectangle visibleCellBounds = 
            visibleTableBounds.intersection(cellBounds);
        return visibleCellBounds;
    }
    
    /**
     * @param cellEditor The cell editor to check.
     * @return <code>true</code> if the given cell editor is editable.
     */
    private boolean isEditable(Control cellEditor) {

        if (cellEditor == null || cellEditor instanceof TableCursor
            || cellEditor == m_table) {
            // No actual editor found.
            return false;
        }
        
        return (cellEditor.getStyle() & SWT.READ_ONLY) == 0;
    } 
    
    /**
     * @param cellEditor The cell editor to check.
     * @return <code>true</code> if the given editor is editable. Otherwise
     *         <code>false</code>.
     */
    private boolean invokeIsEditable(final Control cellEditor) {

        boolean isEditable = ((Boolean)getEventThreadQueuer().invokeAndWait(
                "getSelectedCell", //$NON-NLS-1$
                new IRunnable() {
                    public Object run() {
                        return isEditable(cellEditor) 
                            ? Boolean.TRUE : Boolean.FALSE;
                    }
                })).booleanValue();
        return isEditable;
    }
    
    /**
     * {@inheritDoc}
     */
    public Object activateEditor(final Cell cell) {

        Rectangle rect = scrollCellToVisible(cell.getRow(), cell.getCol());
        Control editor = getTableCellEditor(cell, rect);
        // sometimes the editor only appears after doubleclick!

        if (!invokeIsEditable(editor)) {
            org.eclipse.swt.graphics.Rectangle cellBounds = 
                    new org.eclipse.swt.graphics.Rectangle(
                    rect.x, rect.y, rect.width, rect.height);
            ClickOptions co = ClickOptions.create().setClickCount(2);
            Control clickTarget = editor == null
                    || editor instanceof TableCursor ? m_table : editor;
            getRobot().click(clickTarget, cellBounds, co);
            editor = getTableCellEditor(cell, rect);
        }

        return editor;

    }
    /**
     * Gets the TableCellEditor of the given cell.
     * The Cell has to be activated before!
     * @param cell the cell.
     * @param rect 
     * @return the TableCellEditor
     */
    private Control getTableCellEditor(final Cell cell, Rectangle rect) {
        org.eclipse.swt.graphics.Rectangle swtRect = 
                new org.eclipse.swt.graphics.Rectangle(rect.x, rect.y, 
                        rect.width, rect.height);
        getRobot().click(m_table, 
            swtRect,
            ClickOptions.create().setClickCount(1));

        
        return SwtUtils.getCursorControl();
    }
}




/*******************************************************************************
 * 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.uiadapter;

import org.eclipse.jubula.rc.common.driver.IRunnable;
import org.eclipse.jubula.rc.common.implclasses.tree.AbstractTreeOperationContext;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.ITreeAdapter;
import org.eclipse.jubula.rc.swt.implclasses.TreeOperationContext;
import org.eclipse.swt.widgets.Tree;
/**
 * Implements the Tree interface for adapting a <code>SWT.Tree</code>
 * 
 *  @author BREDEX GmbH
 */
public class TreeAdapter extends WidgetAdapter implements ITreeAdapter {


    /**
     * 
     * @param objectToAdapt graphics component which will be adapted
     */
    public TreeAdapter(Object objectToAdapt) {
        super(objectToAdapt);
    }
    /**
     * 
     * @return the caste object
     */
    private Tree getTree() {
        return (Tree) getRealComponent();
    }
    /**
     * {@inheritDoc}
     */
    public Object getRootNode() {
        return getEventThreadQueuer()
                .invokeAndWait("getRootNode", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return getTree().getItems();
                    }
                });
    }
    /**
     * {@inheritDoc}
     */
    public AbstractTreeOperationContext getContext() {
        return new TreeOperationContext(getEventThreadQueuer(),
                getRobot(), getTree());
    }
    /**
     * {@inheritDoc}
     */
    public boolean isRootVisible() {
        
        return true;
    }

}




/*******************************************************************************
 * 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.uiadapter;

import org.eclipse.jubula.rc.common.caps.AbstractMenuCAPs;
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.driver.RobotTiming;
import org.eclipse.jubula.rc.common.exception.RobotException;
import org.eclipse.jubula.rc.common.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.listener.EventLock;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IWidgetAdapter;
import org.eclipse.jubula.rc.swt.caps.CAPUtil;
import org.eclipse.jubula.rc.swt.caps.MenuCAPs;
import org.eclipse.jubula.rc.swt.driver.DragAndDropHelperSwt;
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.SimulatedTooltip;
import org.eclipse.jubula.rc.swt.utils.SwtUtils;
import org.eclipse.jubula.tools.constants.TimeoutConstants;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Widget;
/**
 * Implements the interface for widgets and supports basic methods
 * which are needed for nearly a lot of components.
 * 
 *  @author BREDEX GmbH
 */
public abstract class WidgetAdapter implements IWidgetAdapter {
    
    /** constants for communication */
    protected static final String POS_UNIT_PIXEL = "Pixel"; //$NON-NLS-1$
    /** constants for communication */
    protected static final String POS_UNI_PERCENT = "Percent"; //$NON-NLS-1$


    /** the RobotFactory from the AUT */
    private IRobotFactory m_robotFactory;
     
    /**   */
    private Control m_component;
    
    /**
     * Is true, if a popup menu is shown 
     */
    protected static class PopupShownCondition implements
            EventListener.Condition {

        /**
         * the popup menu
         */
        private Menu m_popup = null;
        
        /**
         * 
         * @return the popup menu
         */
        public Menu getPopup() {
            return m_popup;
        }
        
        /**
         * {@inheritDoc}
         * @param event event
         * @return result of the condition
         */
        public boolean isTrue(Event event) {

            if (event.type == SWT.Show && event.widget instanceof Menu) {
                m_popup = (Menu)event.widget;
                return true;
            } 
            
            return false;
        }
    }
    
    /**
     * 
     * @param objectToAdapt 
     */
    protected WidgetAdapter(Object objectToAdapt) {
        m_component = (Control) objectToAdapt;
    }
    
    /**
     * {@inheritDoc}
     */
    public Object getRealComponent() {
        return m_component;
    }
    
    /**
     * Gets the Robot factory. The factory is created once per instance.
     *
     * @return The Robot factory.
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }
    /**
     * Gets the Robot
     *
     * @return The Robot
     * @throws RobotException
     *             If the Robot cannot be created.
     */
    protected IRobot getRobot() throws RobotException {
        return getRobotFactory().getRobot();
    }
    /**
     * @return The event thread queuer.
     */
    public IEventThreadQueuer getEventThreadQueuer() {
        return getRobotFactory().getEventThreadQueuer();
    }
    
    /**
     * {@inheritDoc}
     */
    public String getPropteryValue(final String propertyname) {
        Object prop = getEventThreadQueuer().invokeAndWait("getProperty",  //$NON-NLS-1$
                new IRunnable() {
                    public Object run() throws StepExecutionException {
                        try {
                            return getRobot().getPropertyValue(
                                    getRealComponent(), propertyname);
                        } catch (RobotException e) {
                            throw new StepExecutionException(
                                e.getMessage(), 
                                EventFactory.createActionError(
                                    TestErrorEvent.PROPERTY_NOT_ACCESSABLE));
                        }
                    }
                });
        return String.valueOf(prop);
    }
    
    /**
     * {@inheritDoc}
     */
    public boolean isShowing() {
        Boolean actual = (Boolean)getEventThreadQueuer()
                .invokeAndWait("isShowing", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_component.isVisible() 
                            ? Boolean.TRUE : Boolean.FALSE; // see findBugs;
                    }
                });
        return actual.booleanValue();
    }
    
    /**
     * {@inheritDoc}
     */
    public boolean isEnabled() {

        Boolean actual = (Boolean)getEventThreadQueuer()
                .invokeAndWait("isEnabled", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_component.isEnabled() 
                            ? Boolean.TRUE : Boolean.FALSE; // see findBugs;
                    }
                });
        return actual.booleanValue();
    }
    
    /**
     * {@inheritDoc}
     */
    public boolean hasFocus() {
        Boolean actual = (Boolean)getEventThreadQueuer()
                .invokeAndWait("hasFocus", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_component.isFocusControl() 
                            ? Boolean.TRUE : Boolean.FALSE; // see findBugs;
                    }
                });
        return actual.booleanValue();
    }
    
    /**
     * Shows and returns the popup menu
     * @param button MouseButton
     * @return the popup menu
     */
    public AbstractMenuCAPs showPopup(
            final int button) {
        final Widget component = m_component;
        if (SwtUtils.isMouseCursorInWidget(component)) {
            return showPopup(component, new Runnable() {
                public void run() {
                    RobotTiming.sleepPreShowPopupDelay();
                    
                    getRobot().clickAtCurrentPosition(component, 1, 
                            button);
                }
            });
        }
        return showPopup(50, POS_UNI_PERCENT, 50, 
            POS_UNI_PERCENT, button);
    }

    /**
     * Shows and returns the popup menu
     * 
     * @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
     * @param button MouseButton
     * @return the popup menu
     * @throws StepExecutionException error
     */
    public AbstractMenuCAPs showPopup(
            final int xPos, final String xUnits,
            final int yPos, final String yUnits, 
            final int button) throws StepExecutionException {
        final Widget component = m_component;
        return showPopup(component, new Runnable() {
            public void run() {
                RobotTiming.sleepPreShowPopupDelay();
                boolean isAbsoluteUnitsX = 
                    POS_UNIT_PIXEL.equalsIgnoreCase(
                            xUnits);
                boolean isAbsoluteUnitsY = 
                    POS_UNIT_PIXEL.equalsIgnoreCase(
                            yUnits);
                getRobot().click(component, null, 
                    ClickOptions.create().setClickCount(1)
                        .setMouseButton(button), 
                    xPos, isAbsoluteUnitsX, yPos, isAbsoluteUnitsY);
            }
        });
    }

    /**
     * Shows and returns the popup menu
     * 
     * @param component The component for which to open the popup menu.
     * @param showPopup A <code>Runnable</code> that, when run, should display
     *                  a popup menu for the given component.
     * @return the popup menu
     * @throws StepExecutionException error
     */
    private AbstractMenuCAPs showPopup(final Widget component, 
        final Runnable showPopup) throws StepExecutionException {

        PopupShownCondition cond = new PopupShownCondition();
        EventLock lock = new EventLock();
        final EventListener listener = new EventListener(lock, cond);
        final Display d = component.getDisplay();
        final IEventThreadQueuer queuer = new EventThreadQueuerSwtImpl();
        
        queuer.invokeAndWait("addPopupShownListeners", new IRunnable() { //$NON-NLS-1$
            public Object run() {
                d.addFilter(SWT.Show, listener);
                
                return null;
            }
        });
        
        try {
            // showPopup must run in the current thread in order to
            // avoid a race condition.
            showPopup.run();

            synchronized (lock) {
                long timeout = TimeoutConstants.SERVER_TIMEOUT_WAIT_FOR_POPUP;
                long done = System.currentTimeMillis() + timeout; 
                long now;
                while (!lock.isReleased() && (timeout > 0)) {
                    lock.wait(timeout);
                    now = System.currentTimeMillis();
                    timeout = done - now;
                }
            } 
        } catch (InterruptedException e) {
            // ignore
        } finally {
            queuer.invokeAndWait("removePopupShownListeners", new IRunnable() { //$NON-NLS-1$
                public Object run() {
                    d.removeFilter(SWT.Show, listener);
                    
                    return null;
                }
            });
        }
        if (!lock.isReleased()) {
            throw new StepExecutionException("popup not shown", //$NON-NLS-1$
                    EventFactory.createActionError(
                            TestErrorEvent.POPUP_NOT_FOUND));
        }
        
        MenuCAPs contextMenu = new MenuCAPs();
        contextMenu.setComponent(cond.getPopup());
        contextMenu.setContextMenu(true);
        return contextMenu;
    }
    
    /**
     * {@inheritDoc}
     */
    public void showToolTip(final String text, final int textSize, 
        final int timePerWord, final int windowWidth) {

        final Rectangle bounds = (Rectangle)getEventThreadQueuer()
            .invokeAndWait("gdShowText.getBounds", new IRunnable() { //$NON-NLS-1$

                public Object run() {
                    return SwtUtils.getWidgetBounds(m_component);
                }
            });

        SimulatedTooltip sp = (SimulatedTooltip)getEventThreadQueuer()
            .invokeAndWait("gdShowText.initToolTip", new IRunnable() { //$NON-NLS-1$

                public Object run() throws StepExecutionException {
                    return new SimulatedTooltip(timePerWord, text,
                        windowWidth, textSize, bounds);
                }
            
            });
        sp.start();
        try {
            sp.join();
        } catch (InterruptedException e) {
            throw new StepExecutionException(e);
        }
    }
    
    /**
     * {@inheritDoc}
     */
    public void gdDrag(int mouseButton, String modifier, int xPos, 
            String xUnits, int yPos, String yUnits) {
        // Only store the Drag-Information. Otherwise the GUI-Eventqueue
        // blocks after performed Drag!
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        dndHelper.setMouseButton(mouseButton);
        dndHelper.setModifier(modifier);
        dndHelper.setDragComponent(null);
        clickDirect(0, mouseButton, xPos, xUnits, yPos, yUnits);
    }
    
    /**
     * {@inheritDoc}                  
     */
    public void gdDrop(final int xPos, final String xUnits, final int yPos, 
            final String yUnits, int delayBeforeDrop) {
        final DragAndDropHelperSwt dndHelper = DragAndDropHelperSwt
            .getInstance();
        final IRobot robot = getRobot();
        final String modifier = dndHelper.getModifier();
        final int mouseButton = dndHelper.getMouseButton();
        // Note: This method performs the drag AND drop action in one runnable
        // in the GUI-Eventqueue because after the mousePress, the eventqueue
        // blocks!
        try {
            CAPUtil.pressOrReleaseModifiers(modifier, true);

            getEventThreadQueuer().invokeAndWait("gdStartDrag", new IRunnable() { //$NON-NLS-1$
                public Object run() throws StepExecutionException {
                    // drag
                    robot.mousePress(dndHelper.getDragComponent(), null, 
                            mouseButton);

                    CAPUtil.shakeMouse();
                    
                    // drop
                    clickDirect(0, mouseButton, xPos, xUnits, yPos, yUnits);
                    return null;
                }            
            });
            
            CAPUtil.waitBeforeDrop(delayBeforeDrop);
        } finally {
            getRobot().mouseRelease(null, null, mouseButton);
            CAPUtil.pressOrReleaseModifiers(modifier, false);
        }
    }

    /**
     * clicks into a component. 
     * @param count amount of clicks
     * @param button what button should be clicked
     * @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
     */
    protected void clickDirect(int count, int button, int xPos, String xUnits,
            int yPos, String yUnits)
        throws StepExecutionException {

        getRobot().click(
                m_component,
                null,
                ClickOptions.create().setClickCount(count).setMouseButton(
                        button), xPos, xUnits.equalsIgnoreCase(POS_UNIT_PIXEL),
                yPos, yUnits.equalsIgnoreCase(POS_UNIT_PIXEL));
    }
}




/*******************************************************************************
 * 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.uiadapter.factory;

import org.eclipse.jubula.rc.common.uiadapter.factory.IUIAdapterFactory;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;
import org.eclipse.jubula.rc.swt.uiadapter.ButtonAdapter;
import org.eclipse.jubula.rc.swt.uiadapter.MenuAdapter;
import org.eclipse.jubula.rc.swt.uiadapter.MenuItemAdapter;
import org.eclipse.jubula.rc.swt.uiadapter.TableAdapter;
import org.eclipse.jubula.rc.swt.uiadapter.TreeAdapter;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Tree;

/**
 * This factory constructs the specific adapter out of the incoming
 * graphics component from the AUT.
 * 
 * @author BREDEX GmbH
 */
public class SWTAdapterFactory implements IUIAdapterFactory {
    /** */
    private static final Class[] SUPPORTEDCLASSES = 
            new Class[]{Button.class, Menu.class, MenuItem.class, Tree.class,
                Table.class};
    
    
    /**
     * {@inheritDoc}
     */
    public Class[] getSupportedClasses() {
        return SUPPORTEDCLASSES;
    }

    /**
     * {@inheritDoc}
     */
    public IComponentAdapter getAdapter(Object objectToAdapt) {
        IComponentAdapter returnvalue = null;
        if (objectToAdapt instanceof Button) {
            returnvalue = new ButtonAdapter(objectToAdapt);
        } else if (objectToAdapt instanceof Menu) {
            returnvalue = new MenuAdapter(objectToAdapt);
        } else if (objectToAdapt instanceof MenuItem) {
            returnvalue = new MenuItemAdapter(objectToAdapt);
        } else if (objectToAdapt instanceof Tree) {
            returnvalue = new TreeAdapter(objectToAdapt);
        } else if (objectToAdapt instanceof Table) {
            returnvalue = new TableAdapter(objectToAdapt);
        }
        
        
        return returnvalue;
    }

}




	
	<toolkitComponent type="javax.swing.AbstractButton" visible="false">
		<realizes>guidancer.concrete.Button</realizes>
		<testerClass>org.eclipse.jubula.rc.swing.swing.caps.AbstractButtonCAPs</testerClass>
		<componentClass name="javax.swing.AbstractButton" />
	</toolkitComponent>


			<typeFactory>org.eclipse.jubula.rc.common.implclasses.DefaultComponentFactory</typeFactory>
		</defaultMapping>
		<realizes>guidancer.concrete.MenuBar</realizes>
		<testerClass>org.eclipse.jubula.rc.swing.swing.caps.JMenuBarCAPs</testerClass>
		<componentClass name="com.bredexsw.guidancer.autserver.swing.implclasses.JMenuBarDefaultMapping" />
	</toolkitComponent>
	
	<toolkitComponent type="javax.swing.JComboBox" visible="false">
		<realizes>guidancer.concrete.ComboBox</realizes>
		<testerClass>org.eclipse.jubula.rc.swing.swing.caps.JComboBoxCAPs</testerClass>
		<componentClass name="javax.swing.JComboBox" />
	</toolkitComponent>
	

	
	<toolkitComponent type="javax.swing.JTable" visible="false">
		<realizes>guidancer.concrete.Table</realizes>
		<testerClass>org.eclipse.jubula.rc.swing.swing.caps.JTableCAPs</testerClass>
		<componentClass name="javax.swing.JTable" />
	</toolkitComponent>
	

	
	<toolkitComponent type="javax.swing.JTree" visible="false">
		<realizes>guidancer.concrete.Tree</realizes>
		<testerClass>org.eclipse.jubula.rc.swing.swing.caps.JTreeCAPs</testerClass>
		<componentClass name="javax.swing.JTree" />
	</toolkitComponent>
	




	
	<toolkitComponent type="org.eclipse.swt.widgets.Button" visible="false">
		<realizes>guidancer.abstract.SwtButton</realizes>
		<testerClass>org.eclipse.jubula.rc.swt.caps.ButtonCAPs</testerClass>
		<componentClass name="org.eclipse.swt.widgets.Button" />
	</toolkitComponent>
	

			<typeFactory>org.eclipse.jubula.rc.common.implclasses.DefaultComponentFactory</typeFactory>
		</defaultMapping>
		<realizes>guidancer.concrete.MenuBar</realizes>
		<testerClass>org.eclipse.jubula.rc.swt.caps.MenuCAPs</testerClass>
		<componentClass name="com.bredexsw.guidancer.autswtserver.implclasses.MenuDefaultMapping" />
	</toolkitComponent>
	

	
	<toolkitComponent type="org.eclipse.swt.widgets.Table" visible="false">
		<realizes>guidancer.concrete.Table</realizes>
		<testerClass>org.eclipse.jubula.rc.swt.caps.TableCAPs</testerClass>
		<componentClass name="org.eclipse.swt.widgets.Table" />
	</toolkitComponent>
	
	<toolkitComponent type="org.eclipse.swt.widgets.Tree" observable="false">
		<realizes>guidancer.concrete.Tree</realizes>
		<testerClass>org.eclipse.jubula.rc.swt.caps.TreeCAPs</testerClass>
		<componentClass name="org.eclipse.swt.widgets.Tree" />
		<action name="CompSystem.VerifyCheckboxOfSelectedEntry" changed="4.1">
			<method>gdVerifySelectedCheckbox</method>

	
	<toolkitComponent type="org.eclipse.swt.widgets.SwtTree">
		<realizes>org.eclipse.swt.widgets.Tree</realizes>
		<testerClass>org.eclipse.jubula.rc.swt.caps.TreeCAPs</testerClass>
		<componentClass name="org.eclipse.swt.widgets.Tree" />
		<action name="CompSystem.SelectByTextPathAtColumn" changed="1.22">
			<method>gdSelect</method>
- 

Return to bug 394179

Lines 184-190 Link Here

(-)a/org.eclipse.jubula.toolkit.provider.swt/resources/xml/ComponentConfiguration.xml (-6 / +5 lines)
184		184
185	<toolkitComponent type="org.eclipse.swt.widgets.Button" visible="false">	185	<toolkitComponent type="org.eclipse.swt.widgets.Button" visible="false">
186	<realizes>guidancer.abstract.SwtButton</realizes>	186	<realizes>guidancer.abstract.SwtButton</realizes>
187	<testerClass>org.eclipse.jubula.rc.swt.implclasses.ButtonImplClass</testerClass>	187	<testerClass>org.eclipse.jubula.rc.swt.caps.ButtonCAPs</testerClass>
188	<componentClass name="org.eclipse.swt.widgets.Button" />	188	<componentClass name="org.eclipse.swt.widgets.Button" />
189	</toolkitComponent>	189	</toolkitComponent>
190		190
Lines 203-209 Link Here
203	<typeFactory>org.eclipse.jubula.rc.common.implclasses.DefaultComponentFactory</typeFactory>	203	<typeFactory>org.eclipse.jubula.rc.common.implclasses.DefaultComponentFactory</typeFactory>
204	</defaultMapping>	204	</defaultMapping>
205	<realizes>guidancer.concrete.MenuBar</realizes>	205	<realizes>guidancer.concrete.MenuBar</realizes>
206	<testerClass>org.eclipse.jubula.rc.swt.implclasses.MenuImplClass</testerClass>	206	<testerClass>org.eclipse.jubula.rc.swt.caps.MenuCAPs</testerClass>
207	<componentClass name="com.bredexsw.guidancer.autswtserver.implclasses.MenuDefaultMapping" />	207	<componentClass name="com.bredexsw.guidancer.autswtserver.implclasses.MenuDefaultMapping" />
208	</toolkitComponent>	208	</toolkitComponent>
209		209
Lines 239-251 Link Here
239		239
240	<toolkitComponent type="org.eclipse.swt.widgets.Table" visible="false">	240	<toolkitComponent type="org.eclipse.swt.widgets.Table" visible="false">
241	<realizes>guidancer.concrete.Table</realizes>	241	<realizes>guidancer.concrete.Table</realizes>
242	<testerClass>org.eclipse.jubula.rc.swt.implclasses.TableImplClass</testerClass>	242	<testerClass>org.eclipse.jubula.rc.swt.caps.TableCAPs</testerClass>
243	<componentClass name="org.eclipse.swt.widgets.Table" />	243	<componentClass name="org.eclipse.swt.widgets.Table" />
244	</toolkitComponent>	244	</toolkitComponent>
245		245
246	<toolkitComponent type="org.eclipse.swt.widgets.Tree" observable="false">	246	<toolkitComponent type="org.eclipse.swt.widgets.Tree" observable="false">
247	<realizes>guidancer.concrete.Tree</realizes>	247	<realizes>guidancer.concrete.Tree</realizes>
248	<testerClass>org.eclipse.jubula.rc.swt.implclasses.TableTreeImplClass</testerClass>	248	<testerClass>org.eclipse.jubula.rc.swt.caps.TreeCAPs</testerClass>
249	<componentClass name="org.eclipse.swt.widgets.Tree" />	249	<componentClass name="org.eclipse.swt.widgets.Tree" />
250	<action name="CompSystem.VerifyCheckboxOfSelectedEntry" changed="4.1">	250	<action name="CompSystem.VerifyCheckboxOfSelectedEntry" changed="4.1">
251	<method>gdVerifySelectedCheckbox</method>	251	<method>gdVerifySelectedCheckbox</method>
Lines 370-376 Link Here
370		370
371	<toolkitComponent type="org.eclipse.swt.widgets.SwtTree">	371	<toolkitComponent type="org.eclipse.swt.widgets.SwtTree">
372	<realizes>org.eclipse.swt.widgets.Tree</realizes>	372	<realizes>org.eclipse.swt.widgets.Tree</realizes>
373	<testerClass>org.eclipse.jubula.rc.swt.implclasses.TableTreeImplClass</testerClass>	373	<testerClass>org.eclipse.jubula.rc.swt.caps.TreeCAPs</testerClass>
374	<componentClass name="org.eclipse.swt.widgets.Tree" />	374	<componentClass name="org.eclipse.swt.widgets.Tree" />
375	<action name="CompSystem.SelectByTextPathAtColumn" changed="1.22">	375	<action name="CompSystem.SelectByTextPathAtColumn" changed="1.22">
376	<method>gdSelect</method>	376	<method>gdSelect</method>
377	-

Lines 7-12 Bundle-Vendor: Eclipse Jubula Link Here

(-)a/org.eclipse.jubula.rc.common/META-INF/MANIFEST.MF (+3 lines)
7	Export-Package: org.eclipse.jubula.rc.common,	7	Export-Package: org.eclipse.jubula.rc.common,
8	org.eclipse.jubula.rc.common.adaptable,	8	org.eclipse.jubula.rc.common.adaptable,
9	org.eclipse.jubula.rc.common.businessprocess,	9	org.eclipse.jubula.rc.common.businessprocess,
		10	org.eclipse.jubula.rc.common.caps,
10	org.eclipse.jubula.rc.common.classloader,	11	org.eclipse.jubula.rc.common.classloader,
11	org.eclipse.jubula.rc.common.commands,	12	org.eclipse.jubula.rc.common.commands,
12	org.eclipse.jubula.rc.common.components,	13	org.eclipse.jubula.rc.common.components,
Lines 18-23 Export-Package: org.eclipse.jubula.rc.common, Link Here
18	org.eclipse.jubula.rc.common.listener,	19	org.eclipse.jubula.rc.common.listener,
19	org.eclipse.jubula.rc.common.logger,	20	org.eclipse.jubula.rc.common.logger,
20	org.eclipse.jubula.rc.common.registration,	21	org.eclipse.jubula.rc.common.registration,
		22	org.eclipse.jubula.rc.common.uiadapter.factory,
		23	org.eclipse.jubula.rc.common.uiadapter.interfaces,
21	org.eclipse.jubula.rc.common.util	24	org.eclipse.jubula.rc.common.util
22	Require-Bundle: org.apache.commons.beanutils;bundle-version="[1.7.0,2.0.0)",	25	Require-Bundle: org.apache.commons.beanutils;bundle-version="[1.7.0,2.0.0)",
23	org.apache.commons.lang;bundle-version="[2.4.0,3.0.0)",	26	org.apache.commons.lang;bundle-version="[2.4.0,3.0.0)",

Added Link Here

(-)a/org.eclipse.jubula.rc.common/src/org/eclipse/jubula/rc/common/caps/AbstractButtonCAPs.java (+83 lines)
1	/*******************************************************************************
2	* Copyright (c) 2012 BREDEX GmbH.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* BREDEX GmbH - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jubula.rc.common.caps;
12
13	import org.eclipse.jubula.rc.common.implclasses.MatchUtil;
14	import org.eclipse.jubula.rc.common.implclasses.Verifier;
15	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IButtonAdapter;
16
17
18	/**
19	* Implementation for all Button like classes, it holds the
20	* general methods for the testing of buttons.
21	*
22	* @author BREDEX GmbH
23	*
24	*/
25	public abstract class AbstractButtonCAPs extends AbstractWidgetCAPs {
26
27	/**
28	* Action to read the value of a JButton to store it in a variable in the
29	* Client
30	*
31	* @param variable the name of the variable
32	* @return the text value.
33	*/
34	public String gdReadValue(String variable) {
35	return ((IButtonAdapter) this.getComponent()).getText();
36	}
37	/**
38	*
39	* @return the IButtonAdapter for the component.
40	*/
41	private IButtonAdapter getButtonAdapter() {
42	return (IButtonAdapter)getComponent();
43	}
44
45	/**
46	* Verifies the selected property.
47	*
48	* @param selected The selected property value to verify.
49	*/
50	public void gdVerifySelected(boolean selected) {
51
52	Verifier.equals(selected, getButtonAdapter().isSelected());
53	}
54
55	/**
56	* Verifies the passed text.
57	*
58	* @param text The text to verify
59	* @param operator The RegEx operator used to verify
60	*/
61	public void gdVerifyText(String text, String operator) {
62	verifyText(text, operator);
63	}
64
65	/**
66	* Verifies the passed text.
67	*
68	* @param text The text to verify
69	*/
70	public void gdVerifyText(String text) {
71	gdVerifyText(text, MatchUtil.DEFAULT_OPERATOR);
72	}
73	/**
74	* Verifies the passed text.
75	* @param text The text to verify
76	* @param operator The operator used to verify
77	*/
78	public void verifyText(String text, String operator) {
79	String value = getButtonAdapter().getText();
80	Verifier.match(value, text, operator);
81	}
82
83	}

Lines 22-33 import org.eclipse.jubula.rc.common.AUTServer; Link Here

(-)a/org.eclipse.jubula.rc.swing/src/org/eclipse/jubula/rc/swing/SwingAUTServer.java (+7 lines)
22	import org.eclipse.jubula.rc.common.driver.IRobot;	22	import org.eclipse.jubula.rc.common.driver.IRobot;
23	import org.eclipse.jubula.rc.common.driver.IRobotFactory;	23	import org.eclipse.jubula.rc.common.driver.IRobotFactory;
24	import org.eclipse.jubula.rc.common.listener.BaseAUTListener;	24	import org.eclipse.jubula.rc.common.listener.BaseAUTListener;
		25	import org.eclipse.jubula.rc.common.uiadapter.factory.GUIAdapterFactoryRegistry;
25	import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig;	26	import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig;
26	import org.eclipse.jubula.rc.swing.listener.CheckListener;	27	import org.eclipse.jubula.rc.swing.listener.CheckListener;
27	import org.eclipse.jubula.rc.swing.listener.ComponentHandler;	28	import org.eclipse.jubula.rc.swing.listener.ComponentHandler;
28	import org.eclipse.jubula.rc.swing.listener.FocusTracker;	29	import org.eclipse.jubula.rc.swing.listener.FocusTracker;
29	import org.eclipse.jubula.rc.swing.listener.MappingListener;	30	import org.eclipse.jubula.rc.swing.listener.MappingListener;
30	import org.eclipse.jubula.rc.swing.listener.RecordListener;	31	import org.eclipse.jubula.rc.swing.listener.RecordListener;
		32	import org.eclipse.jubula.rc.swing.swing.uiadapter.factory.SwingAdapterFactory;
31	import org.eclipse.jubula.tools.constants.AUTServerExitConstants;	33	import org.eclipse.jubula.tools.constants.AUTServerExitConstants;
32	import org.eclipse.jubula.tools.constants.DebugConstants;	34	import org.eclipse.jubula.tools.constants.DebugConstants;
33	import org.eclipse.jubula.tools.utils.EnvironmentUtils;	35	import org.eclipse.jubula.tools.utils.EnvironmentUtils;
Lines 220-225 public class SwingAUTServer extends AUTServer { Link Here
220	}	222	}
221		223
222	AUTServer.getInstance().invokeAUT();	224	AUTServer.getInstance().invokeAUT();
		225
		226	// FIXME dont know where to put
		227	GUIAdapterFactoryRegistry.getInstance().
		228	registerFactory(new SwingAdapterFactory());
		229	System.out.println("AdapterFactory registered"); //$NON-NLS-1$
223	}	230	}
224		231
225	/**	232	/**

Lines 27-33 Link Here

(-)a/org.eclipse.jubula.toolkit.provider.swing/resources/xml/ComponentConfiguration.xml (-5 / +5 lines)
27		27
28	<toolkitComponent type="javax.swing.AbstractButton" visible="false">	28	<toolkitComponent type="javax.swing.AbstractButton" visible="false">
29	<realizes>guidancer.concrete.Button</realizes>	29	<realizes>guidancer.concrete.Button</realizes>
30	<testerClass>org.eclipse.jubula.rc.swing.swing.implclasses.AbstractButtonImplClass</testerClass>	30	<testerClass>org.eclipse.jubula.rc.swing.swing.caps.AbstractButtonCAPs</testerClass>
31	<componentClass name="javax.swing.AbstractButton" />	31	<componentClass name="javax.swing.AbstractButton" />
32	</toolkitComponent>	32	</toolkitComponent>
33		33
Lines 36-48 Link Here
36	<typeFactory>org.eclipse.jubula.rc.common.implclasses.DefaultComponentFactory</typeFactory>	36	<typeFactory>org.eclipse.jubula.rc.common.implclasses.DefaultComponentFactory</typeFactory>
37	</defaultMapping>	37	</defaultMapping>
38	<realizes>guidancer.concrete.MenuBar</realizes>	38	<realizes>guidancer.concrete.MenuBar</realizes>
39	<testerClass>org.eclipse.jubula.rc.swing.swing.implclasses.JMenuBarImplClass</testerClass>	39	<testerClass>org.eclipse.jubula.rc.swing.swing.caps.JMenuBarCAPs</testerClass>
40	<componentClass name="com.bredexsw.guidancer.autserver.swing.implclasses.JMenuBarDefaultMapping" />	40	<componentClass name="com.bredexsw.guidancer.autserver.swing.implclasses.JMenuBarDefaultMapping" />
41	</toolkitComponent>	41	</toolkitComponent>
42		42
43	<toolkitComponent type="javax.swing.JComboBox" visible="false">	43	<toolkitComponent type="javax.swing.JComboBox" visible="false">
44	<realizes>guidancer.concrete.ComboBox</realizes>	44	<realizes>guidancer.concrete.ComboBox</realizes>
45	<testerClass>org.eclipse.jubula.rc.swing.swing.implclasses.JComboBoxImplClass</testerClass>	45	<testerClass>org.eclipse.jubula.rc.swing.swing.caps.JComboBoxCAPs</testerClass>
46	<componentClass name="javax.swing.JComboBox" />	46	<componentClass name="javax.swing.JComboBox" />
47	</toolkitComponent>	47	</toolkitComponent>
48		48
Lines 66-72 Link Here
66		66
67	<toolkitComponent type="javax.swing.JTable" visible="false">	67	<toolkitComponent type="javax.swing.JTable" visible="false">
68	<realizes>guidancer.concrete.Table</realizes>	68	<realizes>guidancer.concrete.Table</realizes>
69	<testerClass>org.eclipse.jubula.rc.swing.swing.implclasses.JTableImplClass</testerClass>	69	<testerClass>org.eclipse.jubula.rc.swing.swing.caps.JTableCAPs</testerClass>
70	<componentClass name="javax.swing.JTable" />	70	<componentClass name="javax.swing.JTable" />
71	</toolkitComponent>	71	</toolkitComponent>
72		72
Lines 78-84 Link Here
78		78
79	<toolkitComponent type="javax.swing.JTree" visible="false">	79	<toolkitComponent type="javax.swing.JTree" visible="false">
80	<realizes>guidancer.concrete.Tree</realizes>	80	<realizes>guidancer.concrete.Tree</realizes>
81	<testerClass>org.eclipse.jubula.rc.swing.swing.implclasses.JTreeImplClass</testerClass>	81	<testerClass>org.eclipse.jubula.rc.swing.swing.caps.JTreeCAPs</testerClass>
82	<componentClass name="javax.swing.JTree" />	82	<componentClass name="javax.swing.JTree" />
83	</toolkitComponent>	83	</toolkitComponent>
84		84