Attachment #223948 for bug #394179

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




 * @author BREDEX GmbH
 *
 */
public abstract class AbstractButtonCAPs extends AbstractTextVerifiable {

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


        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.
     * 

    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.Arrays;

import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
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.exception.StepExecutionException;
import org.eclipse.jubula.rc.common.implclasses.IndexConverter;
import org.eclipse.jubula.rc.common.implclasses.ListSelectionVerifier;
import org.eclipse.jubula.rc.common.implclasses.MatchUtil;
import org.eclipse.jubula.rc.common.implclasses.Verifier;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IListAdapter;
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;

/**
 * 
 * @author BREDEX GmbH
 *
 */
public abstract class AbstractListCAPs extends AbstractTextVerifiable {

    /** The default separator for enumerations of list values. */
    public static final char INDEX_LIST_SEP_CHAR = 
        TestDataConstants.VALUE_CHAR_DEFAULT; 
    //FIXME this should be in an upper class or Util
    /** The default separator of a list of values */
    public static final char VALUE_SEPARATOR = 
        TestDataConstants.VALUE_CHAR_DEFAULT;
    
    /**
     * Splits the enumeration of values.
     * @param values The values to split
     * @param separator The separator, may be <code>null</code>
     * @return The array of values
     */
    private String[] split(String values, String separator) {
        String[] list = StringParsing.splitToArray(values, ((separator == null)
            || (separator.length() == 0) ? INDEX_LIST_SEP_CHAR
                : separator.charAt(0)),
            TestDataConstants.ESCAPE_CHAR_DEFAULT);
        list = StringUtils.stripAll(list);
        return list;
    }
    
    /**
     * @return The array of selected indices
     * @throws StepExecutionException If there are no indices selected
     */
    private int[] getCheckedSelectedIndices() throws StepExecutionException {
        int[] selected = getListAdapter().getSelectedIndices();
        if (selected.length == 0) {
            throw new StepExecutionException("No list element selected", //$NON-NLS-1$
                EventFactory.createActionError(TestErrorEvent.NO_SELECTION));
        }
        return selected;
    }

    /**
     * 
     * @return the List Adapter
     */
    private IListAdapter getListAdapter() {
        return ((IListAdapter) getComponent());
    }
    
    /**
     * Verifies if the passed index is selected.
     * 
     * @param index The index to verify
     * @param expectSelected Whether the index should be selected.
     */
    public void gdVerifySelectedIndex(String index, boolean expectSelected) {
        int[] selected = getCheckedSelectedIndices();
        int implIndex = IndexConverter.toImplementationIndex(
                Integer.parseInt(index));

        boolean isSelected = ArrayUtils.contains(selected, implIndex);
        if (expectSelected != isSelected) {
            throw new StepExecutionException(
                    "Selection check failed for index: " + index,  //$NON-NLS-1$
                    EventFactory.createVerifyFailed(
                            String.valueOf(expectSelected), 
                            String.valueOf(isSelected)));
        }
    }
    
    /**
     * Verifies if the passed value or enumeration of values is selected. By
     * default, the enumeration separator is <code>,</code>
     * @param valueList The value or list of values to verify
     */
    public void gdVerifySelectedValue(String valueList) {
        gdVerifySelectedValue(valueList, MatchUtil.DEFAULT_OPERATOR, true);
    }
    
    /**
     * Verifies if the passed value is selected.
     * 
     * @param value The value to verify
     * @param operator The operator to use when comparing the 
     *                 expected and actual values.
     *  @param isSelected if the value should be selected or not.
     */
    public void gdVerifySelectedValue(String value, String operator,
            boolean isSelected) {

        final String[] current = getListAdapter().getSelectedValues();
        final ListSelectionVerifier listSelVerifier =
            new ListSelectionVerifier();
        for (int i = 0; i < current.length; i++) {
            listSelVerifier.addItem(i, current[i], true);
        }
        listSelVerifier.verifySelection(value, operator, isSelected);
    }
    
    /**
     * Verifies if all selected elements of a list match a text.
     * @param text The text to verify
     * @param operator The operator used to verify
     */
    public void gdVerifyText(String text, String operator) {
        String[] selected = getListAdapter().getSelectedValues();
        final int selCount = selected.length;
        if (selCount < 1) {
            throw new StepExecutionException("No selection", //$NON-NLS-1$
                EventFactory.createActionError(TestErrorEvent.NO_SELECTION));
        }
        for (int i = 0; i < selCount; i++) {
            Verifier.match(selected[i], text, operator);
        }
    }
    
    /**
     * Selects the passed index or enumeration of indices. The enumeration must
     * be separated by <code>,</code>, e.g. <code>1, 3,6</code>.
     * @param indexList The index or indices to select
     * @param extendSelection Whether this selection extends a previous 
     *                        selection.
     * @param button what mouse button should be used
     */
    public void gdSelectIndex(String indexList, final String extendSelection,
            int button) {
        final boolean isExtendSelection = extendSelection
                .equals(CompSystemConstants.EXTEND_SELECTION_YES);
        selectIndices(IndexConverter
                .toImplementationIndices(parseIndices(indexList)), ClickOptions
                .create().setClickCount(1).setMouseButton(button),
                isExtendSelection);
    }
    
    /**
     * Selects the passed value or enumeration of values. By default, the
     * enumeration separator is <code>,</code>.
     * @param valueList The value or list of values to select
     * @param operator If regular expressions are used
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param extendSelection Whether this selection extends a previous 
     *                          selection. If <code>true</code>, the first 
     *                          element will be selected with CONTROL as a 
     *                          modifier.
     * @param button what mouse button should be used
     */
    public void gdSelectValue(String valueList, String operator, 
            String searchType, final String extendSelection, int button) {
        final boolean isExtendSelection = 
            extendSelection.equals(CompSystemConstants.EXTEND_SELECTION_YES);
        selectValue(valueList, String.valueOf(VALUE_SEPARATOR), operator, 
            searchType, ClickOptions.create()
                .setClickCount(1)
                .setMouseButton(button), isExtendSelection); 
    }
    
    /**
     * Selects the passed value or enumeration of values. By default, the
     * enumeration separator is <code>,</code>, but may be changed by
     * <code>separator</code>.
     * @param valueList The value or list of values to select
     * @param separator The separator, optional
     * @param operator If regular expressions are used
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param clickCount the amount of clicks to use
     * @param extendSelection Whether this selection extends a previous 
     *                        selection.
     */
    public void gdSelectValue(String valueList, String separator,
            String operator, final String searchType, int clickCount, 
            final String extendSelection) {
        final boolean isExtendSelection = 
            extendSelection.equals(CompSystemConstants.EXTEND_SELECTION_YES);
        selectValue(valueList, separator, operator, searchType, ClickOptions
                .create().setClickCount(clickCount), isExtendSelection);
    }
    
    /**
     * Verifies if the list contains an element that renderes <code>value</code>.
     * @param value The text to verify
     */
    public void gdVerifyContainsValue(String value) {
        Verifier.equals(true, containsValue(value));
    }

    /**
     * Verifies if the list contains an element that renderes <code>value</code>.
     * @param value The text to verify
     * @param operator The operator used to verify
     * @param exists if the wanted value should exist or not.
     */
    public void gdVerifyContainsValue(String value, String operator,
            boolean exists) {

        Verifier.equals(exists, containsValue(value, operator));
    }
    
    /**
     * Action to read the value of the current selected item of the JList
     * 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) {
        String[] selected = getListAdapter().getSelectedValues();
        if (selected.length > 0) {
            return selected[0];
        }
        throw new StepExecutionException("No list item selected", //$NON-NLS-1$
            EventFactory.createActionError(TestErrorEvent.NO_SELECTION));
    }
    
    /**
     * Drags the passed value.
     *
     * @param mouseButton the mouseButton.
     * @param modifier the modifier.
     * @param value The value to drag
     * @param operator If regular expressions are used
     * @param searchType Determines where the search begins ("relative" or "absolute")
     */
    public void gdDragValue(int mouseButton, String modifier, String value,
            String operator, final String searchType) {

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

        Integer [] indices = getListAdapter().findIndicesOfValues(
            new String [] {value}, operator, searchType);
        selectIndices(ArrayUtils.toPrimitive(indices), 
                ClickOptions.create().setClickCount(0), false);

        pressOrReleaseModifiers(modifier, true);
        getRobot().mousePress(null, null, mouseButton);
    }

    /**
     * Drops on the passed value.
     *
     * @param value The value on which to drop
     * @param operator If regular expressions are used
     * @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 gdDropValue(String value, String operator,
        final String searchType, int delayBeforeDrop) {

        DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
        try {
            Integer [] indices = getListAdapter().findIndicesOfValues(
                new String [] {value}, operator, searchType);
            selectIndices(ArrayUtils.toPrimitive(indices), 
                    ClickOptions.create().setClickCount(0), false);
            waitBeforeDrop(delayBeforeDrop);
        } finally {
            getRobot().mouseRelease(null, null, dndHelper.getMouseButton());
            pressOrReleaseModifiers(dndHelper.getModifier(), false);
        }
    }

    /**
     * Drags the passed index.
     *
     * @param mouseButton the mouseButton.
     * @param modifier the modifier.
     * @param index The index to drag
     */
    public void gdDragIndex(final int mouseButton, final String modifier,
            int index) {

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

        selectIndices(
                new int [] {IndexConverter.toImplementationIndex(index)}, 
                ClickOptions.create().setClickCount(0), false);

        pressOrReleaseModifiers(modifier, true);
        getRobot().mousePress(null, null, mouseButton);
    }

    /**
     * Drops onto the passed index.
     *
     * @param index The index on which to drop
     * @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 gdDropIndex(final int index, int delayBeforeDrop) {

        DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();

        try {
            selectIndices(
                    new int [] {IndexConverter.toImplementationIndex(index)}, 
                    ClickOptions.create().setClickCount(0), false);
            waitBeforeDrop(delayBeforeDrop);
        } finally {
            getRobot().mouseRelease(null, null, dndHelper.getMouseButton());
            pressOrReleaseModifiers(dndHelper.getModifier(), false);
        }
    }

    /**
     * @param value The value
     * @return <code>true</code> if the list contains an element that is rendered with <code>value</code>
     */
    public boolean containsValue(String value) {
        Integer[] indices = getListAdapter().findIndicesOfValues(
                new String[] { value },
                MatchUtil.EQUALS, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
        return indices.length > 0;
    }
    
    /**
     * @param value The value
     * @param operator The operator used to verify
     * @return <code>true</code> if the list contains an element that is rendered with <code>value</code>
     */
    public boolean containsValue(String value, String operator) {
        Integer[] indices = null;
        if (operator.equals(MatchUtil.NOT_EQUALS)) {
            indices = getListAdapter().findIndicesOfValues(
                    new String[] { value },
                MatchUtil.EQUALS, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
            return indices.length == 0;
        } 
        indices = getListAdapter().findIndicesOfValues(new String[] { value },
            operator, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
        return indices.length > 0;
    }
    
    /**
     * Selects the passed value or enumeration of values. By default, the
     * enumeration separator is <code>,</code>, but may be changed by
     * <code>separator</code>.
     * @param valueList The value or list of values to select
     * @param separator The separator, optional
     * @param operator If regular expressions are used
     * @param searchType Determines where the search begins ("relative" or "absolute")
     * @param co the click options to use
     * @param isExtendSelection Whether this selection extends a previous 
     *                        selection.
     */
    private void selectValue(String valueList, String separator,
            String operator, final String searchType, ClickOptions co, 
            final boolean isExtendSelection) {

        String[] values = null;
        if (StringConstants.EMPTY.equals(valueList)) {
            values = new String[1];
            values[0] = StringConstants.EMPTY;
        } else {
            values = split(valueList, separator);
        }
        Integer[] indices = getListAdapter().findIndicesOfValues(values,
                operator, searchType);
        Arrays.sort(indices);
        if (!operator.equals(MatchUtil.NOT_EQUALS) 
                && (indices.length < values.length)) {
            throw new StepExecutionException("One or more values not found of set: " //$NON-NLS-1$
                + Arrays.asList(values).toString(),
                EventFactory.createActionError(TestErrorEvent.NOT_FOUND));
        }
        selectIndices(ArrayUtils.toPrimitive(indices), co, isExtendSelection);
    }
    
    /**
     * Parses the enumeration of indices.
     * @param indexList The enumeration of indices
     * @return The array of parsed indices
     */
    private int[] parseIndices(String indexList) {
        String[] list = StringParsing.splitToArray(indexList,
                INDEX_LIST_SEP_CHAR, TestDataConstants.ESCAPE_CHAR_DEFAULT);
        int[] indices = new int[list.length];
        for (int i = 0; i < list.length; i++) {
            indices[i] = IndexConverter.intValue(list[i]);
        }
        return indices;
    }
    
    /**
     * @param indices The indices to select
     * @param co the click options to use
     * @param isExtendSelection Whether this selection extends a previous 
     *                          selection. If <code>true</code>, the first 
     *                          element will be selected with CONTROL as a 
     *                          modifier.
     */
    private void selectIndices(int[] indices, ClickOptions co, 
            boolean isExtendSelection) {
        Object list = getListAdapter().getRealComponent();
        if (indices.length > 0) {
            try {
                if (isExtendSelection) {
                    getRobot().keyPress(list,
                            getSystemDefaultModifier());
                }

                // first selection
                getListAdapter().clickOnIndex(
                        new Integer(indices[0]), co);
            } finally {
                if (isExtendSelection) {
                    getRobot().keyRelease(list,
                            getSystemDefaultModifier());
                }
            }
        }
        try {
            getRobot().keyPress(list,
                    getSystemDefaultModifier());
            // following selections
            for (int i = 1; i < indices.length; i++) {
                getListAdapter().clickOnIndex(
                        new Integer(indices[i]), co);
            }
        } finally {
            getRobot().keyRelease(list,
                    getSystemDefaultModifier());
        }
    }
    
    /**
     * {@inheritDoc}
     */
    public String[] getTextArrayFromComponent() {
        return null;
    }
    
    /**
     * 
     * @return -
     */
    protected abstract int getSystemDefaultModifier();
    
}




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.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.

                co, extendSelection);
        
    }
//FIXME    
//    /**
//     * 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

        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.

        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

     */
    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);
    }
}

Lines 11-16 Link Here

(-)a/org.eclipse.jubula.rc.common/src/org/eclipse/jubula/rc/common/caps/AbstractTextVerifiable.java (-5 / +10 lines)
11	package org.eclipse.jubula.rc.common.caps;	11	package org.eclipse.jubula.rc.common.caps;
12		12
13	import org.eclipse.jubula.rc.common.exception.StepExecutionException;	13	import org.eclipse.jubula.rc.common.exception.StepExecutionException;
		14	import org.eclipse.jubula.rc.common.implclasses.Verifier;
		15	import org.eclipse.jubula.rc.common.uiadapter.interfaces.ITextVerifiable;
14		16
15	/**	17	/**
16	* This class represents the general implementation for components	18	* This class represents the general implementation for components
Lines 27-34 public abstract class AbstractTextVerifiable extends AbstractWidgetCAPs { Link Here
27	* @param variable the name of the variable	29	* @param variable the name of the variable
28	* @return the text value.	30	* @return the text value.
29	*/	31	*/
30	public abstract String gdReadValue(String variable);	32	public String gdReadValue(String variable) {
31	// FIXME this is only a pattern because only Tables uses this at the moment	33	return ((ITextVerifiable)getComponent()).getText();
		34	}
32		35
33	/**	36	/**
34	* Verifies the rendered text inside the currently component.<br>	37	* Verifies the rendered text inside the currently component.<br>
Lines 37-43 public abstract class AbstractTextVerifiable extends AbstractWidgetCAPs { Link Here
37	* @param operator The operation used to verify	40	* @param operator The operation used to verify
38	* @throws StepExecutionException If the rendered text cannot be extracted.	41	* @throws StepExecutionException If the rendered text cannot be extracted.
39	*/	42	*/
40	public abstract void gdVerifyText(String text, String operator)	43	public void gdVerifyText(String text, String operator)
41	throws StepExecutionException;	44	throws StepExecutionException {
42	// FIXME this is only a pattern because only Tables uses this at the moment	45	Verifier.match(((ITextVerifiable)getComponent()).getText(), text,
		46	operator);
		47	}
43	}	48	}

Lines 27-39 import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter; Link Here

(-)a/org.eclipse.jubula.rc.common/src/org/eclipse/jubula/rc/common/caps/AbstractUICAPs.java (-3 / +8 lines)
27	*/	27	*/
28	public abstract class AbstractUICAPs implements IBaseImplementationClass {	28	public abstract class AbstractUICAPs implements IBaseImplementationClass {
29		29
30
31
32	/** constants for communication */	30	/** constants for communication */
33	protected static final String POS_UNIT_PIXEL = "Pixel"; //$NON-NLS-1$	31	protected static final String POS_UNIT_PIXEL = "Pixel"; //$NON-NLS-1$
34		32
35	/** constants for communication */	33	/** constants for communication */
36	protected static final String POS_UNI_PERCENT = "Percent"; //$NON-NLS-1$	34	protected static final String POS_UNI_PERCENT = "Percent"; //$NON-NLS-1$
		35
		36	/** */
		37	private IRobotFactory m_robotFactory;
		38
37	/** */	39	/** */
38	private IComponentAdapter m_component;	40	private IComponentAdapter m_component;
39		41
Lines 50-56 public abstract class AbstractUICAPs implements IBaseImplementationClass { Link Here
50	* Gets the Robot factory. The factory is created once per instance.	52	* Gets the Robot factory. The factory is created once per instance.
51	* @return The Robot factory.	53	* @return The Robot factory.
52	*/	54	*/
53	protected abstract IRobotFactory getRobotFactory();	55	protected IRobotFactory getRobotFactory() {
		56	m_robotFactory = m_component.getRobotFactory();
		57	return m_robotFactory;
		58	}
54		59
55	/**	60	/**
56	* {@inheritDoc}	61	* {@inheritDoc}

Lines 10-21 Link Here

(-)a/org.eclipse.jubula.rc.common/src/org/eclipse/jubula/rc/common/caps/AbstractWidgetCAPs.java (+45 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jubula.rc.common.caps;	11	package org.eclipse.jubula.rc.common.caps;
12		12
		13	import java.util.StringTokenizer;
		14
13	import org.eclipse.jubula.rc.common.CompSystemConstants;	15	import org.eclipse.jubula.rc.common.CompSystemConstants;
14	import org.eclipse.jubula.rc.common.driver.ClickOptions;	16	import org.eclipse.jubula.rc.common.driver.ClickOptions;
		17	import org.eclipse.jubula.rc.common.driver.IRobot;
15	import org.eclipse.jubula.rc.common.driver.ClickOptions.ClickModifier;	18	import org.eclipse.jubula.rc.common.driver.ClickOptions.ClickModifier;
16	import org.eclipse.jubula.rc.common.exception.StepExecutionException;	19	import org.eclipse.jubula.rc.common.exception.StepExecutionException;
17	import org.eclipse.jubula.rc.common.implclasses.Verifier;	20	import org.eclipse.jubula.rc.common.implclasses.Verifier;
18	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IWidgetAdapter;	21	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IWidgetAdapter;
		22	import org.eclipse.jubula.rc.common.util.KeyStrokeUtil;
		23	import org.eclipse.jubula.tools.utils.TimeUtil;
19	/**	24	/**
20	* Implementation of basic functions for a lot of graphics components	25	* Implementation of basic functions for a lot of graphics components
21	* except for context menus and menus.	26	* except for context menus and menus.
Lines 482-486 public abstract class AbstractWidgetCAPs extends AbstractUICAPs { Link Here
482	getWidgetAdapter().showToolTip(text, textSize,	487	getWidgetAdapter().showToolTip(text, textSize,
483	timePerWord, windowWidth);	488	timePerWord, windowWidth);
484	}	489	}
		490
		491	/**
		492	* Presses or releases the given modifier.
		493	* @param modifier the modifier.
		494	* @param press if true, the modifier will be pressed.
		495	* if false, the modifier will be released.
		496	*/
		497	protected void pressOrReleaseModifiers(String modifier, boolean press) {
		498	final IRobot robot = getRobot();
		499	final StringTokenizer modTok = new StringTokenizer(
		500	KeyStrokeUtil.getModifierString(modifier), " "); //$NON-NLS-1$
		501	while (modTok.hasMoreTokens()) {
		502	final String mod = modTok.nextToken();
		503	final int keyCode = getKeyCode(mod);
		504	if (press) {
		505	robot.keyPress(null, keyCode);
		506	} else {
		507	robot.keyRelease(null, keyCode);
		508	}
		509	}
		510	}
		511
		512	/**
		513	* Gets the key code for a specific modifier
		514	* @param mod the modifier
		515	* @return the integer key code value
		516	*/
		517	protected int getKeyCode(String mod) {
		518	return getWidgetAdapter().getKeyCode(mod);
		519	}
485		520
		521	/**
		522	* Waits the given amount of time. Logs a drop-related error if interrupted.
		523	*
		524	* @param delayBeforeDrop the amount of time (in milliseconds) to wait
		525	* between moving the mouse to the drop point and
		526	* releasing the mouse button
		527	*/
		528	public static void waitBeforeDrop(int delayBeforeDrop) {
		529	TimeUtil.delay(delayBeforeDrop);
		530	}
486	}	531	}




 * @author BREDEX GmbH
 */

public interface IButtonAdapter extends ITextVerifiable {
    /**
     * Gets the text from the button
     * @return the text which is saved in the component

     * @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);
   
}

Lines 9-14 Link Here

(-)a/org.eclipse.jubula.rc.common/src/org/eclipse/jubula/rc/common/uiadapter/interfaces/IComponentAdapter.java (+9 lines)
9	* BREDEX GmbH - initial API and implementation	9	* BREDEX GmbH - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jubula.rc.common.uiadapter.interfaces;	11	package org.eclipse.jubula.rc.common.uiadapter.interfaces;
		12
		13	import org.eclipse.jubula.rc.common.driver.IRobotFactory;
		14
12	/**	15	/**
13	* This is the main interface for classes which will hold or be the	16	* This is the main interface for classes which will hold or be the
14	* component that implement the methods we need for this	17	* component that implement the methods we need for this
Lines 22-26 public interface IComponentAdapter { Link Here
22	* @return toolkit specific component	25	* @return toolkit specific component
23	*/	26	*/
24	public Object getRealComponent();	27	public Object getRealComponent();
		28
		29	/**
		30	* Gets the toolkit specific RobotFactory
		31	* @return the RobotFactory
		32	*/
		33	public IRobotFactory getRobotFactory();
25		34
26	}	35	}




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

/**
 * 
 * @author BREDEX GmbH
 *
 */
public interface IListAdapter extends ITextVerifiable {
    /**
     * 
     * @return The array of selected indices
     */
    public int[] getSelectedIndices();

    /**
     * Clicks on the index of the passed list.
     * @param i The index to click
     * @param co the click options to use for selecting an index item
     */
    public void clickOnIndex(Integer i, ClickOptions co);
    
    /**
     * @return The array of selected values as the renderer shows them
     */
    public String[] getSelectedValues();
    
    /**
     * Finds the indices of the list elements that are rendered with the passed values.
     * @param values The values
     * @param operator operator to use
     * @param searchType 
     *            Determines where the search begins ("relative" or "absolute")
     * @return The array of indices. It's length is equal to the length of the
     *         values array, but may contains <code>null</code> elements for
     *         all values that are not found in the list
     */
    public Integer[] findIndicesOfValues(final String[] values,
        final String operator, final String searchType);

}

Lines 20-26 import org.eclipse.jubula.rc.common.implclasses.table.Cell; Link Here

(-)a/org.eclipse.jubula.rc.common/src/org/eclipse/jubula/rc/common/uiadapter/interfaces/ITableAdapter.java (-1 / +1 lines)
20	*	20	*
21	* @author BREDEX GmbH	21	* @author BREDEX GmbH
22	*/	22	*/
23	public interface ITableAdapter extends IWidgetAdapter {	23	public interface ITableAdapter extends ITextVerifiable {
24		24
25		25
26	/**	26	/**




package org.eclipse.jubula.rc.common.uiadapter.interfaces;
/**
 * 
 * @author BREDEX GmbH
 *
 */
public interface ITextVerifiable extends IWidgetAdapter {

    /**
     * Gets the value of the component, or if there are more
     * than the first selected.
     * @return the value of the component
     */
    public String getText();
}

Lines 106-110 public interface IWidgetAdapter extends IComponentAdapter { Link Here

(-)a/org.eclipse.jubula.rc.common/src/org/eclipse/jubula/rc/common/uiadapter/interfaces/IWidgetAdapter.java (+7 lines)
106	*/	106	*/
107	public void gdDrop(int xPos, String xUnits, int yPos, String yUnits,	107	public void gdDrop(int xPos, String xUnits, int yPos, String yUnits,
108	int delayBeforeDrop);	108	int delayBeforeDrop);
		109
		110	/**
		111	* Gets the key code for a specific modifier
		112	* @param mod the modifier
		113	* @return the integer key code value
		114	*/
		115	public int getKeyCode(String mod);
109		116
110	}	117	}




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

public class AbstractButtonCAPs 
    extends org.eclipse.jubula.rc.common.caps.AbstractButtonCAPs {

    /** Robot Factory*/
    private IRobotFactory m_robotFactory;

    /**
     * Clicks the button <code>count</code> times.
     * 

        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 org.eclipse.jubula.rc.common.caps.AbstractListCAPs;
import org.eclipse.jubula.rc.swing.utils.SwingUtils;
/**
 * 
 * @author BREDEX GmbH
 *
 */
public class JListCAPs extends AbstractListCAPs {
        
    /**
     * {@inheritDoc}
     */
    protected int getSystemDefaultModifier() {
        return SwingUtils.getSystemDefaultModifier();
    }
    
}




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;


 * 
 * @author BREDEX GmbH
 */
public class JMenuBarCAPs extends AbstractMenuCAPs {
            
    
    /** The robot factory.  */
    private IRobotFactory m_robotFactory;
    /**
     * {@inheritDoc}
     */
    protected IRobotFactory getRobotFactory() {
        if (m_robotFactory == null) {
            m_robotFactory = new RobotFactoryConfig().getRobotFactory();
        }
        return m_robotFactory;
    }
        
    /**
     * {@inheritDoc}
     */




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>

    private static AutServerLogger log = new AutServerLogger(
            JTableCAPs.class);

    /** the RobotFactory from the AUT */
    private IRobotFactory m_robotFactory;
    
    /**
     * @return the log
     */

        return log;
    }    

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

                });
    }


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

}




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>
 * 

 */
public class JTreeCAPs extends AbstractTreeCAPs {

   
    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}
     */

    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.




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

import org.eclipse.jubula.rc.common.driver.IRobotFactory;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;
import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig;
/**
 * 
 * @author BREDEX GmbH
 *
 */
public abstract class AbstractComponentAdapter implements IComponentAdapter {

    /** the RobotFactory from the AUT */
    private IRobotFactory m_robotFactory;
    
    /**
     * Gets the Robot factory. The factory is created once per instance.
     *
     * @return The Robot factory.
     */
    public 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.uiadapter;

import java.awt.Component;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.util.HashSet;
import java.util.Set;

import javax.swing.JList;
import javax.swing.ListCellRenderer;
import javax.swing.ListModel;

import org.eclipse.jubula.rc.common.CompSystemConstants;
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.MatchUtil;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IListAdapter;
import org.eclipse.jubula.rc.swing.swing.caps.CapUtil;
import org.eclipse.jubula.rc.swing.swing.implclasses.JComboBoxImplClass;
import org.eclipse.jubula.tools.objects.event.EventFactory;
import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
/**
 * 
 * @author BREDEX GmbH
 *
 */
public class JListAdapter extends WidgetAdapter implements IListAdapter {
    /** */
    private JList m_list;
    
    /**
     * 
     * @param objectToAdapt 
     */
    public JListAdapter(Object objectToAdapt) {
        super(objectToAdapt);
        m_list = (JList) objectToAdapt;
    }
    
    /**
     * {@inheritDoc}
     */
    public String getText() {
        String[] selected = getSelectedValues();
        if (selected.length > 0) {
            return selected[0];
        }
        throw new StepExecutionException("No list item selected", //$NON-NLS-1$
            EventFactory.createActionError(TestErrorEvent.NO_SELECTION));
    }

    /**
     * {@inheritDoc}
     */
    public int[] getSelectedIndices() {
        return (int[])getEventThreadQueuer().invokeAndWait(
            "getSelectedIndices", new IRunnable() { //$NON-NLS-1$
                public Object run() {
                    return m_list.getSelectedIndices();
                }
            });
    }

    /**
     * Clicks on the index of the passed list.
     *
     * @param i The index to click
     * @param co the click options to use
     * @param maxWidth the maximal width which is used to select the item
     */
    public void clickOnIndex(final Integer i,
            ClickOptions co, double maxWidth) {
        final int index = i.intValue();
        ListModel model = m_list.getModel();
        if ((model == null) || (index >= model.getSize())
            || (index < 0)) {
            throw new StepExecutionException("List index '" + i //$NON-NLS-1$
                + "' is out of range", //$NON-NLS-1$
                EventFactory.createActionError(TestErrorEvent.INVALID_INDEX));
        }
        // Call of JList.ensureIndexIsVisible() is not required,
        // because the Robot scrolls the click rectangle to visible.
        Rectangle r = (Rectangle) getRobotFactory().getEventThreadQueuer()
                .invokeAndWait("getCellBounds", new IRunnable() { //$NON-NLS-1$

                    public Object run() throws StepExecutionException {
                        return m_list.getCellBounds(index, index);
                    }
                });        
        
        if (r == null) {
            throw new StepExecutionException(
                "List index '" + i + "' is not visible", //$NON-NLS-1$ //$NON-NLS-2$
                EventFactory.createActionError(TestErrorEvent.NOT_VISIBLE));
        }
        
        // if possible adjust height and width for items
        ListCellRenderer lcr = m_list.getCellRenderer();
        if (lcr != null) {
            Component listItem = lcr.getListCellRendererComponent(m_list, model
                    .getElementAt(index), index, false, false);
            Dimension preferredSize = listItem.getPreferredSize();
            r.setSize(preferredSize);
        }
        
        if (maxWidth != JComboBoxImplClass.NO_MAX_WIDTH
                && r.getWidth() > maxWidth) {
            Dimension d = new Dimension();
            d.setSize(maxWidth, r.getHeight());
            r.setSize(d);
        }

        getRobot().click(m_list, r,
                co.setClickType(ClickOptions.ClickType.RELEASED));
    }

    /**
     * {@inheritDoc}
     */
    public String[] getSelectedValues() {
        final int[] indices = getSelectedIndices();

        return (String[])getEventThreadQueuer().invokeAndWait(
            "getSelectedValues", new IRunnable() { //$NON-NLS-1$
                public Object run() {
                    Object[] values = m_list.getSelectedValues();
                    String[] selected = new String[values.length];
                    ListCellRenderer renderer = m_list.getCellRenderer();
                    for (int i = 0; i < values.length; i++) {
                        Object value = values[i];
                        Component c = renderer.getListCellRendererComponent(
                            m_list, value, indices[i], true, false);
                        selected[i] = CapUtil.getRenderedText(c);
                    }
                    return selected;
                }
            });
    }
    /**
     * {@inheritDoc}
     */
    public Integer[] findIndicesOfValues(
            final String[] values, final String  operator,
            final String searchType) {

        final Set indexSet = new HashSet();
        getEventThreadQueuer().invokeAndWait("findIndices", //$NON-NLS-1$
            new IRunnable() {
                public Object run() {
                    ListCellRenderer renderer = m_list.getCellRenderer();
                    ListModel model = m_list.getModel();
                    for (int i = getStartingIndex(searchType);
                            i < model.getSize(); ++i) {
                        Object obj = model.getElementAt(i);
                        m_list.ensureIndexIsVisible(i);
                        Component comp = renderer
                                .getListCellRendererComponent(
                            m_list, obj, i, false, false);
                        String str = CapUtil.getRenderedText(comp);
                        if (MatchUtil.getInstance().
                            match(str, values, operator)) {
                            indexSet.add(new Integer(i));
                        }
                    }
                    return null; // return value is not used
                }
            });

        Integer[] indices = new Integer[indexSet.size()];
        indexSet.toArray(indices);
        return indices;
    }
    
    /**
     * Finds the indices of the list elements that are rendered with the passed
     * values.
     *
     * @param values The values
     * @param operator operator to use
     * @return The array of indices. It's length is equal to the length of the
     *         values array, but may contains <code>null</code> elements for
     *         all values that are not found in the list
     */
    public Integer[] findIndicesOfValues(
        final String[] values, final String  operator) {

        return findIndicesOfValues(values, operator, 
                CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
    }
    
    /**
     * {@inheritDoc}
     */
    public boolean containsValue(String value, String operator) {
        Integer[] indices = null;
        if (operator.equals(MatchUtil.NOT_EQUALS)) {
            indices = findIndicesOfValues(new String[] { value },
                MatchUtil.EQUALS);
            return indices.length == 0;
        }
        indices = findIndicesOfValues(new String[] { value },
            operator);
        return indices.length > 0;
    }
    
    /**
     * Clicks on the index of the passed list.
     *
     * @param i
     *            The index to click
     * @param co the click options to use
     */
    public void clickOnIndex(final Integer i, ClickOptions co) {
        clickOnIndex(i, co, JComboBoxImplClass.NO_MAX_WIDTH);
    }

    /**
     * @param searchType Determines 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 getStartingIndex(final String searchType) {
        int startingIndex = 0;
        if (searchType.equalsIgnoreCase(
                CompSystemConstants.SEARCH_TYPE_RELATIVE)) {
            int [] selectedIndices = getSelectedIndices();
            // Start from the last selected item
            startingIndex = selectedIndices[selectedIndices.length - 1] + 1;
        }
        return startingIndex;
    }
}

Lines 28-34 import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter; Link Here

(-)a/org.eclipse.jubula.rc.swing/src/org/eclipse/jubula/rc/swing/swing/uiadapter/JMenuAdapter.java (-1 / +2 lines)
28	* @author BREDEX GmbH	28	* @author BREDEX GmbH
29	*	29	*
30	*/	30	*/
31	public class JMenuAdapter implements IMenuAdapter {	31	public class JMenuAdapter extends AbstractComponentAdapter
		32	implements IMenuAdapter {
32	/** The JMenu from the AUT */	33	/** The JMenu from the AUT */
33	private JMenu m_menu;	34	private JMenu m_menu;
34		35

Lines 28-34 import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter; Link Here

(-)a/org.eclipse.jubula.rc.swing/src/org/eclipse/jubula/rc/swing/swing/uiadapter/JMenuBarAdapter.java (-1 / +2 lines)
28	* @author BREDEX GmbH	28	* @author BREDEX GmbH
29	*	29	*
30	*/	30	*/
31	public class JMenuBarAdapter implements IMenuAdapter {	31	public class JMenuBarAdapter extends AbstractComponentAdapter
		32	implements IMenuAdapter {
32	/** The JMenuBar */	33	/** The JMenuBar */
33	private JMenuBar m_menuBar;	34	private JMenuBar m_menuBar;
34		35




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;


 * @author BREDEX GmbH
 * 
 */
public class JMenuItemAdapter extends AbstractComponentAdapter
    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.
     *

Lines 27-33 import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter; Link Here

(-)a/org.eclipse.jubula.rc.swing/src/org/eclipse/jubula/rc/swing/swing/uiadapter/JPopupMenuAdapter.java (-1 / +2 lines)
27	* @author BREDEX GmbH	27	* @author BREDEX GmbH
28	*	28	*
29	*/	29	*/
30	public class JPopupMenuAdapter implements IMenuAdapter {	30	public class JPopupMenuAdapter extends AbstractComponentAdapter
		31	implements IMenuAdapter {
31	/** */	32	/** */
32	private JPopupMenu m_contextMenu;	33	private JPopupMenu m_contextMenu;
33		34

Lines 374-377 public class JTableAdapter extends WidgetAdapter implements ITableAdapter { Link Here

(-)a/org.eclipse.jubula.rc.swing/src/org/eclipse/jubula/rc/swing/swing/uiadapter/JTableAdapter.java (+8 lines)
374	getRobot().scrollToVisible(m_table, bounds);	374	getRobot().scrollToVisible(m_table, bounds);
375	return bounds;	375	return bounds;
376	}	376	}
		377
		378	/**
		379	* {@inheritDoc}
		380	*/
		381	public String getText() {
		382	final Cell selectedCell = getSelectedCell();
		383	return getCellText(selectedCell.getRow(), selectedCell.getCol());
		384	}
377	}	385	}




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.driver.KeyCodeConverter;
import org.eclipse.jubula.rc.swing.swing.implclasses.EventListener;
import org.eclipse.jubula.tools.constants.TimeoutConstants;
import org.eclipse.jubula.tools.i18n.I18n;

 * 
 * @author BREDEX GmbH 
 */
public abstract class WidgetAdapter extends AbstractComponentAdapter
    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$
    

    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 IEventThreadQueuer.
     *
     * @return The Robot

                xPos, xUnits.equalsIgnoreCase(POS_UNIT_PIXEL),
                yPos, yUnits.equalsIgnoreCase(POS_UNIT_PIXEL));
    }
    
    /**
     * {@inheritDoc}
     */
    public int getKeyCode(String mod) {
        return KeyCodeConverter.getKeyCode(mod);
    }
}





import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JList;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;

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.JListAdapter;
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;

    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,
        JList.class};
    
    /**
     * {@inheritDoc}

        } else if (objectToAdapt instanceof JTable) {
            returnvalue = new JTableAdapter(objectToAdapt);
            
        } else if (objectToAdapt instanceof JList) {
            returnvalue = new JListAdapter(objectToAdapt);
            
        } else if (objectToAdapt instanceof JPopupMenu) {
            returnvalue = new JPopupMenuAdapter(objectToAdapt);
        






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;



 * @author BREDEX GmbH
 */
public class ButtonCAPs extends AbstractButtonCAPs {

    /** The robot factory. */
    private IRobotFactory m_robotFactory;
    
    /**
     * {@inheritDoc}
     */

                        ((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;
    }


}




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.

    }
    
    /**
     * 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.
     * 




/*******************************************************************************
 * 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.AbstractListCAPs;
import org.eclipse.jubula.rc.swt.utils.SwtUtils;
/**
 * 
 * @author BREDEX GmbH
 *
 */
public class ListCAPs extends AbstractListCAPs {


    /**
     * {@inheritDoc}
     */
    protected int getSystemDefaultModifier() {
        return SwtUtils.getSystemDefaultModifier();
    }

}




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.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;

 */
public class MenuCAPs extends AbstractMenuCAPs 
    implements IBaseImplementationClass {

    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 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




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;

 */
public class TableCAPs extends AbstractTableCAPs {
    
    /**  */
    private IRobotFactory m_robotFactory;

    /**
     *  Gets the real table component

        componentTextArray = getTextArrayFromItemArray(itemArray);         
        return componentTextArray;
    }

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

        
        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

                }            
            });

            waitBeforeDrop(delayBeforeDrop);
            
        } finally {
            robot.mouseRelease(dndHelper.getDragComponent(), null, 

                }            
            });
            
            waitBeforeDrop(delayBeforeDrop);
            
        } finally {
            robot.mouseRelease(dndHelper.getDragComponent(), null, 

                }            
            });

            waitBeforeDrop(delayBeforeDrop);
        
        } finally {
            robot.mouseRelease(dndHelper.getDragComponent(), null, 




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.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;

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

                    CompSystemConstants.EXTEND_SELECTION_NO);

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

                    CompSystemConstants.EXTEND_SELECTION_NO);

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




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

import org.eclipse.jubula.rc.common.driver.IRobotFactory;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;
import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;
/**
 * 
 * @author BREDEX GmBH
 *
 */
public abstract class AbstractComponentAdapter implements IComponentAdapter {

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

    /**
     * Gets the Robot factory. The factory is created once per instance.
     *
     * @return The Robot factory.
     */
    public 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.uiadapter;

import java.util.ArrayList;

import org.eclipse.jubula.rc.common.CompSystemConstants;
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.MatchUtil;
import org.eclipse.jubula.rc.common.uiadapter.interfaces.IListAdapter;
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.graphics.Rectangle;
import org.eclipse.swt.widgets.List;
/**
 * 
 * @author BREDEX GmbH
 *
 */
public class ListAdapter extends WidgetAdapter implements IListAdapter {

    /**  */
    private List m_list;
    /**
     * 
     * @param objectToAdapt -
     */
    public ListAdapter(Object objectToAdapt) {
        super(objectToAdapt);
        m_list = (List) objectToAdapt;
    }

    /**
     * {@inheritDoc}
     */
    public String getText() {
        String[] selected = getSelectedValues();
        if (selected.length > 0) {
            return selected[0];
        }
        throw new StepExecutionException("No list item selected", //$NON-NLS-1$
            EventFactory.createActionError(TestErrorEvent.NO_SELECTION));
    }
    
    /**
     * {@inheritDoc}
     */
    public int[] getSelectedIndices() {
        return (int[])getEventThreadQueuer().invokeAndWait(
                "getSelectedIndices", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_list.getSelectionIndices();
                    }
                });
    }
    /**
     * {@inheritDoc}
     */
    public void clickOnIndex(Integer i, ClickOptions co) {
        final int iVal = i.intValue();
        scrollIndexToVisible(iVal);
        
        final Rectangle clickConstraints = 
            (Rectangle)getEventThreadQueuer().invokeAndWait(
                "setClickConstraints",  //$NON-NLS-1$
                new IRunnable() {

                    public Object run() throws StepExecutionException {
                        Rectangle constraints = new Rectangle(0, 0, 0, 0);
                        int displayedItemCount = getDisplayedItemCount();
                        int numberBelowTop = 0;
                        if (displayedItemCount >= m_list.getItemCount()) {
                            numberBelowTop = iVal;
                        } else {
                            numberBelowTop = Math.max(0, iVal 
                                - m_list.getItemCount() + displayedItemCount);
                        }
                        
                        // Set the constraints based on the numberBelowTop
                        constraints.height = m_list.getItemHeight();
                        constraints.width = m_list.getBounds().width;
                        constraints.y += (numberBelowTop * constraints.height);
                        // explicitly use list relative bounds here - as e.g. on
                        // Mac OS systems list.getClientArea() is not relative
                        // see bug 353905
                        Rectangle actualListBounds =
                            new Rectangle(0, 0, m_list.getClientArea().width, 
                                    m_list.getClientArea().height);
                        return constraints.intersection(actualListBounds);
                    }
                });
        
        // Note that we set scrollToVisible false because we have already done
        // the scrolling.
        getRobot().click(m_list, clickConstraints, 
                co.setScrollToVisible(false));

    }
    /**
     * {@inheritDoc}
     */
    public String[] getSelectedValues() {
        return (String[])getEventThreadQueuer().invokeAndWait(
                "getSelectedValues", new IRunnable() { //$NON-NLS-1$
                    public Object run() {
                        return m_list.getSelection();
                    }
                });
    }
    /**
     * {@inheritDoc}
     */
    public Integer[] findIndicesOfValues(final String[] values,
            final String operator, final String searchType) {
        final java.util.List indexList = (java.util.List)
                getEventThreadQueuer().invokeAndWait("findIndices", //$NON-NLS-1$
                    new IRunnable() {
                        public Object run() {
                            final int valuesLength = values.length;
                            final java.util.List idxList = new ArrayList(
                                values.length);
                            final int listItemCount = m_list.getItemCount();
                            final MatchUtil matchUtil = MatchUtil.getInstance();
                            for (int i = 0; i < valuesLength; i++) {
                                final String value = values[i];
                                for (int j = getStartingIndex(searchType); 
                                    j < listItemCount; j++) {
                                    
                                    final String listItem = m_list.getItem(j);
                                    if (matchUtil.match(listItem, value, 
                                        operator)) {
                                        
                                        idxList.add(new Integer(j));
                                    }
                                }
                            }
                            return idxList;
                        }
                    });
        Integer[] indices = new Integer[indexList.size()];
        indexList.toArray(indices);
        return indices;
    }

    /**
     * @return  the number of items displayed in the list.
     */
    private int getDisplayedItemCount() {
        return ((Integer)getEventThreadQueuer().invokeAndWait(
                "getDisplayedItemCount",  //$NON-NLS-1$
                new IRunnable() {

                public Object run() throws StepExecutionException {
                    int listHeight = SwtUtils.getWidgetBounds(m_list).height;
                    int itemHeight = m_list.getItemHeight();
                    
                    return new Integer(listHeight / itemHeight);
                }
            
            })).intValue();
    }
    
    /**
     * @param index The index to make visible
     */
    private void scrollIndexToVisible(final int index) {
        getEventThreadQueuer().invokeAndWait(
            "scrollIndexToVisible",  //$NON-NLS-1$
            new IRunnable() {

                public Object run() throws StepExecutionException {
           
                    m_list.setTopIndex(index);

                    return null;
                }
            
            });
    }
    /**
     * @param searchType Determines 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 getStartingIndex(final String searchType) {
        int startingIndex = 0;
        if (searchType.equalsIgnoreCase(
                CompSystemConstants.SEARCH_TYPE_RELATIVE)) {
            int [] selectedIndices = getSelectedIndices();
            // Start from the last selected item, if any item(s) are selected
            if (selectedIndices.length > 0) {
                startingIndex = selectedIndices[selectedIndices.length - 1] + 1;
            }
        }
        return startingIndex;
    }
}





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;


 * 
 * @author BREDEX GmbH
 */
public class MenuAdapter extends AbstractComponentAdapter
    implements IMenuAdapter {
    /** the Menu from the AUT */
    private Menu m_menu;
    
    /** the RobotFactory from the AUT */
    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 IEventThreadQueuer.
     * 
     * @return The Robot




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.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;

 * 
 *  @author BREDEX GmbH
 */
public class MenuItemAdapter extends AbstractComponentAdapter
    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

    }
    
    /**
     * 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

Lines 523-526 public class TableAdapter extends WidgetAdapter implements ITableAdapter { Link Here

(-)a/org.eclipse.jubula.rc.swt/src/org/eclipse/jubula/rc/swt/uiadapter/TableAdapter.java (+8 lines)
523		523
524	return SwtUtils.getCursorControl();	524	return SwtUtils.getCursorControl();
525	}	525	}
		526
		527	/**
		528	* {@inheritDoc}
		529	*/
		530	public String getText() {
		531	final Cell selectedCell = getSelectedCell();
		532	return getCellText(selectedCell.getRow(), selectedCell.getCol());
		533	}
526	}	534	}




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

import org.eclipse.jubula.rc.common.caps.AbstractMenuCAPs;
import org.eclipse.jubula.rc.common.caps.AbstractWidgetCAPs;
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.driver.KeyCodeConverter;
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;

 * 
 *  @author BREDEX GmbH
 */
public abstract class WidgetAdapter extends AbstractComponentAdapter
    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;
    

        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
     *

                }            
            });
            
            AbstractWidgetCAPs.waitBeforeDrop(delayBeforeDrop);
        } finally {
            getRobot().mouseRelease(null, null, mouseButton);
            CAPUtil.pressOrReleaseModifiers(modifier, false);

                        button), xPos, xUnits.equalsIgnoreCase(POS_UNIT_PIXEL),
                yPos, yUnits.equalsIgnoreCase(POS_UNIT_PIXEL));
    }
    
    /**
     * {@inheritDoc}
     */
    public int getKeyCode(String mod) {
        return KeyCodeConverter.getKeyCode(mod);
    }
}




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.ListAdapter;
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.List;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Table;

    /** */
    private static final Class[] SUPPORTEDCLASSES = 
            new Class[]{Button.class, Menu.class, MenuItem.class, Tree.class,
                Table.class, List.class};
    
    
    /**

            returnvalue = new TreeAdapter(objectToAdapt);
        } else if (objectToAdapt instanceof Table) {
            returnvalue = new TableAdapter(objectToAdapt);
        } else if (objectToAdapt instanceof List) {
            returnvalue = new ListAdapter(objectToAdapt);
        }
        
        

Lines 48-54 Link Here

(-)a/org.eclipse.jubula.toolkit.provider.swing/resources/xml/ComponentConfiguration.xml (-1 / +1 lines)
48		48
49	<toolkitComponent type="javax.swing.JList" visible="false">	49	<toolkitComponent type="javax.swing.JList" visible="false">
50	<realizes>guidancer.concrete.List</realizes>	50	<realizes>guidancer.concrete.List</realizes>
51	<testerClass>org.eclipse.jubula.rc.swing.swing.implclasses.JListImplClass</testerClass>	51	<testerClass>org.eclipse.jubula.rc.swing.swing.caps.JListCAPs</testerClass>
52	<componentClass name="javax.swing.JList" />	52	<componentClass name="javax.swing.JList" />
53	</toolkitComponent>	53	</toolkitComponent>
54		54

Lines 221-227 Link Here

(-)a/org.eclipse.jubula.toolkit.provider.swt/resources/xml/ComponentConfiguration.xml (-2 / +1 lines)
221		221
222	<toolkitComponent type="org.eclipse.swt.widgets.List" visible="false">	222	<toolkitComponent type="org.eclipse.swt.widgets.List" visible="false">
223	<realizes>guidancer.concrete.List</realizes>	223	<realizes>guidancer.concrete.List</realizes>
224	<testerClass>org.eclipse.jubula.rc.swt.implclasses.ListImplClass</testerClass>	224	<testerClass>org.eclipse.jubula.rc.swt.caps.ListCAPs</testerClass>
225	<componentClass name="org.eclipse.swt.widgets.List" />	225	<componentClass name="org.eclipse.swt.widgets.List" />
226	</toolkitComponent>	226	</toolkitComponent>
227		227
228	-

Return to bug 394179

Added Link Here

(-)a/org.eclipse.jubula.rc.common/src/org/eclipse/jubula/rc/common/caps/AbstractListCAPs.java (+476 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 java.util.Arrays;
14
15	import org.apache.commons.lang.ArrayUtils;
16	import org.apache.commons.lang.StringUtils;
17	import org.eclipse.jubula.rc.common.CompSystemConstants;
18	import org.eclipse.jubula.rc.common.driver.ClickOptions;
19	import org.eclipse.jubula.rc.common.driver.DragAndDropHelper;
20	import org.eclipse.jubula.rc.common.exception.StepExecutionException;
21	import org.eclipse.jubula.rc.common.implclasses.IndexConverter;
22	import org.eclipse.jubula.rc.common.implclasses.ListSelectionVerifier;
23	import org.eclipse.jubula.rc.common.implclasses.MatchUtil;
24	import org.eclipse.jubula.rc.common.implclasses.Verifier;
25	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IListAdapter;
26	import org.eclipse.jubula.tools.constants.StringConstants;
27	import org.eclipse.jubula.tools.constants.TestDataConstants;
28	import org.eclipse.jubula.tools.objects.event.EventFactory;
29	import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
30	import org.eclipse.jubula.tools.utils.StringParsing;
31
32	/**
33	*
34	* @author BREDEX GmbH
35	*
36	*/
37	public abstract class AbstractListCAPs extends AbstractTextVerifiable {
38
39	/** The default separator for enumerations of list values. */
40	public static final char INDEX_LIST_SEP_CHAR =
41	TestDataConstants.VALUE_CHAR_DEFAULT;
42	//FIXME this should be in an upper class or Util
43	/** The default separator of a list of values */
44	public static final char VALUE_SEPARATOR =
45	TestDataConstants.VALUE_CHAR_DEFAULT;
46
47	/**
48	* Splits the enumeration of values.
49	* @param values The values to split
50	* @param separator The separator, may be <code>null</code>
51	* @return The array of values
52	*/
53	private String[] split(String values, String separator) {
54	String[] list = StringParsing.splitToArray(values, ((separator == null)
55	\|\| (separator.length() == 0) ? INDEX_LIST_SEP_CHAR
56	: separator.charAt(0)),
57	TestDataConstants.ESCAPE_CHAR_DEFAULT);
58	list = StringUtils.stripAll(list);
59	return list;
60	}
61
62	/**
63	* @return The array of selected indices
64	* @throws StepExecutionException If there are no indices selected
65	*/
66	private int[] getCheckedSelectedIndices() throws StepExecutionException {
67	int[] selected = getListAdapter().getSelectedIndices();
68	if (selected.length == 0) {
69	throw new StepExecutionException("No list element selected", //$NON-NLS-1$
70	EventFactory.createActionError(TestErrorEvent.NO_SELECTION));
71	}
72	return selected;
73	}
74
75	/**
76	*
77	* @return the List Adapter
78	*/
79	private IListAdapter getListAdapter() {
80	return ((IListAdapter) getComponent());
81	}
82
83	/**
84	* Verifies if the passed index is selected.
85	*
86	* @param index The index to verify
87	* @param expectSelected Whether the index should be selected.
88	*/
89	public void gdVerifySelectedIndex(String index, boolean expectSelected) {
90	int[] selected = getCheckedSelectedIndices();
91	int implIndex = IndexConverter.toImplementationIndex(
92	Integer.parseInt(index));
93
94	boolean isSelected = ArrayUtils.contains(selected, implIndex);
95	if (expectSelected != isSelected) {
96	throw new StepExecutionException(
97	"Selection check failed for index: " + index, //$NON-NLS-1$
98	EventFactory.createVerifyFailed(
99	String.valueOf(expectSelected),
100	String.valueOf(isSelected)));
101	}
102	}
103
104	/**
105	* Verifies if the passed value or enumeration of values is selected. By
106	* default, the enumeration separator is <code>,</code>
107	* @param valueList The value or list of values to verify
108	*/
109	public void gdVerifySelectedValue(String valueList) {
110	gdVerifySelectedValue(valueList, MatchUtil.DEFAULT_OPERATOR, true);
111	}
112
113	/**
114	* Verifies if the passed value is selected.
115	*
116	* @param value The value to verify
117	* @param operator The operator to use when comparing the
118	* expected and actual values.
119	* @param isSelected if the value should be selected or not.
120	*/
121	public void gdVerifySelectedValue(String value, String operator,
122	boolean isSelected) {
123
124	final String[] current = getListAdapter().getSelectedValues();
125	final ListSelectionVerifier listSelVerifier =
126	new ListSelectionVerifier();
127	for (int i = 0; i < current.length; i++) {
128	listSelVerifier.addItem(i, current[i], true);
129	}
130	listSelVerifier.verifySelection(value, operator, isSelected);
131	}
132
133	/**
134	* Verifies if all selected elements of a list match a text.
135	* @param text The text to verify
136	* @param operator The operator used to verify
137	*/
138	public void gdVerifyText(String text, String operator) {
139	String[] selected = getListAdapter().getSelectedValues();
140	final int selCount = selected.length;
141	if (selCount < 1) {
142	throw new StepExecutionException("No selection", //$NON-NLS-1$
143	EventFactory.createActionError(TestErrorEvent.NO_SELECTION));
144	}
145	for (int i = 0; i < selCount; i++) {
146	Verifier.match(selected[i], text, operator);
147	}
148	}
149
150	/**
151	* Selects the passed index or enumeration of indices. The enumeration must
152	* be separated by <code>,</code>, e.g. <code>1, 3,6</code>.
153	* @param indexList The index or indices to select
154	* @param extendSelection Whether this selection extends a previous
155	* selection.
156	* @param button what mouse button should be used
157	*/
158	public void gdSelectIndex(String indexList, final String extendSelection,
159	int button) {
160	final boolean isExtendSelection = extendSelection
161	.equals(CompSystemConstants.EXTEND_SELECTION_YES);
162	selectIndices(IndexConverter
163	.toImplementationIndices(parseIndices(indexList)), ClickOptions
164	.create().setClickCount(1).setMouseButton(button),
165	isExtendSelection);
166	}
167
168	/**
169	* Selects the passed value or enumeration of values. By default, the
170	* enumeration separator is <code>,</code>.
171	* @param valueList The value or list of values to select
172	* @param operator If regular expressions are used
173	* @param searchType Determines where the search begins ("relative" or "absolute")
174	* @param extendSelection Whether this selection extends a previous
175	* selection. If <code>true</code>, the first
176	* element will be selected with CONTROL as a
177	* modifier.
178	* @param button what mouse button should be used
179	*/
180	public void gdSelectValue(String valueList, String operator,
181	String searchType, final String extendSelection, int button) {
182	final boolean isExtendSelection =
183	extendSelection.equals(CompSystemConstants.EXTEND_SELECTION_YES);
184	selectValue(valueList, String.valueOf(VALUE_SEPARATOR), operator,
185	searchType, ClickOptions.create()
186	.setClickCount(1)
187	.setMouseButton(button), isExtendSelection);
188	}
189
190	/**
191	* Selects the passed value or enumeration of values. By default, the
192	* enumeration separator is <code>,</code>, but may be changed by
193	* <code>separator</code>.
194	* @param valueList The value or list of values to select
195	* @param separator The separator, optional
196	* @param operator If regular expressions are used
197	* @param searchType Determines where the search begins ("relative" or "absolute")
198	* @param clickCount the amount of clicks to use
199	* @param extendSelection Whether this selection extends a previous
200	* selection.
201	*/
202	public void gdSelectValue(String valueList, String separator,
203	String operator, final String searchType, int clickCount,
204	final String extendSelection) {
205	final boolean isExtendSelection =
206	extendSelection.equals(CompSystemConstants.EXTEND_SELECTION_YES);
207	selectValue(valueList, separator, operator, searchType, ClickOptions
208	.create().setClickCount(clickCount), isExtendSelection);
209	}
210
211	/**
212	* Verifies if the list contains an element that renderes <code>value</code>.
213	* @param value The text to verify
214	*/
215	public void gdVerifyContainsValue(String value) {
216	Verifier.equals(true, containsValue(value));
217	}
218
219	/**
220	* Verifies if the list contains an element that renderes <code>value</code>.
221	* @param value The text to verify
222	* @param operator The operator used to verify
223	* @param exists if the wanted value should exist or not.
224	*/
225	public void gdVerifyContainsValue(String value, String operator,
226	boolean exists) {
227
228	Verifier.equals(exists, containsValue(value, operator));
229	}
230
231	/**
232	* Action to read the value of the current selected item of the JList
233	* to store it in a variable in the Client
234	* @param variable the name of the variable
235	* @return the text value.
236	*/
237	public String gdReadValue(String variable) {
238	String[] selected = getListAdapter().getSelectedValues();
239	if (selected.length > 0) {
240	return selected[0];
241	}
242	throw new StepExecutionException("No list item selected", //$NON-NLS-1$
243	EventFactory.createActionError(TestErrorEvent.NO_SELECTION));
244	}
245
246	/**
247	* Drags the passed value.
248	*
249	* @param mouseButton the mouseButton.
250	* @param modifier the modifier.
251	* @param value The value to drag
252	* @param operator If regular expressions are used
253	* @param searchType Determines where the search begins ("relative" or "absolute")
254	*/
255	public void gdDragValue(int mouseButton, String modifier, String value,
256	String operator, final String searchType) {
257
258	DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
259	dndHelper.setModifier(modifier);
260	dndHelper.setMouseButton(mouseButton);
261
262	Integer [] indices = getListAdapter().findIndicesOfValues(
263	new String [] {value}, operator, searchType);
264	selectIndices(ArrayUtils.toPrimitive(indices),
265	ClickOptions.create().setClickCount(0), false);
266
267	pressOrReleaseModifiers(modifier, true);
268	getRobot().mousePress(null, null, mouseButton);
269	}
270
271	/**
272	* Drops on the passed value.
273	*
274	* @param value The value on which to drop
275	* @param operator If regular expressions are used
276	* @param searchType Determines where the search begins ("relative" or "absolute")
277	* @param delayBeforeDrop the amount of time (in milliseconds) to wait
278	* between moving the mouse to the drop point and
279	* releasing the mouse button
280	*/
281	public void gdDropValue(String value, String operator,
282	final String searchType, int delayBeforeDrop) {
283
284	DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
285	try {
286	Integer [] indices = getListAdapter().findIndicesOfValues(
287	new String [] {value}, operator, searchType);
288	selectIndices(ArrayUtils.toPrimitive(indices),
289	ClickOptions.create().setClickCount(0), false);
290	waitBeforeDrop(delayBeforeDrop);
291	} finally {
292	getRobot().mouseRelease(null, null, dndHelper.getMouseButton());
293	pressOrReleaseModifiers(dndHelper.getModifier(), false);
294	}
295	}
296
297	/**
298	* Drags the passed index.
299	*
300	* @param mouseButton the mouseButton.
301	* @param modifier the modifier.
302	* @param index The index to drag
303	*/
304	public void gdDragIndex(final int mouseButton, final String modifier,
305	int index) {
306
307	DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
308	dndHelper.setModifier(modifier);
309	dndHelper.setMouseButton(mouseButton);
310
311	selectIndices(
312	new int [] {IndexConverter.toImplementationIndex(index)},
313	ClickOptions.create().setClickCount(0), false);
314
315	pressOrReleaseModifiers(modifier, true);
316	getRobot().mousePress(null, null, mouseButton);
317	}
318
319	/**
320	* Drops onto the passed index.
321	*
322	* @param index The index on which to drop
323	* @param delayBeforeDrop the amount of time (in milliseconds) to wait
324	* between moving the mouse to the drop point and
325	* releasing the mouse button
326	*/
327	public void gdDropIndex(final int index, int delayBeforeDrop) {
328
329	DragAndDropHelper dndHelper = DragAndDropHelper.getInstance();
330
331	try {
332	selectIndices(
333	new int [] {IndexConverter.toImplementationIndex(index)},
334	ClickOptions.create().setClickCount(0), false);
335	waitBeforeDrop(delayBeforeDrop);
336	} finally {
337	getRobot().mouseRelease(null, null, dndHelper.getMouseButton());
338	pressOrReleaseModifiers(dndHelper.getModifier(), false);
339	}
340	}
341
342	/**
343	* @param value The value
344	* @return <code>true</code> if the list contains an element that is rendered with <code>value</code>
345	*/
346	public boolean containsValue(String value) {
347	Integer[] indices = getListAdapter().findIndicesOfValues(
348	new String[] { value },
349	MatchUtil.EQUALS, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
350	return indices.length > 0;
351	}
352
353	/**
354	* @param value The value
355	* @param operator The operator used to verify
356	* @return <code>true</code> if the list contains an element that is rendered with <code>value</code>
357	*/
358	public boolean containsValue(String value, String operator) {
359	Integer[] indices = null;
360	if (operator.equals(MatchUtil.NOT_EQUALS)) {
361	indices = getListAdapter().findIndicesOfValues(
362	new String[] { value },
363	MatchUtil.EQUALS, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
364	return indices.length == 0;
365	}
366	indices = getListAdapter().findIndicesOfValues(new String[] { value },
367	operator, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
368	return indices.length > 0;
369	}
370
371	/**
372	* Selects the passed value or enumeration of values. By default, the
373	* enumeration separator is <code>,</code>, but may be changed by
374	* <code>separator</code>.
375	* @param valueList The value or list of values to select
376	* @param separator The separator, optional
377	* @param operator If regular expressions are used
378	* @param searchType Determines where the search begins ("relative" or "absolute")
379	* @param co the click options to use
380	* @param isExtendSelection Whether this selection extends a previous
381	* selection.
382	*/
383	private void selectValue(String valueList, String separator,
384	String operator, final String searchType, ClickOptions co,
385	final boolean isExtendSelection) {
386
387	String[] values = null;
388	if (StringConstants.EMPTY.equals(valueList)) {
389	values = new String[1];
390	values[0] = StringConstants.EMPTY;
391	} else {
392	values = split(valueList, separator);
393	}
394	Integer[] indices = getListAdapter().findIndicesOfValues(values,
395	operator, searchType);
396	Arrays.sort(indices);
397	if (!operator.equals(MatchUtil.NOT_EQUALS)
398	&& (indices.length < values.length)) {
399	throw new StepExecutionException("One or more values not found of set: " //$NON-NLS-1$
400	+ Arrays.asList(values).toString(),
401	EventFactory.createActionError(TestErrorEvent.NOT_FOUND));
402	}
403	selectIndices(ArrayUtils.toPrimitive(indices), co, isExtendSelection);
404	}
405
406	/**
407	* Parses the enumeration of indices.
408	* @param indexList The enumeration of indices
409	* @return The array of parsed indices
410	*/
411	private int[] parseIndices(String indexList) {
412	String[] list = StringParsing.splitToArray(indexList,
413	INDEX_LIST_SEP_CHAR, TestDataConstants.ESCAPE_CHAR_DEFAULT);
414	int[] indices = new int[list.length];
415	for (int i = 0; i < list.length; i++) {
416	indices[i] = IndexConverter.intValue(list[i]);
417	}
418	return indices;
419	}
420
421	/**
422	* @param indices The indices to select
423	* @param co the click options to use
424	* @param isExtendSelection Whether this selection extends a previous
425	* selection. If <code>true</code>, the first
426	* element will be selected with CONTROL as a
427	* modifier.
428	*/
429	private void selectIndices(int[] indices, ClickOptions co,
430	boolean isExtendSelection) {
431	Object list = getListAdapter().getRealComponent();
432	if (indices.length > 0) {
433	try {
434	if (isExtendSelection) {
435	getRobot().keyPress(list,
436	getSystemDefaultModifier());
437	}
438
439	// first selection
440	getListAdapter().clickOnIndex(
441	new Integer(indices[0]), co);
442	} finally {
443	if (isExtendSelection) {
444	getRobot().keyRelease(list,
445	getSystemDefaultModifier());
446	}
447	}
448	}
449	try {
450	getRobot().keyPress(list,
451	getSystemDefaultModifier());
452	// following selections
453	for (int i = 1; i < indices.length; i++) {
454	getListAdapter().clickOnIndex(
455	new Integer(indices[i]), co);
456	}
457	} finally {
458	getRobot().keyRelease(list,
459	getSystemDefaultModifier());
460	}
461	}
462
463	/**
464	* {@inheritDoc}
465	*/
466	public String[] getTextArrayFromComponent() {
467	return null;
468	}
469
470	/**
471	*
472	* @return -
473	*/
474	protected abstract int getSystemDefaultModifier();
475
476	}

Lines 11-19 Link Here

(-)a/org.eclipse.jubula.rc.swing/src/org/eclipse/jubula/rc/swing/swing/caps/AbstractButtonCAPs.java (-15 lines)
11	package org.eclipse.jubula.rc.swing.swing.caps;	11	package org.eclipse.jubula.rc.swing.swing.caps;
12		12
13		13
14	import org.eclipse.jubula.rc.common.driver.IRobotFactory;
15	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IButtonAdapter;	14	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IButtonAdapter;
16	import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig;
17		15
18	/**	16	/**
19	* The implementation class for <code>AbstractButton</code> and subclasses. Note	17	* The implementation class for <code>AbstractButton</code> and subclasses. Note
Lines 27-35 import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig; Link Here
27	public class AbstractButtonCAPs	25	public class AbstractButtonCAPs
28	extends org.eclipse.jubula.rc.common.caps.AbstractButtonCAPs {	26	extends org.eclipse.jubula.rc.common.caps.AbstractButtonCAPs {
29		27
30	/** Robot Factory*/
31	private IRobotFactory m_robotFactory;
32
33	/**	28	/**
34	* Clicks the button <code>count</code> times.	29	* Clicks the button <code>count</code> times.
35	*	30	*
Lines 47-60 public class AbstractButtonCAPs Link Here
47	return new String[] { returnvalue.getText() };	42	return new String[] { returnvalue.getText() };
48	}	43	}
49		44
50	/**
51	* {@inheritDoc}
52	*/
53	protected IRobotFactory getRobotFactory() {
54	if (m_robotFactory == null) {
55	m_robotFactory = new RobotFactoryConfig().getRobotFactory();
56	}
57	return m_robotFactory;
58	}
59
60	}	45	}

Lines 26-37 import javax.swing.JPopupMenu; Link Here

(-)a/org.eclipse.jubula.rc.swing/src/org/eclipse/jubula/rc/swing/swing/caps/JMenuBarCAPs.java (-18 / +2 lines)
26	import javax.swing.MenuElement;	26	import javax.swing.MenuElement;
27		27
28	import org.eclipse.jubula.rc.common.caps.AbstractMenuCAPs;	28	import org.eclipse.jubula.rc.common.caps.AbstractMenuCAPs;
29	import org.eclipse.jubula.rc.common.driver.IRobotFactory;
30	import org.eclipse.jubula.rc.common.implclasses.IBaseImplementationClass;
31	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;	29	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;
32	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;	30	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;
33	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;	31	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;
34	import org.eclipse.jubula.rc.swing.driver.RobotFactoryConfig;
35	import org.eclipse.jubula.rc.swing.swing.implclasses.WindowHelper;	32	import org.eclipse.jubula.rc.swing.swing.implclasses.WindowHelper;
36	import org.eclipse.jubula.rc.swing.swing.uiadapter.JMenuItemAdapter;	33	import org.eclipse.jubula.rc.swing.swing.uiadapter.JMenuItemAdapter;
37		34
Lines 40-60 import org.eclipse.jubula.rc.swing.swing.uiadapter.JMenuItemAdapter; Link Here
40	*	37	*
41	* @author BREDEX GmbH	38	* @author BREDEX GmbH
42	*/	39	*/
43	public class JMenuBarCAPs extends AbstractMenuCAPs	40	public class JMenuBarCAPs extends AbstractMenuCAPs {
44	implements IBaseImplementationClass {	41
45
46	/** The robot factory. */
47	private IRobotFactory m_robotFactory;
48	/**
49	* {@inheritDoc}
50	*/
51	protected IRobotFactory getRobotFactory() {
52	if (m_robotFactory == null) {
53	m_robotFactory = new RobotFactoryConfig().getRobotFactory();
54	}
55	return m_robotFactory;
56	}
57
58	/**	42	/**
59	* {@inheritDoc}	43	* {@inheritDoc}
60	*/	44	*/

Lines 13-18 package org.eclipse.jubula.rc.swing.swing.uiadapter.factory; Link Here

(-)a/org.eclipse.jubula.rc.swing/src/org/eclipse/jubula/rc/swing/swing/uiadapter/factory/SwingAdapterFactory.java (-1 / +7 lines)
13		13
14	import javax.swing.JButton;	14	import javax.swing.JButton;
15	import javax.swing.JCheckBox;	15	import javax.swing.JCheckBox;
		16	import javax.swing.JList;
16	import javax.swing.JMenuBar;	17	import javax.swing.JMenuBar;
17	import javax.swing.JMenuItem;	18	import javax.swing.JMenuItem;
18	import javax.swing.JPopupMenu;	19	import javax.swing.JPopupMenu;
Lines 23-28 import javax.swing.JTree; Link Here
23	import org.eclipse.jubula.rc.common.uiadapter.factory.IUIAdapterFactory;	24	import org.eclipse.jubula.rc.common.uiadapter.factory.IUIAdapterFactory;
24	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;	25	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;
25	import org.eclipse.jubula.rc.swing.swing.uiadapter.AbstractButtonAdapter;	26	import org.eclipse.jubula.rc.swing.swing.uiadapter.AbstractButtonAdapter;
		27	import org.eclipse.jubula.rc.swing.swing.uiadapter.JListAdapter;
26	import org.eclipse.jubula.rc.swing.swing.uiadapter.JMenuBarAdapter;	28	import org.eclipse.jubula.rc.swing.swing.uiadapter.JMenuBarAdapter;
27	import org.eclipse.jubula.rc.swing.swing.uiadapter.JMenuItemAdapter;	29	import org.eclipse.jubula.rc.swing.swing.uiadapter.JMenuItemAdapter;
28	import org.eclipse.jubula.rc.swing.swing.uiadapter.JPopupMenuAdapter;	30	import org.eclipse.jubula.rc.swing.swing.uiadapter.JPopupMenuAdapter;
Lines 45-51 public class SwingAdapterFactory implements IUIAdapterFactory { Link Here
45	private static final Class[] SUPPORTEDCLASSES = new Class[] {	47	private static final Class[] SUPPORTEDCLASSES = new Class[] {
46	JButton.class, JCheckBox.class, JRadioButton.class,	48	JButton.class, JCheckBox.class, JRadioButton.class,
47	JMenuBar.class, JMenuItem.class, JTree.class ,	49	JMenuBar.class, JMenuItem.class, JTree.class ,
48	JCheckBox.class, JRadioButton.class, JTable.class, JPopupMenu.class};	50	JCheckBox.class, JRadioButton.class, JTable.class, JPopupMenu.class,
		51	JList.class};
49		52
50	/**	53	/**
51	* {@inheritDoc}	54	* {@inheritDoc}
Lines 81-86 public class SwingAdapterFactory implements IUIAdapterFactory { Link Here
81	} else if (objectToAdapt instanceof JTable) {	84	} else if (objectToAdapt instanceof JTable) {
82	returnvalue = new JTableAdapter(objectToAdapt);	85	returnvalue = new JTableAdapter(objectToAdapt);
83		86
		87	} else if (objectToAdapt instanceof JList) {
		88	returnvalue = new JListAdapter(objectToAdapt);
		89
84	} else if (objectToAdapt instanceof JPopupMenu) {	90	} else if (objectToAdapt instanceof JPopupMenu) {
85	returnvalue = new JPopupMenuAdapter(objectToAdapt);	91	returnvalue = new JPopupMenuAdapter(objectToAdapt);
86		92

Lines 20-26 import org.eclipse.jubula.rc.common.util.KeyStrokeUtil; Link Here

(-)a/org.eclipse.jubula.rc.swt/src/org/eclipse/jubula/rc/swt/caps/CAPUtil.java (-12 lines)
20	import org.eclipse.jubula.rc.swt.driver.KeyCodeConverter;	20	import org.eclipse.jubula.rc.swt.driver.KeyCodeConverter;
21	import org.eclipse.jubula.rc.swt.driver.SwtRobot;	21	import org.eclipse.jubula.rc.swt.driver.SwtRobot;
22	import org.eclipse.jubula.tools.utils.EnvironmentUtils;	22	import org.eclipse.jubula.tools.utils.EnvironmentUtils;
23	import org.eclipse.jubula.tools.utils.TimeUtil;
24	import org.eclipse.swt.widgets.Display;	23	import org.eclipse.swt.widgets.Display;
25	/**	24	/**
26	* Util class for some swt specific commands.	25	* Util class for some swt specific commands.
Lines 46-62 public class CAPUtil { Link Here
46	}	45	}
47		46
48	/**	47	/**
49	* Waits the given amount of time. Logs a drop-related error if interrupted.
50	*
51	* @param delayBeforeDrop the amount of time (in milliseconds) to wait
52	* between moving the mouse to the drop point and
53	* releasing the mouse button
54	*/
55	public static void waitBeforeDrop(int delayBeforeDrop) {
56	TimeUtil.delay(delayBeforeDrop);
57	}
58
59	/**
60	* Move the mouse pointer from its current position to a few points in	48	* Move the mouse pointer from its current position to a few points in
61	* its proximity. This is used to initiate a drag operation.	49	* its proximity. This is used to initiate a drag operation.
62	*	50	*

Lines 13-22 package org.eclipse.jubula.rc.swt.caps; Link Here

(-)a/org.eclipse.jubula.rc.swt/src/org/eclipse/jubula/rc/swt/caps/MenuCAPs.java (-25 / +2 lines)
13	import org.apache.commons.lang.Validate;	13	import org.apache.commons.lang.Validate;
14	import org.eclipse.jubula.rc.common.caps.AbstractMenuCAPs;	14	import org.eclipse.jubula.rc.common.caps.AbstractMenuCAPs;
15	import org.eclipse.jubula.rc.common.driver.IEventThreadQueuer;	15	import org.eclipse.jubula.rc.common.driver.IEventThreadQueuer;
16	import org.eclipse.jubula.rc.common.driver.IRobot;
17	import org.eclipse.jubula.rc.common.driver.IRobotFactory;
18	import org.eclipse.jubula.rc.common.driver.IRunnable;	16	import org.eclipse.jubula.rc.common.driver.IRunnable;
19	import org.eclipse.jubula.rc.common.exception.RobotException;
20	import org.eclipse.jubula.rc.common.exception.StepExecutionException;	17	import org.eclipse.jubula.rc.common.exception.StepExecutionException;
21	import org.eclipse.jubula.rc.common.implclasses.IBaseImplementationClass;	18	import org.eclipse.jubula.rc.common.implclasses.IBaseImplementationClass;
22	import org.eclipse.jubula.rc.common.implclasses.MenuUtilBase;	19	import org.eclipse.jubula.rc.common.implclasses.MenuUtilBase;
Lines 24-30 import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter; Link Here
24	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;	21	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuAdapter;
25	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;	22	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IMenuItemAdapter;
26	import org.eclipse.jubula.rc.swt.driver.EventThreadQueuerSwtImpl;	23	import org.eclipse.jubula.rc.swt.driver.EventThreadQueuerSwtImpl;
27	import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;
28	import org.eclipse.jubula.rc.swt.driver.RobotSwtImpl;	24	import org.eclipse.jubula.rc.swt.driver.RobotSwtImpl;
29	import org.eclipse.jubula.rc.swt.uiadapter.MenuItemAdapter;	25	import org.eclipse.jubula.rc.swt.uiadapter.MenuItemAdapter;
30	import org.eclipse.jubula.tools.i18n.I18n;	26	import org.eclipse.jubula.tools.i18n.I18n;
Lines 43-63 import org.eclipse.swt.widgets.Shell; Link Here
43	*/	39	*/
44	public class MenuCAPs extends AbstractMenuCAPs	40	public class MenuCAPs extends AbstractMenuCAPs
45	implements IBaseImplementationClass {	41	implements IBaseImplementationClass {
46	/** the RobotFactory from the AUT */	42
47	private IRobotFactory m_robotFactory;
48		43
49	/** Test variable for contextMenus*/	44	/** Test variable for contextMenus*/
50	private boolean m_isCM = false;	45	private boolean m_isCM = false;
51	/**	46
52	* Gets the IEventThreadQueuer.
53	*
54	* @return The Robot
55	* @throws RobotException
56	* If the Robot cannot be created.
57	*/
58	protected IRobot getRobot() throws RobotException {
59	return getRobotFactory().getRobot();
60	}
61		47
62	/**	48	/**
63	* @return The event thread queuer.	49	* @return The event thread queuer.
Lines 97-111 public class MenuCAPs extends AbstractMenuCAPs Link Here
97	public String[] getTextArrayFromComponent() {	83	public String[] getTextArrayFromComponent() {
98	return null;	84	return null;
99	}	85	}
100	/**
101	* {@inheritDoc}
102	*/
103	protected IRobotFactory getRobotFactory() {
104	if (m_robotFactory == null) {
105	m_robotFactory = new RobotFactoryConfig().getRobotFactory();
106	}
107	return m_robotFactory;
108	}
109		86
110	/**	87	/**
111	* Tries to select a menu item in a menu defined by a Text-Path	88	* Tries to select a menu item in a menu defined by a Text-Path

Added Link Here

(-)a/org.eclipse.jubula.rc.swt/src/org/eclipse/jubula/rc/swt/uiadapter/AbstractComponentAdapter.java (+29 lines)
1	package org.eclipse.jubula.rc.swt.uiadapter;
2
3	import org.eclipse.jubula.rc.common.driver.IRobotFactory;
4	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IComponentAdapter;
5	import org.eclipse.jubula.rc.swt.driver.RobotFactoryConfig;
6	/**
7	*
8	* @author BREDEX GmBH
9	*
10	*/
11	public abstract class AbstractComponentAdapter implements IComponentAdapter {
12
13	/** the RobotFactory from the AUT */
14	private IRobotFactory m_robotFactory;
15
16
17	/**
18	* Gets the Robot factory. The factory is created once per instance.
19	*
20	* @return The Robot factory.
21	*/
22	public IRobotFactory getRobotFactory() {
23	if (m_robotFactory == null) {
24	m_robotFactory = new RobotFactoryConfig().getRobotFactory();
25	}
26	return m_robotFactory;
27	}
28
29	}