Attachment #223848 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);
    }

}




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	}




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

}




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

}




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




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

}




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

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	}

Added Link Here

(-)a/org.eclipse.jubula.rc.swing/src/org/eclipse/jubula/rc/swing/swing/caps/JListCAPs.java (+19 lines)
1	package org.eclipse.jubula.rc.swing.swing.caps;
2
3	import org.eclipse.jubula.rc.common.caps.AbstractListCAPs;
4	import org.eclipse.jubula.rc.swing.utils.SwingUtils;
5	/**
6	*
7	* @author BREDEX GmbH
8	*
9	*/
10	public class JListCAPs extends AbstractListCAPs {
11
12	/**
13	* {@inheritDoc}
14	*/
15	protected int getSystemDefaultModifier() {
16	return SwingUtils.getSystemDefaultModifier();
17	}
18
19	}

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

Added Link Here

(-)a/org.eclipse.jubula.rc.swing/src/org/eclipse/jubula/rc/swing/swing/uiadapter/JListAdapter.java (+233 lines)
1	package org.eclipse.jubula.rc.swing.swing.uiadapter;
2
3	import java.awt.Component;
4	import java.awt.Dimension;
5	import java.awt.Rectangle;
6	import java.util.HashSet;
7	import java.util.Set;
8
9	import javax.swing.JList;
10	import javax.swing.ListCellRenderer;
11	import javax.swing.ListModel;
12
13	import org.eclipse.jubula.rc.common.CompSystemConstants;
14	import org.eclipse.jubula.rc.common.driver.ClickOptions;
15	import org.eclipse.jubula.rc.common.driver.IRunnable;
16	import org.eclipse.jubula.rc.common.exception.StepExecutionException;
17	import org.eclipse.jubula.rc.common.implclasses.MatchUtil;
18	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IListAdapter;
19	import org.eclipse.jubula.rc.swing.swing.caps.CapUtil;
20	import org.eclipse.jubula.rc.swing.swing.implclasses.JComboBoxImplClass;
21	import org.eclipse.jubula.tools.objects.event.EventFactory;
22	import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
23	/**
24	*
25	* @author marvin
26	*
27	*/
28	public class JListAdapter extends WidgetAdapter implements IListAdapter {
29	/** */
30	private JList m_list;
31
32	/**
33	*
34	* @param objectToAdapt
35	*/
36	public JListAdapter(Object objectToAdapt) {
37	super(objectToAdapt);
38	m_list = (JList) objectToAdapt;
39	}
40
41	/**
42	* {@inheritDoc}
43	*/
44	public String getText() {
45	String[] selected = getSelectedValues();
46	if (selected.length > 0) {
47	return selected[0];
48	}
49	throw new StepExecutionException("No list item selected", //$NON-NLS-1$
50	EventFactory.createActionError(TestErrorEvent.NO_SELECTION));
51	}
52
53	/**
54	* {@inheritDoc}
55	*/
56	public int[] getSelectedIndices() {
57	return (int[])getEventThreadQueuer().invokeAndWait(
58	"getSelectedIndices", new IRunnable() { //$NON-NLS-1$
59	public Object run() {
60	return m_list.getSelectedIndices();
61	}
62	});
63	}
64
65	/**
66	* Clicks on the index of the passed list.
67	*
68	* @param i The index to click
69	* @param co the click options to use
70	* @param maxWidth the maximal width which is used to select the item
71	*/
72	public void clickOnIndex(final Integer i,
73	ClickOptions co, double maxWidth) {
74	final int index = i.intValue();
75	ListModel model = m_list.getModel();
76	if ((model == null) \|\| (index >= model.getSize())
77	\|\| (index < 0)) {
78	throw new StepExecutionException("List index '" + i //$NON-NLS-1$
79	+ "' is out of range", //$NON-NLS-1$
80	EventFactory.createActionError(TestErrorEvent.INVALID_INDEX));
81	}
82	// Call of JList.ensureIndexIsVisible() is not required,
83	// because the Robot scrolls the click rectangle to visible.
84	Rectangle r = (Rectangle) getRobotFactory().getEventThreadQueuer()
85	.invokeAndWait("getCellBounds", new IRunnable() { //$NON-NLS-1$
86
87	public Object run() throws StepExecutionException {
88	return m_list.getCellBounds(index, index);
89	}
90	});
91
92	if (r == null) {
93	throw new StepExecutionException(
94	"List index '" + i + "' is not visible", //$NON-NLS-1$ //$NON-NLS-2$
95	EventFactory.createActionError(TestErrorEvent.NOT_VISIBLE));
96	}
97
98	// if possible adjust height and width for items
99	ListCellRenderer lcr = m_list.getCellRenderer();
100	if (lcr != null) {
101	Component listItem = lcr.getListCellRendererComponent(m_list, model
102	.getElementAt(index), index, false, false);
103	Dimension preferredSize = listItem.getPreferredSize();
104	r.setSize(preferredSize);
105	}
106
107	if (maxWidth != JComboBoxImplClass.NO_MAX_WIDTH
108	&& r.getWidth() > maxWidth) {
109	Dimension d = new Dimension();
110	d.setSize(maxWidth, r.getHeight());
111	r.setSize(d);
112	}
113
114	getRobot().click(m_list, r,
115	co.setClickType(ClickOptions.ClickType.RELEASED));
116	}
117
118	/**
119	* {@inheritDoc}
120	*/
121	public String[] getSelectedValues() {
122	final int[] indices = getSelectedIndices();
123
124	return (String[])getEventThreadQueuer().invokeAndWait(
125	"getSelectedValues", new IRunnable() { //$NON-NLS-1$
126	public Object run() {
127	Object[] values = m_list.getSelectedValues();
128	String[] selected = new String[values.length];
129	ListCellRenderer renderer = m_list.getCellRenderer();
130	for (int i = 0; i < values.length; i++) {
131	Object value = values[i];
132	Component c = renderer.getListCellRendererComponent(
133	m_list, value, indices[i], true, false);
134	selected[i] = CapUtil.getRenderedText(c);
135	}
136	return selected;
137	}
138	});
139	}
140	/**
141	* {@inheritDoc}
142	*/
143	public Integer[] findIndicesOfValues(
144	final String[] values, final String operator,
145	final String searchType) {
146
147	final Set indexSet = new HashSet();
148	getEventThreadQueuer().invokeAndWait("findIndices", //$NON-NLS-1$
149	new IRunnable() {
150	public Object run() {
151	ListCellRenderer renderer = m_list.getCellRenderer();
152	ListModel model = m_list.getModel();
153	for (int i = getStartingIndex(searchType);
154	i < model.getSize(); ++i) {
155	Object obj = model.getElementAt(i);
156	m_list.ensureIndexIsVisible(i);
157	Component comp = renderer
158	.getListCellRendererComponent(
159	m_list, obj, i, false, false);
160	String str = CapUtil.getRenderedText(comp);
161	if (MatchUtil.getInstance().
162	match(str, values, operator)) {
163	indexSet.add(new Integer(i));
164	}
165	}
166	return null; // return value is not used
167	}
168	});
169
170	Integer[] indices = new Integer[indexSet.size()];
171	indexSet.toArray(indices);
172	return indices;
173	}
174
175	/**
176	* Finds the indices of the list elements that are rendered with the passed
177	* values.
178	*
179	* @param values The values
180	* @param operator operator to use
181	* @return The array of indices. It's length is equal to the length of the
182	* values array, but may contains <code>null</code> elements for
183	* all values that are not found in the list
184	*/
185	public Integer[] findIndicesOfValues(
186	final String[] values, final String operator) {
187
188	return findIndicesOfValues(values, operator,
189	CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
190	}
191
192	/**
193	* {@inheritDoc}
194	*/
195	public boolean containsValue(String value, String operator) {
196	Integer[] indices = null;
197	if (operator.equals(MatchUtil.NOT_EQUALS)) {
198	indices = findIndicesOfValues(new String[] { value },
199	MatchUtil.EQUALS);
200	return indices.length == 0;
201	}
202	indices = findIndicesOfValues(new String[] { value },
203	operator);
204	return indices.length > 0;
205	}
206
207	/**
208	* Clicks on the index of the passed list.
209	*
210	* @param i
211	* The index to click
212	* @param co the click options to use
213	*/
214	public void clickOnIndex(final Integer i, ClickOptions co) {
215	clickOnIndex(i, co, JComboBoxImplClass.NO_MAX_WIDTH);
216	}
217
218	/**
219	* @param searchType Determines where the search begins ("relative" or "absolute")
220	* @return The index from which to begin a search, based on the search type
221	* and (if appropriate) the currently selected cell.
222	*/
223	private int getStartingIndex(final String searchType) {
224	int startingIndex = 0;
225	if (searchType.equalsIgnoreCase(
226	CompSystemConstants.SEARCH_TYPE_RELATIVE)) {
227	int [] selectedIndices = getSelectedIndices();
228	// Start from the last selected item
229	startingIndex = selectedIndices[selectedIndices.length - 1] + 1;
230	}
231	return startingIndex;
232	}
233	}

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	*

Added Link Here

(-)a/org.eclipse.jubula.rc.swt/src/org/eclipse/jubula/rc/swt/caps/ListCAPs.java (+20 lines)
1	package org.eclipse.jubula.rc.swt.caps;
2
3	import org.eclipse.jubula.rc.common.caps.AbstractListCAPs;
4	import org.eclipse.jubula.rc.swt.utils.SwtUtils;
5	/**
6	*
7	* @author BREDEX GmbH
8	*
9	*/
10	public class ListCAPs extends AbstractListCAPs {
11
12
13	/**
14	* {@inheritDoc}
15	*/
16	protected int getSystemDefaultModifier() {
17	return SwtUtils.getSystemDefaultModifier();
18	}
19
20	}

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	}

Added Link Here

(-)a/org.eclipse.jubula.rc.swt/src/org/eclipse/jubula/rc/swt/uiadapter/ListAdapter.java (+198 lines)
1	package org.eclipse.jubula.rc.swt.uiadapter;
2
3	import java.util.ArrayList;
4
5	import org.eclipse.jubula.rc.common.CompSystemConstants;
6	import org.eclipse.jubula.rc.common.driver.ClickOptions;
7	import org.eclipse.jubula.rc.common.driver.IRunnable;
8	import org.eclipse.jubula.rc.common.exception.StepExecutionException;
9	import org.eclipse.jubula.rc.common.implclasses.MatchUtil;
10	import org.eclipse.jubula.rc.common.uiadapter.interfaces.IListAdapter;
11	import org.eclipse.jubula.rc.swt.utils.SwtUtils;
12	import org.eclipse.jubula.tools.objects.event.EventFactory;
13	import org.eclipse.jubula.tools.objects.event.TestErrorEvent;
14	import org.eclipse.swt.graphics.Rectangle;
15	import org.eclipse.swt.widgets.List;
16	/**
17	*
18	* @author BREDEX GmbH
19	*
20	*/
21	public class ListAdapter extends WidgetAdapter implements IListAdapter {
22
23	/** */
24	private List m_list;
25	/**
26	*
27	* @param objectToAdapt -
28	*/
29	public ListAdapter(Object objectToAdapt) {
30	super(objectToAdapt);
31	m_list = (List) objectToAdapt;
32	}
33
34	/**
35	* {@inheritDoc}
36	*/
37	public String getText() {
38	String[] selected = getSelectedValues();
39	if (selected.length > 0) {
40	return selected[0];
41	}
42	throw new StepExecutionException("No list item selected", //$NON-NLS-1$
43	EventFactory.createActionError(TestErrorEvent.NO_SELECTION));
44	}
45
46	/**
47	* {@inheritDoc}
48	*/
49	public int[] getSelectedIndices() {
50	return (int[])getEventThreadQueuer().invokeAndWait(
51	"getSelectedIndices", new IRunnable() { //$NON-NLS-1$
52	public Object run() {
53	return m_list.getSelectionIndices();
54	}
55	});
56	}
57	/**
58	* {@inheritDoc}
59	*/
60	public void clickOnIndex(Integer i, ClickOptions co) {
61	final int iVal = i.intValue();
62	scrollIndexToVisible(iVal);
63
64	final Rectangle clickConstraints =
65	(Rectangle)getEventThreadQueuer().invokeAndWait(
66	"setClickConstraints", //$NON-NLS-1$
67	new IRunnable() {
68
69	public Object run() throws StepExecutionException {
70	Rectangle constraints = new Rectangle(0, 0, 0, 0);
71	int displayedItemCount = getDisplayedItemCount();
72	int numberBelowTop = 0;
73	if (displayedItemCount >= m_list.getItemCount()) {
74	numberBelowTop = iVal;
75	} else {
76	numberBelowTop = Math.max(0, iVal
77	- m_list.getItemCount() + displayedItemCount);
78	}
79
80	// Set the constraints based on the numberBelowTop
81	constraints.height = m_list.getItemHeight();
82	constraints.width = m_list.getBounds().width;
83	constraints.y += (numberBelowTop * constraints.height);
84	// explicitly use list relative bounds here - as e.g. on
85	// Mac OS systems list.getClientArea() is not relative
86	// see bug 353905
87	Rectangle actualListBounds =
88	new Rectangle(0, 0, m_list.getClientArea().width,
89	m_list.getClientArea().height);
90	return constraints.intersection(actualListBounds);
91	}
92	});
93
94	// Note that we set scrollToVisible false because we have already done
95	// the scrolling.
96	getRobot().click(m_list, clickConstraints,
97	co.setScrollToVisible(false));
98
99	}
100	/**
101	* {@inheritDoc}
102	*/
103	public String[] getSelectedValues() {
104	return (String[])getEventThreadQueuer().invokeAndWait(
105	"getSelectedValues", new IRunnable() { //$NON-NLS-1$
106	public Object run() {
107	return m_list.getSelection();
108	}
109	});
110	}
111	/**
112	* {@inheritDoc}
113	*/
114	public Integer[] findIndicesOfValues(final String[] values,
115	final String operator, final String searchType) {
116	final java.util.List indexList = (java.util.List)
117	getEventThreadQueuer().invokeAndWait("findIndices", //$NON-NLS-1$
118	new IRunnable() {
119	public Object run() {
120	final int valuesLength = values.length;
121	final java.util.List idxList = new ArrayList(
122	values.length);
123	final int listItemCount = m_list.getItemCount();
124	final MatchUtil matchUtil = MatchUtil.getInstance();
125	for (int i = 0; i < valuesLength; i++) {
126	final String value = values[i];
127	for (int j = getStartingIndex(searchType);
128	j < listItemCount; j++) {
129
130	final String listItem = m_list.getItem(j);
131	if (matchUtil.match(listItem, value,
132	operator)) {
133
134	idxList.add(new Integer(j));
135	}
136	}
137	}
138	return idxList;
139	}
140	});
141	Integer[] indices = new Integer[indexList.size()];
142	indexList.toArray(indices);
143	return indices;
144	}
145
146	/**
147	* @return the number of items displayed in the list.
148	*/
149	private int getDisplayedItemCount() {
150	return ((Integer)getEventThreadQueuer().invokeAndWait(
151	"getDisplayedItemCount", //$NON-NLS-1$
152	new IRunnable() {
153
154	public Object run() throws StepExecutionException {
155	int listHeight = SwtUtils.getWidgetBounds(m_list).height;
156	int itemHeight = m_list.getItemHeight();
157
158	return new Integer(listHeight / itemHeight);
159	}
160
161	})).intValue();
162	}
163
164	/**
165	* @param index The index to make visible
166	*/
167	private void scrollIndexToVisible(final int index) {
168	getEventThreadQueuer().invokeAndWait(
169	"scrollIndexToVisible", //$NON-NLS-1$
170	new IRunnable() {
171
172	public Object run() throws StepExecutionException {
173
174	m_list.setTopIndex(index);
175
176	return null;
177	}
178
179	});
180	}
181	/**
182	* @param searchType Determines where the search begins ("relative" or "absolute")
183	* @return The index from which to begin a search, based on the search type
184	* and (if appropriate) the currently selected cell.
185	*/
186	private int getStartingIndex(final String searchType) {
187	int startingIndex = 0;
188	if (searchType.equalsIgnoreCase(
189	CompSystemConstants.SEARCH_TYPE_RELATIVE)) {
190	int [] selectedIndices = getSelectedIndices();
191	// Start from the last selected item, if any item(s) are selected
192	if (selectedIndices.length > 0) {
193	startingIndex = selectedIndices[selectedIndices.length - 1] + 1;
194	}
195	}
196	return startingIndex;
197	}
198	}