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

 * Copyright (c) 2012 BREDEX GmbH.

 * All rights reserved. This program and the accompanying materials

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

 * which accompanies this distribution, and is available at

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

 *

 * Contributors:

 *     BREDEX GmbH - initial API and implementation 

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

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

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

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

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

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

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

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

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

/**

 * General implementation for ComboBoxes and ComboBox like components.

 * @author BREDEX GmbH

 *

 */

public class AbstractComboBoxCAPs extends AbstractTextInputSupport {

    /** The dafault separator of a list of values */

    public static final char VALUE_SEPARATOR =

        TestDataConstants.VALUE_CHAR_DEFAULT;

    /**

     * 

     * @return the <code>IComboBoxAdapter</code>

     */

    private IComboBoxAdapter getCBAdapter() {

        return (IComboBoxAdapter) getComponent();

    }

    /**

     * {@inheritDoc}

     */

    public String[] getTextArrayFromComponent() {

        return null;

    }

    /**

     * Verifies the editable property. 

     * @param editable The editable property to verify.

     */

    public void gdVerifyEditable(boolean editable) {

        Verifier.equals(editable, getCBAdapter().isEditable());

    }

    /**

     * Checks if the component contains the specified text.

     * @param text check if this text is in the combobox

     */

    public void gdVerifyContainsValue(final String text) {

        Verifier.equals(true, getCBAdapter().containsValue(text));

    }

    /**

     * 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 value should exist or not.

     */

    public void gdVerifyContainsValue(String value, String operator, 

            boolean exists) {        

        final boolean contains = getCBAdapter().containsValue(value, operator);

        Verifier.equals(exists, contains);

    }

    /**

     * @see org.eclipse.jubula.rc.swing.swing.implclasses.AbstractSwingImplClass#getText()

     * @return value from ComboBoxHelper

     */

    protected String getText() {

        return getCBAdapter().getText();

    }

    /**

     * {@inheritDoc}

     */

    public void gdInputText(String text) {        

        getCBAdapter().input(text, false);

    }

    /**

     * {@inheritDoc}

     */

    public void gdReplaceText(String text) throws StepExecutionException {

        getCBAdapter().input(text, true);

    }

    /**

     * Selects <code>index</code> in the combobox.

     *

     * @param index

     *            The index to select

     */

    public void gdSelectIndex(String index) {

        int implIdx = IndexConverter.toImplementationIndex(

                IndexConverter.intValue(index)); 

        getCBAdapter().select(implIdx);

    }

    /**

     * Selects a value from the list of the combobox

     * @param valueList The value or list of values to (not)select

     * @param operator if regular expressions are used

     * @param searchType Determines where the search begins ("relative" or "absolute")

     */

    public void gdSelectValue(String valueList, String operator,

        final String searchType) {

        gdSelectValue(valueList, String.valueOf(VALUE_SEPARATOR), operator,

            searchType);

    }

    /**

     * Selects a value from the list of the combobox

     *

     * @param valueList

     *            the item(s) which should be (not)selected.

     * @param separator

     *            The seperator if <code>text</code> is an enumeration of

     *            values. Not supported by this implementation class

     * @param operator

     *            if regular expressions are used

     * @param searchType

     *            Determines where the search begins ("relative" or "absolute")

     */

    private void gdSelectValue(String valueList, String separator,

        String operator, final String searchType) {

        String[] values = split(valueList, separator);

        getCBAdapter().select(values, operator, searchType);

    }

    /**

     * Verifies if the combobox has <code>index</code> selected.

     * @param index The index to verify

     * @param isSelected If the index should be selected or not.

     */

    public void gdVerifySelectedIndex(String index, boolean isSelected) {

        int implIdx = IndexConverter.toImplementationIndex(

                IndexConverter.intValue(index));

        int actual = getCBAdapter().getSelectedIndex();

        Verifier.equals(implIdx, actual, isSelected);

    }

    /**

     * Verifies if the passed text is currently selected in the combobox.

     * @param text The text to verify.

     */

    public void gdVerifyText(String text) {

        gdVerifyText(text, MatchUtil.DEFAULT_OPERATOR);

    }

    /**

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

        return list;

    }

}

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

    /** The default separator for enumerations of list values. */

    protected static final char INDEX_LIST_SEP_CHAR = 

        TestDataConstants.VALUE_CHAR_DEFAULT;

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

 * Copyright (c) 2012 BREDEX GmbH.

 * All rights reserved. This program and the accompanying materials

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

 * which accompanies this distribution, and is available at

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

 *

 * Contributors:

 *     BREDEX GmbH - initial API and implementation 

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

package org.eclipse.jubula.rc.common.uiadapter.interfaces;

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

/**

 * This interface holds all methods which are needed to test

 * ComboBox like components.

 * @author BREDEX GmbH

 *

 */

public interface IComboBoxAdapter extends ITextVerifiable {

    /**

     * 

     * @return the value if the Text Component is editable

     */

    boolean isEditable();

    /**

     * @param value The value to check

     * @param operator The operator used to verify

     * @return <code>true</code> if the combobox contains an element rendered with the passed value

     */

    public boolean containsValue(String value, String operator);

    /**

     * @param value The value to check

     * @return <code>true</code> if the combobox contains an element rendered with the passed value

     */

    public boolean containsValue(String value);

    /**

     * select the whole text of  the textfield by clicking three times.

     */

    void selectAll();

    /**

     * @return The currently selected index for the combo box, or -1 if no

     *          index is currently selected.

     */

    public int getSelectedIndex();

    /**

     * Selects the combobox element with the passed index.

     * @param index The index to select

     */

    public void select(int index);

    /**

     * Selects the specified item in the combobox.

     * @param values the values which should be (not) selected

     * @param operator if regular expressions are used

     * @param searchType Determines where the search begins ("relative" or "absolute")

     * @throws StepExecutionException if an error occurs during selecting the item

     * @throws IllegalArgumentException if <code>component</code> or <code>text</code> are null

     */

    public void select(final String[] values, String operator,

        String searchType)

        throws StepExecutionException, IllegalArgumentException; 

    /**

     * Inputs <code>text</code> to <code>component</code>.<br> 

     * @param text the text to type

     * @param replace whether to replace the text or not

     * @throws StepExecutionException if an error occurs during typing <code>text</code>

     * @throws IllegalArgumentException if <code>component</code> or <code>text</code> are null

     */

    public void input(String text, boolean replace)

        throws StepExecutionException, IllegalArgumentException;

}

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.swing.driver.RobotFactoryConfig;

    /**

     * The robot factory.

     */

    private static IRobotFactory robotFactory;

     * Casts the passed renderer component to a known type and extracts the

     * rendered text.

     *

     * @param renderer

     *            The renderer.

     * @param queueInEventThread

     *            If <code>true</code>, the text extraction is executed in

     *            the event queue thread.

     * @return The rendered text.

     * @throws StepExecutionException

     *             If the passed renderer is not supported. Supported types are

     *             <code>JLabel</code>, <code>JToggleButton</code>,

     *             <code>AbstractButton</code> and <code>JTextComponent</code>

     *

     */

    public static String getRenderedText(final Component renderer,

        boolean queueInEventThread) throws StepExecutionException {

        if (queueInEventThread) {

            return (String)getEventThreadQueuer().invokeAndWait(

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

                    public Object run() {

                        return getRenderedText(renderer);

                    }

                });

        }

        return getRenderedText(renderer);

    }

    /**

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

 * Copyright (c) 2012 BREDEX GmbH.

 * All rights reserved. This program and the accompanying materials

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

 * which accompanies this distribution, and is available at

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

 *

 * Contributors:

 *     BREDEX GmbH - initial API and implementation 

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

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

import java.awt.Component;

import java.awt.Container;

import java.awt.Dimension;

import java.awt.Rectangle;

import java.util.Arrays;

import javax.accessibility.Accessible;

import javax.accessibility.AccessibleContext;

import javax.swing.ComboBoxEditor;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JList;

import javax.swing.JPopupMenu;

import javax.swing.SwingUtilities;

import org.apache.commons.lang.Validate;

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

import org.eclipse.jubula.rc.swing.swing.caps.CapUtil;

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

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;

/**

 * Implementation of the Interface <code>IComboBoxAdapter</code> as a

 * adapter for the <code>JComboBox</code> component.

 * @author BREDEX GmbH

 *

 */

public class JComboBoxAdapter extends WidgetAdapter implements

        IComboBoxAdapter {

    /**

     * <code>INVALID_MAX_WIDTH</code>

     */

    public static final int NO_MAX_WIDTH = -1;

    /**   */

    private JComboBox m_comboBox;

    /**

     * 

     * @param objectToAdapt 

     */

    public JComboBoxAdapter(Object objectToAdapt) {

        super(objectToAdapt);

        m_comboBox = (JComboBox) objectToAdapt;

    }

    /**

     * {@inheritDoc}

     */

    public String getText() {

        String comboBoxText;

        if (m_comboBox.isEditable()) { 

            comboBoxText = CapUtil.getRenderedText(

                    getComboBoxEditorComponent(m_comboBox), true);

        } else {

            final int selIndex = m_comboBox.getSelectedIndex();

            if (selIndex == -1) {

                comboBoxText = String.valueOf(

                        m_comboBox.getSelectedItem());

            } else {

                final JList jlist = new JList(m_comboBox.getModel());

                Object o = getEventThreadQueuer().invokeAndWait(

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

                            public Object run() {

                                Component disp = m_comboBox.getRenderer()

                                    .getListCellRendererComponent(jlist,

                                        jlist.getModel().getElementAt(selIndex),

                                        selIndex, true, m_comboBox.hasFocus());

                                return CapUtil.getRenderedText(disp, false);

                            }

                        });

                comboBoxText = String.valueOf(o);

            }

        }

        return comboBoxText;

    }

    /**

     * {@inheritDoc}

     */

    public boolean isEditable() {

        Boolean editable = (Boolean)getEventThreadQueuer().invokeAndWait("isEditable", //$NON-NLS-1$

            new IRunnable() {

                public Object run() {

                    // see findBugs

                    return m_comboBox.isEditable() 

                            ? Boolean.TRUE : Boolean.FALSE;

                }

            });

        return editable.booleanValue();

    }

    /**

     * {@inheritDoc}

     */

    public boolean containsValue(String value, String operator) {

        JListAdapter list = new JListAdapter(findJList());

        return list.containsValue(value, operator);

    }

    /**

     * {@inheritDoc}

     */

    public boolean containsValue(String value) {

        return containsValue(value, MatchUtil.EQUALS);

    }

    /**

     * select the whole text of  the textfield by clicking three times.

     */

    public void selectAll() {

        click(new Integer(1));

        getRobot().keyStroke(getRobot().getSystemModifierSpec() + " A"); //$NON-NLS-1$

    }

    /**

     * {@inheritDoc}

     */

    public int getSelectedIndex() {

        Integer actual = (Integer)getEventThreadQueuer()

                .invokeAndWait(

                    JComboBoxImplClass.class.getName() + ".getSelectedIndex", //$NON-NLS-1$

                    new IRunnable() {

                        public Object run() {

                            return new Integer(m_comboBox.getSelectedIndex());

                        }

                    });

        return actual.intValue();

    }

    /**

     * {@inheritDoc}

     */

    public void select(int index) {

        JListAdapter list = new JListAdapter(findJList());

        list.clickOnIndex(new Integer(index), ClickOptions

                .create().setClickCount(1), getMaxWidth());

    }

    /**

     * Selects the specified item in the combobox.

     * @param values the values which should be (not) selected

     * @param operator if regular expressions are used

     * @param searchType Determines where the search begins ("relative" or "absolute")

     * @throws StepExecutionException if an error occurs during selecting the item

     * @throws IllegalArgumentException if <code>component</code> or <code>text</code> are null

     */

    public void select(final String[] values, String operator,

        String searchType)

        throws StepExecutionException, IllegalArgumentException {

        try {

            for (int i = 0; i < values.length; i++) {

                String text = values[i];

                Validate.notNull(text, "text must not be null"); //$NON-NLS-1$

            }

            JListAdapter list = new JListAdapter(findJList());

            Integer[] indices = list.findIndicesOfValues(values,

                    operator, searchType);

            Arrays.sort(indices);

            if (indices.length == 0) {

                throw new StepExecutionException("Text '" + Arrays.asList(values).toString() //$NON-NLS-1$

                    + "' not found", //$NON-NLS-1$

                    EventFactory.createActionError(TestErrorEvent.NOT_FOUND));

            }

            list.clickOnIndex(indices[0], ClickOptions

                    .create().setClickCount(1), getMaxWidth());

        } catch (StepExecutionException e) {

            m_comboBox.hidePopup();

            throw e;

        } catch (IllegalArgumentException e) {

            m_comboBox.hidePopup();

            throw e;

        }

    }

    /**

     * Inputs <code>text</code> to <code>component</code>.<br>

     * @param text the text to type in

     * @param replace whether to rplace the text or not

     * @throws StepExecutionException if an error occurs during typing <code>text</code>

     * @throws IllegalArgumentException if <code>component</code> or <code>text</code> are null

     */

    public void input(String text, boolean replace)

        throws StepExecutionException, IllegalArgumentException {

        Validate.notNull(text, "text must not be null"); //$NON-NLS-1$

        Component editor = getComboBoxEditorComponent(m_comboBox);

        if (editor == null) {

            throw new StepExecutionException("could not find editor", //$NON-NLS-1$

                EventFactory.createActionError(TestErrorEvent.COMP_NOT_FOUND));

        }

        if (replace) {

            selectAll();

        }

        getRobot().type(editor, text);

    }

    /**

     * performs a <code>count</code> -click on the textfield.

     * @param count the number of clicks

     */

    public void click(Integer count) {

        Component editor = getComboBoxEditorComponent(m_comboBox);

        if (editor == null) {

            throw new StepExecutionException("no editor found", //$NON-NLS-1$

                EventFactory.createActionError(TestErrorEvent.COMP_NOT_FOUND));

        }

        getRobot().click(editor, null, ClickOptions.create().setClickCount(

                count.intValue()));

    }

    /**

     * @param component

     *            the combobox

     * @return the editor used to render and edit the selected item in the

     *         JComboBox field.

     * @throws StepExecutionException

     *             if the editor comonent could not be found

     */

    private Component getComboBoxEditorComponent(JComboBox component)

        throws StepExecutionException {

        ComboBoxEditor cbe = component.getEditor();

        if (cbe == null) {

            throw new StepExecutionException("no ComboBoxEditor found", //$NON-NLS-1$

                EventFactory.createActionError(TestErrorEvent.COMP_NOT_FOUND));

        }

        Component c = cbe.getEditorComponent();

        if (c == null) {

            throw new StepExecutionException("no EditorComponent found", //$NON-NLS-1$

                EventFactory.createActionError(TestErrorEvent.COMP_NOT_FOUND));

        }

        return c;

    }

    /**

     * Finds the <code>JList</code> of the combobox.

     * @return The list

     */

    private JList findJList() {

        JList list = (JList)getComponentViaHierarchy(openPopupMenu(),

                JList.class);

        if (list == null) {

            throw new StepExecutionException("list component not found", //$NON-NLS-1$

                EventFactory.createActionError(TestErrorEvent.COMP_NOT_FOUND));

        }

        return list;

    }

    /**

     * Opens the combobox popup menu and returns the popup instance. May also be

     * called if the popup is already visible

     * @return The popup menu

     */

    private JPopupMenu openPopupMenu() {

        if (!isPopupVisible()) {

            Component c = getComponentViaHierarchy(m_comboBox, JButton.class);

            Rectangle r = null;

            if ((c == null) && (!m_comboBox.isEditable())) {

                c = m_comboBox;

            } else if ((c == null) && (m_comboBox.isEditable())) {

                c = m_comboBox;

                r = findArrowIconArea();

            }

//            if (log.isDebugEnabled()) {

//                log.debug("Opening popup by clicking on: " + c); //$NON-NLS-1$

//            }

            getRobot().click(c, r);

        }

        if (!isPopupVisible()) {

//            log.debug("Dropdown list still not visible, must be an error"); //$NON-NLS-1$

            throw new StepExecutionException("dropdown list not visible", //$NON-NLS-1$

                EventFactory.createActionError(

                        TestErrorEvent.DROPDOWN_LIST_NOT_FOUND));

        }

        return getPopupMenu(m_comboBox);

    }

    /**

     * Tries to find the popup menu from the combobox

     * @param component the combobox

     * @return the popup of the combobox

     * @throws StepExecutionException if the popup could not be found

     */

    private JPopupMenu getPopupMenu(JComboBox component)

        throws StepExecutionException {

        AccessibleContext ac = component.getAccessibleContext();

        for (int i = 0; i < ac.getAccessibleChildrenCount(); i++) {

            Accessible a = ac.getAccessibleChild(i);

            if (a instanceof JPopupMenu) {

                return (JPopupMenu)a;

            }

        }

        throw new StepExecutionException("cannot find dropdown list", //$NON-NLS-1$

            EventFactory.createActionError(

                    TestErrorEvent.DROPDOWN_LIST_NOT_FOUND));

    }

    /**

     * Tries to find the component in the component hierarchy

     * @param component where to search

     * @param c type of the component which should be found

     * @return the desired component

     */

    private Component getComponentViaHierarchy(Container component, Class c) {

        Component[] comps = component.getComponents();

        for (int i = 0; i < comps.length; i++) {

            if (c.isInstance(comps[i])) {

                return comps[i];

            }

        }

        for (int i = 0; i < comps.length; i++) {

            if (comps[i] instanceof Container) {

                Component ct = getComponentViaHierarchy((Container)comps[i], c);

                if (ct != null) {

                    return ct;

                }

            }

        }

        return null;

    }

    /**

     * @return true, if the popup of the combobox is visible

     */

    private boolean isPopupVisible() {

        Boolean visible = (Boolean)getEventThreadQueuer().invokeAndWait(

            JComboBoxHelper.class.getName()

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

                public Object run() throws StepExecutionException {

                    return m_comboBox.isPopupVisible()

                        ? Boolean.TRUE : Boolean.FALSE;

                }

            });

        return visible.booleanValue();

    }

    /**

     * @return a rectangle, where the arrow icon is expected.

     */

    private Rectangle findArrowIconArea() {

        JComboBox comboBox = m_comboBox;

        Component editor = getComboBoxEditorComponent(comboBox);

        Rectangle r = null;

        if (editor == null) {

            throw new StepExecutionException("could not find editor", //$NON-NLS-1$

                EventFactory.createActionError(TestErrorEvent.COMP_NOT_FOUND));

        }

        Rectangle ra[] =

            SwingUtilities.computeDifference(comboBox.getBounds(),

                editor.getBounds());

        if ((ra == null) || (ra.length < 1)) {

            throw new StepExecutionException("could not arrow icon", //$NON-NLS-1$

                EventFactory.createActionError(TestErrorEvent.COMP_NOT_FOUND));

        }

        r = ra[0];

        // find the largest area of the returned rectangles.

        double bestAreaIndex = Double.MAX_VALUE;

        for (int i = 0; i < ra.length; i++) {

            if ((ra[i].height > 0) && (ra[i].width > 0)) {

                double areaIndex = ((double)ra[i].width) / ra[i].height - 1.0;

                if (areaIndex < 0) {

                    areaIndex *= (-1);

                }

                if (areaIndex < bestAreaIndex) {

                    bestAreaIndex = areaIndex;

                    r = ra[i];

                }

            }

        }

        return r;

    }

    /**

     * @return the maximal width for the selection; -1 if none available

     * e.g. the preferred width of the combo box itself is 100 pixel although

     * the preferred size of the embedded items is more than two times bigger

     * --> click outside of component (JList) #3013 

     */

    private double getMaxWidth() {

        double maxWidth = NO_MAX_WIDTH;

        Dimension d = m_comboBox.getPreferredSize();

        if (d != null) {

            maxWidth = d.getWidth();

        }

        return maxWidth;

    }

}

import javax.swing.JComboBox;

import org.eclipse.jubula.rc.swing.swing.uiadapter.JComboBoxAdapter;

        } else if (objectToAdapt instanceof JComboBox) {

            returnvalue = new JComboBoxAdapter(objectToAdapt);

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

 * Copyright (c) 2012 BREDEX GmbH.

 * All rights reserved. This program and the accompanying materials

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

 * which accompanies this distribution, and is available at

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

 *

 * Contributors:

 *     BREDEX GmbH - initial API and implementation 

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

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

import java.util.Arrays;

import java.util.HashSet;

import java.util.Set;

import org.apache.commons.lang.Validate;

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

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

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

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

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

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

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

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

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

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

import org.eclipse.swt.SWT;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Widget;

/**

 * Implementation of the Interface <code>IComboBoxAdapter</code> as a abstract

 * adapter for the swt comboboxes.

 * This class needs specific methods of its subclasses therefore it is abstract.

 * 

 * @author BREDEX GmbH

 *

 */

public abstract class AbstractComboBoxAdapter extends WidgetAdapter 

    implements IComboBoxAdapter {

    /** number of clicks to give focus without selecting any text */

    public static final int CLICK_COUNT_FOR_SELECTING_NONE = 3;

    /** the logger */

    private static AutServerLogger log = new AutServerLogger(

        AbstractComboBoxAdapter.class);

    /**

     * 

     * @param objectToAdapt 

     */

    protected AbstractComboBoxAdapter(Object objectToAdapt) {

        super(objectToAdapt);

    }

    /**

     * {@inheritDoc}

     */

    public void select(final String[] values, String operator, 

        final String searchType) 

        throws StepExecutionException, IllegalArgumentException {

        for (int i = 0; i < values.length; i++) {

            String text = values[i];

            Validate.notNull(text, "text must not be null"); //$NON-NLS-1$

        }

        Integer[] indices = findIndicesOfValues(values, 

                operator, searchType);

        Arrays.sort(indices);

        if (indices.length == 0) {

            throw new StepExecutionException("Text '" + Arrays.asList(values).toString() //$NON-NLS-1$ 

                + "' not found", //$NON-NLS-1$ 

                EventFactory.createActionError(TestErrorEvent.NOT_FOUND));

        }

        select(indices[0].intValue());

    }

    /**

     * {@inheritDoc}

     */

    public void select(int index) {

        int comboItemCount = getItemCount();

        if (index >= comboItemCount

            || index < 0) {

            throw new StepExecutionException("Combo Box index '" + index //$NON-NLS-1$

                + "' is out of range", //$NON-NLS-1$

                EventFactory.createActionError(TestErrorEvent.INVALID_INDEX));

        }

        if (isComboEnabled()) {

            // FIXME zeb: Needs special handling if style is not DROP_DOWN

            openDropdownList();

            selectImpl(index);

        }

    }

    /**

     * @return <code>true</code> if the combo box is currently enabled.

     */

    protected abstract boolean isComboEnabled();

    /**

     * 

     * @param index idx

     */

    protected abstract void selectImpl(int index);

    /**

     * Opens the combobox dropdown list. May also be

     * called if the list is already visible.

     */

    protected abstract void openDropdownList();

    /**

     * 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

     */

    private Integer[] findIndicesOfValues(final String [] values, 

            final String operator, final String searchType) {

        final Set indexSet = new HashSet();

        for (int i = getStartingIndex(searchType); 

                i < getItemCount(); 

                ++i) {

            String str = getItem(i);

            if (MatchUtil.getInstance().

                match(str, values, operator)) {

                indexSet.add(new Integer(i));

            }

        }

        Integer[] indices = new Integer[indexSet.size()];

        indexSet.toArray(indices);

        return indices;

    }

    /**

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

     */

    private int getStartingIndex(final String searchType) {

        int startingIndex = 0;

        if (searchType.equalsIgnoreCase(

                CompSystemConstants.SEARCH_TYPE_RELATIVE)) {

            startingIndex = getSelectedIndex();

        }

        return startingIndex;

    }

    /**

     * {@inheritDoc}

     */

    public boolean containsValue(String value, String operator) {

        Integer[] indices = null;

        if (operator.equals(MatchUtil.NOT_EQUALS)) {

            indices = findIndicesOfValues(new String[] { value },

                MatchUtil.EQUALS, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);

            return indices.length == 0;

        } 

        indices = findIndicesOfValues(new String[] { value },

            operator, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);

        return indices.length > 0;

    }

    /**

     * {@inheritDoc}

     */

    public boolean containsValue(String value) {

        return containsValue(value, MatchUtil.EQUALS);

    }

    /**

     * Returns the number of items contained in the combo list.

     * @return  the number of items.

     */

    protected abstract int getItemCount();

    /**

     * Returns the item at the given, zero-relative index in the combo list. 

     * Throws an exception if the index is out of range.

     * @param index the index of the item to return

     * @return  the item at the given index

     */

    protected abstract String getItem(final int index);

    /**

     * {@inheritDoc}

     */

    public void input(String text, boolean replace)

        throws StepExecutionException, IllegalArgumentException {

        Validate.notNull(text, "text must not be null"); //$NON-NLS-1$

        Control editor = (Control) getRealComponent();

        if (editor == null) {

            throw new StepExecutionException("could not find editor", //$NON-NLS-1$

                EventFactory.createActionError(TestErrorEvent.COMP_NOT_FOUND));

        }

        if (replace) {

            selectAll();

        } else {

            selectNone();

        }

        getRobot().type(editor, text);

        getRobot().keyType(null, SWT.KEYPAD_CR);

    }

    /**

     * {@inheritDoc}

     */

    public void click(Integer count) {

        Control editor = (Control) getRealComponent();

        if (editor == null) {

            throw new StepExecutionException("no editor found", //$NON-NLS-1$

                EventFactory.createActionError(TestErrorEvent.COMP_NOT_FOUND));

        }

        getRobot().click(editor, null, ClickOptions.create().setClickCount(

                count.intValue()));

    }

    /**

     * Give the text field focus without selecting any of the text.

     */

    public void selectNone() {

        // FIXME zeb: This places the caret at the center of the component, 

        //            which may or may not be correct. Where should the text

        //            be inserted?

        click(new Integer(

            CLICK_COUNT_FOR_SELECTING_NONE));

    }

    /**

     * Toggles the combobox dropdown list by clicking on the combo box.

     */

    protected void toggleDropdownList() {

        // Click in the center of the pulldown button

        Rectangle r = findArrowIconArea();

        if (log.isDebugEnabled()) {

            log.debug("Toggling dropdown by clicking on rectangle: " + r  //$NON-NLS-1$

                + "within component: " + getRealComponent()); //$NON-NLS-1$

        }

        getRobot().click(getRealComponent(), r,

            ClickOptions.create().setScrollToVisible(false)

                .setConfirmClick(false));

    }

    /**

     * @return a rectangle, where the arrow icon is expected, relative to the

     *         combo box's location.

     */

    protected Rectangle findArrowIconArea() {

        final Control editor = (Control) getRealComponent();

        Rectangle r = null;

        if (editor == null) {

            throw new StepExecutionException("could not find editor", //$NON-NLS-1$

                EventFactory.createActionError(TestErrorEvent.COMP_NOT_FOUND));

        }

        r = (Rectangle)getEventThreadQueuer().invokeAndWait(

             AbstractComboBoxAdapter.class.getName()

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

                public Object run() throws StepExecutionException {

                    return SwtUtils.getRelativeWidgetBounds(editor, editor);

                }

            });

        // Assume that the arrow icon is approximately square

        r.x += r.width - r.height;

        r.width = r.height;

        return r;

    }

    /**

     * @return true, if combo is not read_only

     */

    private boolean isComboEditable() {

        Integer comboStyle = (Integer)getEventThreadQueuer().invokeAndWait(

            AbstractComboBoxAdapter.class.getName()

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

                public Object run() throws StepExecutionException {

                    return new Integer(((Widget)getRealComponent()).getStyle());

                }

            });

        return ((comboStyle.intValue() & SWT.READ_ONLY) == 0);

    }

    /**

     * {@inheritDoc}

     */

    public boolean isEditable() {

        return isComboEditable();

    }

}

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

 * Copyright (c) 2012 BREDEX GmbH.

 * All rights reserved. This program and the accompanying materials

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

 * which accompanies this distribution, and is available at

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

 *

 * Contributors:

 *     BREDEX GmbH - initial API and implementation 

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

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

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

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

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

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

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

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

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

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

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

import org.eclipse.swt.custom.CCombo;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.List;

import org.eclipse.swt.widgets.Shell;

/**

 * Implementation of the Interface <code>IComboBoxAdapter</code> as a

 * adapter for the <code>CCombo</code> component.

 * This class is sub classing <code>AbstractComboBoxAdapter</code> because

 * <code>Combo</code> and <code>CCombo</code> have common parts

 * @author BREDEX GmbH

 *

 */

public class CComboAdapter extends AbstractComboBoxAdapter {

    /** the logger */

    private static AutServerLogger log = new AutServerLogger(

        CComboAdapter.class);

    /** */

    private CCombo m_combobox;

    /**

     * 

     * @param objectToAdapt 

     */

    public CComboAdapter(Object objectToAdapt) {

        super(objectToAdapt);

        m_combobox = (CCombo) objectToAdapt;

    }

    /**

     * {@inheritDoc}

     */

    public void selectAll() {

        // Get focus

        selectNone();

        // FIXME zeb: Find a platform-independant way to select all text

        //            without calling CCombo methods directly.

        //            The current problem with clicking twice in the text area

        //            is that if there is any white space, only part of the

        //            text is selected.

        getEventThreadQueuer().invokeAndWait("selectAll",  //$NON-NLS-1$

            new IRunnable() {

                public Object run() throws StepExecutionException {

                    m_combobox.setSelection(

                            new Point(0, m_combobox.getText().length()));

                    // return value is not used

                    return null;

                }

            });

    }

    /**

     * {@inheritDoc}

     */

    public int getSelectedIndex() {    

        int selectedIndex = ((Integer)getEventThreadQueuer().invokeAndWait(

                CComboAdapter.class.getName()

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

                    public Object run() throws StepExecutionException {

                        return new Integer(m_combobox.getSelectionIndex());

                    }

                })).intValue();

        return selectedIndex;

    }

    /**

     * {@inheritDoc}

     */

    public String getText() {

        Object o = getEventThreadQueuer().invokeAndWait(

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

                    public Object run() {

                        return m_combobox.getText();

                    }

                });

        return o != null ? o.toString() : null;

    }

    /**

     * {@inheritDoc}

     */

    protected boolean isComboEnabled() {        

        boolean isEnabled = ((Boolean)getEventThreadQueuer().invokeAndWait(

                CComboAdapter.class.getName()

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

                    public Object run() throws StepExecutionException {

                        return m_combobox.isEnabled() 

                                ? Boolean.TRUE : Boolean.FALSE;

                    }

                })).booleanValue();

        return isEnabled;

    }

    /**

     * {@inheritDoc}

     */

    protected void selectImpl(final int index) {

        scrollIndexToVisible(index);

        Rectangle clickConstraints = 

            (Rectangle)getEventThreadQueuer().invokeAndWait(

                "setClickConstraints",  //$NON-NLS-1$

                new IRunnable() {

                    public Object run() throws StepExecutionException {

                        Rectangle constraints = 

                            SwtUtils.getRelativeWidgetBounds(

                                    getDropdownList(), getDropdownList());

                        int displayedItemCount = getDisplayedItemCount();

                        int numberBelowTop = 0;

                        if (displayedItemCount >= getItemCount()) {

                            numberBelowTop = index;

                        } else {

                            numberBelowTop = Math.max(0, index 

                                - getItemCount() + displayedItemCount);

                        }

                        // Set the constraints based on the numberBelowTop

                        constraints.height = getDropdownList().getItemHeight();

                        constraints.y += (numberBelowTop * constraints.height);

                        return constraints;

                    }

                });

        // Note that we set scrollToVisible false because we have already done

        // the scrolling.

        getRobot().click(getDropdownList(), clickConstraints, 

            new ClickOptions().setScrollToVisible(false));

    }

    /**

     * {@inheritDoc}

     */

    protected void openDropdownList() {

        if (!isDropdownVisible()) {

            toggleDropdownList();

        }

        long timeout = TimeoutConstants.SERVER_TIMEOUT_WAIT_FOR_POPUP;

        long done = System.currentTimeMillis() + timeout; 

        long now;

        while (!isDropdownVisible() && timeout >= 0) {

            RobotTiming.sleepPreShowPopupDelay();

            now = System.currentTimeMillis();

            timeout = done - now;

        }

        if (!isDropdownVisible()) {

            log.debug("Dropdown list still not visible, must be an error"); //$NON-NLS-1$

            throw new StepExecutionException("dropdown list not visible", //$NON-NLS-1$

                EventFactory.createActionError(

                        TestErrorEvent.DROPDOWN_LIST_NOT_FOUND));

        }

    }

    /**

     * Returns the number of items contained in the combo list.

     * @return  the number of items.

     */

    protected int getItemCount() {

        return ((Integer)getEventThreadQueuer().invokeAndWait(

                "getItemCount", //$NON-NLS-1$

                new IRunnable() {

                    public Object run() {

                        return new Integer(m_combobox.getItemCount()); 

                    }

                })).intValue();

    }

    /**

     * Returns the item at the given, zero-relative index in the combo list. 

     * Throws an exception if the index is out of range.

     * @param index the index of the item to return

     * @return  the item at the given index

     */

    protected String getItem(final int index) {

        return (String)getEventThreadQueuer().invokeAndWait(

                "getItem", //$NON-NLS-1$

                new IRunnable() {

                    public Object run() {

                        return m_combobox.getItem(index); 

                    }

                });

    }

    /**

     * Tries to find the dropdown list from the combobox 

     * @return the dropdown of the combobox, or <code>null</code> if the 

     *          dropdown could not be found

     */

    protected List getDropdownList()

        throws StepExecutionException {

        return (List)getEventThreadQueuer().invokeAndWait(

            "getDropdownList",  //$NON-NLS-1$

            new IRunnable() {

                public Object run() throws StepExecutionException {

                    Shell mainShell = SwtUtils.getShell(m_combobox);

                    Display d = Display.getCurrent();

                    Shell [] shells = d.getShells();

                    for (int i = 0; i < shells.length; i++) {

                        Shell curShell = shells[i];

                        if (mainShell == curShell.getParent() 

                            && curShell.getChildren().length == 1

                            && curShell.getChildren()[0] instanceof List) {

                            List possibleDropdown = 

                                (List)curShell.getChildren()[0];

                            if (!possibleDropdown.isDisposed()

                                    && possibleDropdown.isVisible()

                                    && isDropdownList(possibleDropdown)) {

                                return possibleDropdown;

                            }

                        }

                    }

                    return null;

                }

            });

    }

    /**

     * Verifies that the given list is the dropdown list for this combo box.

     * 

     * @param list  The list to verify.

     * @return <code>true</code> if <code>list</code> is the dropdown list for

     *          this combo box. Otherwise <code>false</code>.

     */

    private boolean isDropdownList(List list) {

        /*

         * Verify that the list is close enough to the combo box.

         */

        Rectangle comboBounds = 

            SwtUtils.getWidgetBounds(m_combobox);

        Rectangle listBounds = SwtUtils.getWidgetBounds(list);

        // Expand the bounding rectangle for the combo box by a small amount

        int posFuzz = 5;

        int dimFuzz = posFuzz * 2;

        comboBounds.x -= posFuzz;

        comboBounds.width += dimFuzz;

        comboBounds.y -= posFuzz;

        comboBounds.height += dimFuzz;

        return comboBounds.intersects(listBounds);

    }

    /**

     * Tries to set the given index as the top element of the CCombo.

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

                    getDropdownList().setTopIndex(index);

                    return null;

                }

            });

    }

    /**

     * 

     * @return  the number of items displayed in the dropdown list, or 0 if

     *          the list is not showing.

     */

    private int getDisplayedItemCount() {

        return ((Integer)getEventThreadQueuer().invokeAndWait(

                "getDisplayedItemCount",  //$NON-NLS-1$

                new IRunnable() {

                public Object run() throws StepExecutionException {

                    List dropdown = getDropdownList();

                    if (dropdown == null) {

                        return new Integer(0);

                    }

                    int listHeight = SwtUtils.getWidgetBounds(dropdown).height;

                    int itemHeight = dropdown.getItemHeight();

                    return new Integer(listHeight / itemHeight);

                }

            })).intValue();

    }

    /**

     * @return true, if the dropdown of the combobox is visible

     */

    protected boolean isDropdownVisible() {

        Boolean visible = (Boolean)getEventThreadQueuer().invokeAndWait(

            CComboAdapter.class.getName()

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

                public Object run() throws StepExecutionException {

                    List dropdownList = getDropdownList();

                    return dropdownList != null

                        ? Boolean.TRUE : Boolean.FALSE;

                }

            });

        return visible.booleanValue();

    }    

}

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

 * Copyright (c) 2012 BREDEX GmbH.

 * All rights reserved. This program and the accompanying materials

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

 * which accompanies this distribution, and is available at

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

 *

 * Contributors:

 *     BREDEX GmbH - initial API and implementation 

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

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

import org.apache.commons.lang.StringUtils;

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

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

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

import org.eclipse.swt.SWT;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.swt.widgets.Event;

/**

 * Implementation of the Interface <code>IComboBoxAdapter</code> as a

 * adapter for the <code>Combo</code> component.

 * This class is sub classing <code>AbstractComboBoxAdapter</code> because

 * <code>Combo</code> and <code>CCombo</code> have common parts

 * 

 * @author BREDEX GmbH

 *

 */

public class ComboAdapter extends AbstractComboBoxAdapter {

    /**  */

    private Combo m_combobox;

    /**

     * 

     * @param objectToAdapt 

     */

    public ComboAdapter(Object objectToAdapt) {

        super(objectToAdapt);

        m_combobox = (Combo) objectToAdapt;

    }

    /**

     * Select the whole text of the textfield.

     */

    public void selectAll() {

        click(new Integer(1));

        // fix for https://bxapps.bredex.de/bugzilla/show_bug.cgi?id=201

        // The keystroke "command + a" sometimes causes an "a" to be entered

        // into the text field instead of selecting all text (or having no 

        // effect).

        if (EnvironmentUtils.isMacOS()) {

            getEventThreadQueuer().invokeAndWait("combo.selectAll", //$NON-NLS-1$

                new IRunnable() {

                    public Object run() {

                        int textLength = StringUtils.length(

                                m_combobox.getText());

                        m_combobox.setSelection(new Point(0, textLength));

                        return null;

                    }

                });

        } else {

            getRobot().keyStroke(getRobot().getSystemModifierSpec() + " A"); //$NON-NLS-1$

        }

    }

    /**

     * {@inheritDoc}

     */

    public int getSelectedIndex() {

        int selectedIndex = ((Integer)getEventThreadQueuer().invokeAndWait(

                ComboAdapter.class.getName()

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

                    public Object run() throws StepExecutionException {

                        return new Integer(m_combobox.getSelectionIndex());

                    }

                })).intValue();

        return selectedIndex;

    }

    /**

     * {@inheritDoc}

     */

    public String getText() {

        Object o = getEventThreadQueuer().invokeAndWait(

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

                    public Object run() {

                        return m_combobox.getText();

                    }

                });

        return o != null ? o.toString() : null;        

    }

    /**

     * 

     * {@inheritDoc}

     */

    protected boolean isComboEnabled() {

        boolean isEnabled = ((Boolean)getEventThreadQueuer().invokeAndWait(

                ComboAdapter.class.getName()

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

                    public Object run() throws StepExecutionException {

                        return m_combobox.isEnabled() 

                                ? Boolean.TRUE : Boolean.FALSE;

                    }

                })).booleanValue();

        return isEnabled;

    }

    /**

     * {@inheritDoc}

     */

    protected void selectImpl(int index) {

        // Press 'Escape' key to close the dropdown list

        getRobot().keyType(m_combobox, SWT.ESC);

        // Currently no method to select elements via mouse clicks 

        selectComboIndex(index);

    }

    /**

     * 

     * {@inheritDoc}

     */

    protected void openDropdownList() {

        // FIXME zeb: Figure out a way to check the status of the dropdown list

        toggleDropdownList();

    }

    /**

     * Returns the number of items contained in the combo list.

     * @return  the number of items.

     */

    protected int getItemCount() {

        return ((Integer)getEventThreadQueuer().invokeAndWait(

                "getItemCount", //$NON-NLS-1$

                new IRunnable() {

                    public Object run() {

                        return new Integer(m_combobox.getItemCount()); 

                    }

                })).intValue();

    }

    /**

     * Returns the item at the given, zero-relative index in the combo list. 

     * Throws an exception if the index is out of range.

     * @param index the index of the item to return

     * @return  the item at the given index

     */

    protected String getItem(final int index) {

        return (String)getEventThreadQueuer().invokeAndWait(

                "getItem", //$NON-NLS-1$

                new IRunnable() {

                    public Object run() {

                        return m_combobox.getItem(index); 

                    }

                });

    }

    /**

     * 

     * @param index the index to select.

     * @see Combo#select(int)

     */

    private void selectComboIndex(final int index) {

        final Combo combo = m_combobox;

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

            public Object run() throws StepExecutionException {

                combo.select(index);

                Event selectionEvent = new Event();

                selectionEvent.type = SWT.Selection;

                selectionEvent.widget = combo;

                combo.notifyListeners(SWT.Selection, selectionEvent);

                return null;

            }

        });   

    }

}

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

import org.eclipse.jubula.rc.swt.uiadapter.CComboAdapter;

import org.eclipse.jubula.rc.swt.uiadapter.ComboAdapter;

import org.eclipse.swt.custom.CCombo;

import org.eclipse.swt.widgets.Combo;

        } else if (objectToAdapt instanceof Combo) {

            returnvalue = new ComboAdapter(objectToAdapt);

        } else if (objectToAdapt instanceof CCombo) {

            returnvalue = new CComboAdapter(objectToAdapt);