| /* |
| * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package org.netbeans.jemmy.operators; |
| |
| import java.awt.Component; |
| import java.awt.Container; |
| import java.awt.Rectangle; |
| import java.awt.Window; |
| import java.awt.event.ActionListener; |
| import java.io.File; |
| |
| import javax.swing.ComboBoxModel; |
| import javax.swing.Icon; |
| import javax.swing.JButton; |
| import javax.swing.JComboBox; |
| import javax.swing.JComponent; |
| import javax.swing.JDialog; |
| import javax.swing.JFileChooser; |
| import javax.swing.JList; |
| import javax.swing.JTable; |
| import javax.swing.JTextField; |
| import javax.swing.JToggleButton; |
| import javax.swing.ListModel; |
| import javax.swing.filechooser.FileFilter; |
| import javax.swing.filechooser.FileSystemView; |
| import javax.swing.filechooser.FileView; |
| import javax.swing.plaf.FileChooserUI; |
| import javax.swing.table.TableModel; |
| |
| import org.netbeans.jemmy.ComponentChooser; |
| import org.netbeans.jemmy.ComponentSearcher; |
| import org.netbeans.jemmy.JemmyException; |
| import org.netbeans.jemmy.JemmyProperties; |
| import org.netbeans.jemmy.Outputable; |
| import org.netbeans.jemmy.TestOut; |
| import org.netbeans.jemmy.Timeoutable; |
| import org.netbeans.jemmy.Timeouts; |
| import org.netbeans.jemmy.Waitable; |
| import org.netbeans.jemmy.Waiter; |
| import org.netbeans.jemmy.util.LookAndFeel; |
| |
| /** |
| * |
| * Class provides methods to cover main JFileChooser component functionality. |
| * Supports choosers using either JList or JTable as the component showing files. |
| * |
| * @author Alexandre Iline (alexandre.iline@oracle.com) |
| * |
| */ |
| public class JFileChooserOperator extends JComponentOperator |
| implements Timeoutable, Outputable { |
| |
| private final static long WAIT_LIST_PAINTED_TIMEOUT = 60000; |
| |
| private Timeouts timeouts; |
| private TestOut output; |
| private ComponentSearcher innerSearcher; |
| |
| /** |
| * Constructor. |
| * |
| * @param comp a component |
| */ |
| public JFileChooserOperator(JFileChooser comp) { |
| super(comp); |
| innerSearcher = new ComponentSearcher(comp); |
| setTimeouts(JemmyProperties.getProperties().getTimeouts()); |
| setOutput(JemmyProperties.getProperties().getOutput()); |
| } |
| |
| /** |
| * Constructor. Waits component first. Constructor can be used in |
| * complicated cases when output or timeouts should differ from default. |
| * |
| * @param env an operator to get environment from. |
| */ |
| public JFileChooserOperator(Operator env) { |
| this((JFileChooser) waitComponent(JDialogOperator. |
| waitJDialog(new JFileChooserJDialogFinder(env.getOutput()), |
| 0, |
| env.getTimeouts(), |
| env.getOutput()), |
| new JFileChooserFinder(), |
| 0, |
| env.getTimeouts(), |
| env.getOutput())); |
| copyEnvironment(env); |
| } |
| |
| /** |
| * Constructor. Waits component first. |
| */ |
| public JFileChooserOperator() { |
| this(getEnvironmentOperator()); |
| } |
| |
| /** |
| * Searches currently opened JDilog with JFileChooser inside. |
| * |
| * @return a component instance |
| */ |
| public static JDialog findJFileChooserDialog() { |
| return (JDialogOperator. |
| findJDialog(new JFileChooserJDialogFinder(JemmyProperties. |
| getCurrentOutput()))); |
| } |
| |
| /** |
| * Waits currently opened JDilog with JFileChooser inside. |
| * |
| * @return a component instance |
| */ |
| public static JDialog waitJFileChooserDialog() { |
| return (JDialogOperator. |
| waitJDialog(new JFileChooserJDialogFinder(JemmyProperties. |
| getCurrentOutput()))); |
| } |
| |
| /** |
| * Searches JFileChooser in container. |
| * |
| * @param cont a container |
| * @return a component instance |
| */ |
| public static JFileChooser findJFileChooser(Container cont) { |
| return (JFileChooser) findComponent(cont, new JFileChooserFinder()); |
| } |
| |
| /** |
| * Searches JFileChooser in container. |
| * |
| * @param cont a container |
| * @return a component instance |
| */ |
| public static JFileChooser waitJFileChooser(Container cont) { |
| return (JFileChooser) waitComponent(cont, new JFileChooserFinder()); |
| } |
| |
| /** |
| * Searches currently opened JFileChooser. |
| * |
| * @return a component instance |
| */ |
| public static JFileChooser findJFileChooser() { |
| return findJFileChooser(findJFileChooserDialog()); |
| } |
| |
| /** |
| * Waits currently opened JFileChooser. |
| * |
| * @return a component instance |
| */ |
| public static JFileChooser waitJFileChooser() { |
| return waitJFileChooser(waitJFileChooserDialog()); |
| } |
| |
| static { |
| Timeouts.initDefault("JFileChooserOperator.WaitListPaintedTimeout", WAIT_LIST_PAINTED_TIMEOUT); |
| } |
| |
| @Override |
| public void setTimeouts(Timeouts timeouts) { |
| super.setTimeouts(timeouts); |
| this.timeouts = timeouts; |
| } |
| |
| @Override |
| public Timeouts getTimeouts() { |
| return timeouts; |
| } |
| |
| @Override |
| public void setOutput(TestOut out) { |
| output = out; |
| super.setOutput(output.createErrorOutput()); |
| if (innerSearcher != null) { |
| innerSearcher.setOutput(output.createErrorOutput()); |
| } |
| } |
| |
| @Override |
| public TestOut getOutput() { |
| return output; |
| } |
| |
| /** |
| * Returns combo box containing path (upper). |
| * |
| * @return JComboBox being used to show directories. |
| */ |
| public JComboBox<?> getPathCombo() { |
| return getCombo(0); |
| } |
| |
| /** |
| * Returns combo box containing file types (lower). |
| * |
| * @return JComboBox being used to show file types. |
| */ |
| public JComboBox<?> getFileTypesCombo() { |
| return getCombo(1); |
| } |
| |
| /** |
| * Returns approve button. |
| * |
| * @return an approve button. |
| */ |
| public JButton getApproveButton() { |
| String aText = getApproveButtonText(); |
| if (aText == null) { |
| aText = getUI().getApproveButtonText((JFileChooser) getSource()); |
| } |
| if (aText != null) { |
| return ((JButton) innerSearcher. |
| findComponent(new ButtonFinder(aText))); |
| } else { |
| throw (new JemmyException("JFileChooser.getApproveButtonText() " |
| + "and getUI().getApproveButtonText " |
| + "return null")); |
| } |
| } |
| |
| /** |
| * Returns cancel button. |
| * |
| * @return a cancel button. |
| */ |
| public JButton getCancelButton() { |
| return ((JButton) innerSearcher. |
| findComponent(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return (comp != null |
| && comp instanceof JButton |
| && comp.getParent() != null |
| && !(comp.getParent() instanceof JComboBox) |
| && ((JButton) comp).getText() != null |
| && ((JButton) comp).getText().length() != 0); |
| } |
| |
| @Override |
| public String getDescription() { |
| return "JButton"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JFileChooserOperator.getCancelButton.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }, 1)); |
| } |
| |
| /** |
| * Returns "Home" button. |
| * |
| * @return a "home" button. |
| */ |
| public JButton getHomeButton() { |
| return getNoTextButton(1); |
| } |
| |
| /** |
| * Returns "Up One Level" button. |
| * |
| * @return a "Up One Level" button. |
| */ |
| public JButton getUpLevelButton() { |
| return getNoTextButton(0); |
| } |
| |
| /** |
| * Returns a toggle button being used to switch to list view. |
| * |
| * @return a "list mode" button. |
| */ |
| public JToggleButton getListToggleButton() { |
| return getToggleButton(0); |
| } |
| |
| /** |
| * Returns a toggle button being used to switch to detals view. |
| * |
| * @return a "list mode" button. |
| */ |
| public JToggleButton getDetailsToggleButton() { |
| return getToggleButton(1); |
| } |
| |
| /** |
| * Returns field which can be used to type path. |
| * |
| * @return a text field being used for path typing. |
| */ |
| public JTextField getPathField() { |
| return ((JTextField) innerSearcher. |
| findComponent(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return (comp != null |
| && comp instanceof JTextField); |
| } |
| |
| @Override |
| public String getDescription() { |
| return "JTextField"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JFileChooserOperator.getPathField.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| })); |
| } |
| |
| /** |
| * Returns either a JList or JTable, depending on the implementation. |
| * |
| * @return a component being used to display directory content. |
| */ |
| public Component getFileList() { |
| int index = 0; |
| // In GTK and Motif L&F, there are two JLists, one is to list folders |
| // and second one one is to list files |
| if (LookAndFeel.isMotif() || LookAndFeel.isGTK()) { |
| index =1; |
| } |
| return innerSearcher. |
| findComponent(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return (comp != null |
| && (comp instanceof JList || comp instanceof JTable)); |
| } |
| |
| @Override |
| public String getDescription() { |
| return "JList or JTable used to show list of files"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JFileChooserOperator.getFileList.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }, index); |
| } |
| |
| /** |
| * Pushes approve button. |
| */ |
| public void approve() { |
| getQueueTool().waitEmpty(); |
| output.printTrace("Push approve button in JFileChooser\n : " |
| + toStringSource()); |
| JButtonOperator approveOper = new JButtonOperator(getApproveButton()); |
| approveOper.copyEnvironment(this); |
| approveOper.setOutput(output.createErrorOutput()); |
| approveOper.push(); |
| } |
| |
| /** |
| * Pushes cancel button. |
| */ |
| public void cancel() { |
| output.printTrace("Push cancel button in JFileChooser\n : " |
| + toStringSource()); |
| JButtonOperator cancelOper = new JButtonOperator(getCancelButton()); |
| cancelOper.copyEnvironment(this); |
| cancelOper.setOutput(output.createErrorOutput()); |
| cancelOper.push(); |
| } |
| |
| /** |
| * Types file name into text field and pushes approve button. |
| * |
| * @param fileName a file to choose. |
| */ |
| public void chooseFile(String fileName) { |
| getQueueTool().waitEmpty(); |
| output.printTrace("Choose file by JFileChooser\n : " + fileName |
| + "\n : " + toStringSource()); |
| JTextFieldOperator fieldOper = new JTextFieldOperator(getPathField()); |
| fieldOper.copyEnvironment(this); |
| fieldOper.setOutput(output.createErrorOutput()); |
| //workaround |
| fieldOper.setText(fileName); |
| //fieldOper.clearText(); |
| //fieldOper.typeText(fileName); |
| //approveSelection(); |
| approve(); |
| } |
| |
| /** |
| * Pushes "Up One Level" button. |
| * |
| * @return new current directory |
| */ |
| public File goUpLevel() { |
| getQueueTool().waitEmpty(); |
| output.printTrace("Go up level in JFileChooser\n : " |
| + toStringSource()); |
| //workaround |
| setCurrentDirectory(getCurrentDirectory().getParentFile()); |
| //JButtonOperator upOper = new JButtonOperator(getUpLevelButton()); |
| //upOper.copyEnvironment(this); |
| //upOper.setOutput(output.createErrorOutput()); |
| //upOper.push(); |
| waitPainted(-1); |
| return getCurrentDirectory(); |
| } |
| |
| /** |
| * Pushes "Home" button. |
| * |
| * @return new current directory |
| */ |
| public File goHome() { |
| getQueueTool().waitEmpty(); |
| output.printTrace("Go home in JFileChooser\n : " |
| + toStringSource()); |
| AbstractButtonOperator homeOper; |
| // In Windows and Windows Classic L&F, there is no 'Go Home' button, |
| // but there is a toggle button to go desktop. In Windows platform |
| // 'Go Home' button usually navigates to Desktop only. |
| if(LookAndFeel.isWindows() || LookAndFeel.isWindowsClassic()) { |
| homeOper =new JToggleButtonOperator(this, 1); |
| } else { |
| homeOper = new JButtonOperator(getHomeButton()); |
| } |
| homeOper.copyEnvironment(this); |
| homeOper.setOutput(output.createErrorOutput()); |
| homeOper.push(); |
| waitPainted(-1); |
| return getCurrentDirectory(); |
| } |
| |
| /** |
| * Clicks on file in the list. |
| * |
| * @param index Ordinal file index. |
| * @param clickCount click count |
| */ |
| public void clickOnFile(int index, int clickCount) { |
| getQueueTool().waitEmpty(); |
| output.printTrace("Click " + Integer.toString(clickCount) |
| + " times on " + Integer.toString(index) |
| + "`th file in JFileChooser\n : " |
| + toStringSource()); |
| waitPainted(index); |
| Component list = getFileList(); |
| if(list instanceof JList) { |
| JListOperator listOper = new JListOperator((JList) list); |
| listOper.copyEnvironment(this); |
| listOper.setOutput(output.createErrorOutput()); |
| listOper.clickOnItem(index, clickCount); |
| } else if(list instanceof JTable) { |
| JTableOperator tableOper = new JTableOperator((JTable) list); |
| tableOper.copyEnvironment(this); |
| tableOper.setOutput(output.createErrorOutput()); |
| tableOper.clickOnCell(index, 0, clickCount); |
| } else |
| throw new IllegalStateException("Wrong component type"); |
| } |
| |
| /** |
| * Clicks on file in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @param comparator a comparator defining string comparision criteria |
| * @param clickCount click count |
| */ |
| public void clickOnFile(String file, StringComparator comparator, int clickCount) { |
| output.printTrace("Click " + Integer.toString(clickCount) |
| + " times on \"" + file |
| + "\" file in JFileChooser\n : " |
| + toStringSource()); |
| clickOnFile(findFileIndex(file, comparator), clickCount); |
| } |
| |
| /** |
| * Clicks on file in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @param ce Compare exactly. If true, text can be a substring of caption. |
| * @param cc Compare case sensitively. If true, both text and caption are |
| * @param clickCount click count |
| * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean) |
| * @deprecated Use clickOnFile(String, int) or clickOnFile(String, |
| * StringComparator, int) |
| */ |
| @Deprecated |
| public void clickOnFile(String file, boolean ce, boolean cc, int clickCount) { |
| clickOnFile(file, new DefaultStringComparator(ce, cc), clickCount); |
| } |
| |
| /** |
| * Clicks on file in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @param clickCount click count |
| * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean) |
| */ |
| public void clickOnFile(String file, int clickCount) { |
| clickOnFile(file, getComparator(), clickCount); |
| } |
| |
| /** |
| * Clicks on file in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @param comparator a comparator defining string comparision criteria |
| * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean) |
| */ |
| public void clickOnFile(String file, StringComparator comparator) { |
| clickOnFile(file, comparator, 1); |
| } |
| |
| /** |
| * Clicks 1 time on file in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @param ce Compare exactly. If true, text can be a substring of caption. |
| * @param cc Compare case sensitively. If true, both text and caption are |
| * @see #clickOnFile |
| * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean) |
| * @deprecated Use clickOnFile(String) or clickOnFile(String, |
| * StringComparator) |
| */ |
| @Deprecated |
| public void clickOnFile(String file, boolean ce, boolean cc) { |
| clickOnFile(file, ce, cc, 1); |
| } |
| |
| /** |
| * Clicks 1 time on file in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @see #clickOnFile |
| * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean) |
| */ |
| public void clickOnFile(String file) { |
| clickOnFile(file, 1); |
| } |
| |
| /** |
| * Enters into subdirectory. |
| * |
| * @param dir A directory to enter into. |
| * @param comparator a comparator defining string comparision criteria |
| * @return new current directory |
| */ |
| public File enterSubDir(String dir, StringComparator comparator) { |
| setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES); |
| getQueueTool().waitEmpty(); |
| selectFile(dir, comparator); |
| int index = findFileIndex(dir, comparator); |
| waitPainted(index); |
| setCurrentDirectory(getSelectedFile()); |
| return getCurrentDirectory(); |
| } |
| |
| /** |
| * Enters into subdir curently displayed in the list. |
| * |
| * @param dir Directory name (tmp1). Do not use full path (/tmp/tmp1) here. |
| * @param ce Compare exactly. If true, text can be a substring of caption. |
| * @param cc Compare case sensitively. If true, both text and caption are |
| * @return new current directory |
| * @see #clickOnFile |
| * @deprecated Use enterSubDir(String) or enterSubDir(String, |
| * StringComparator) |
| */ |
| @Deprecated |
| public File enterSubDir(String dir, boolean ce, boolean cc) { |
| return enterSubDir(dir, new DefaultStringComparator(ce, cc)); |
| } |
| |
| /** |
| * Enters into subdir curently displayed in the list. |
| * |
| * @param dir Directory name (tmp1). Do not use full path (/tmp/tmp1) here. |
| * @return new current directory |
| * @see #clickOnFile |
| */ |
| public File enterSubDir(String dir) { |
| return enterSubDir(dir, getComparator()); |
| } |
| |
| /** |
| * Selects a file curently in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @param comparator a comparator defining string comparision criteria |
| * @see #clickOnFile |
| */ |
| public void selectFile(String file, StringComparator comparator) { |
| getQueueTool().waitEmpty(); |
| int index = findFileIndex(file, comparator); |
| Component list = getFileList(); |
| if(list instanceof JList) { |
| JListOperator listOper = new JListOperator((JList) list); |
| listOper.copyEnvironment(this); |
| listOper.setOutput(output.createErrorOutput()); |
| listOper.setSelectedIndex(index); |
| } else if(list instanceof JTable){ |
| JTableOperator tableOper = new JTableOperator((JTable) list); |
| tableOper.copyEnvironment(this); |
| tableOper.setOutput(output.createErrorOutput()); |
| tableOper.changeSelection(index, 0, false, false); |
| } else |
| throw new IllegalStateException("Wrong component type"); |
| } |
| |
| /** |
| * Selects a file curently in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @param ce Compare exactly. If true, text can be a substring of caption. |
| * @param cc Compare case sensitively. If true, both text and caption are |
| * @see #clickOnFile |
| * @deprecated Use selectFile(String) or selectFile(String, |
| * StringComparator) |
| */ |
| @Deprecated |
| public void selectFile(String file, boolean ce, boolean cc) { |
| clickOnFile(file, ce, cc); |
| } |
| |
| /** |
| * Selects a file curently in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @see #clickOnFile |
| */ |
| public void selectFile(String file) { |
| clickOnFile(file); |
| } |
| |
| /** |
| * Selects directory from the combo box above. |
| * |
| * @param dir Directory name (tmp1). Do not use full path (/tmp/tmp1) here. |
| * @param comparator a comparator defining string comparision criteria |
| */ |
| public void selectPathDirectory(String dir, StringComparator comparator) { |
| getQueueTool().waitEmpty(); |
| output.printTrace("Select \"" + dir + "\" directory in JFileChooser\n : " |
| + toStringSource()); |
| JComboBoxOperator comboOper = new JComboBoxOperator(getPathCombo()); |
| comboOper.copyEnvironment(this); |
| comboOper.setOutput(output.createErrorOutput()); |
| //workaround |
| comboOper.setSelectedIndex(findDirIndex(dir, comparator)); |
| //comboOper.selectItem(findDirIndex(dir, comparator)); |
| waitPainted(-1); |
| } |
| |
| /** |
| * Selects directory from the combo box above. |
| * |
| * @param dir Directory name (tmp1). Do not use full path (/tmp/tmp1) here. |
| * @param ce Compare exactly. If true, text can be a substring of caption. |
| * @param cc Compare case sensitively. If true, both text and caption are |
| * @deprecated Use selectPathDirectory(String) or |
| * selectPathDirectory(String, StringComparator) |
| */ |
| @Deprecated |
| public void selectPathDirectory(String dir, boolean ce, boolean cc) { |
| selectPathDirectory(dir, new DefaultStringComparator(ce, cc)); |
| } |
| |
| /** |
| * Selects directory from the combo box above. |
| * |
| * @param dir Directory name (tmp1). Do not use full path (/tmp/tmp1) here. |
| */ |
| public void selectPathDirectory(String dir) { |
| selectPathDirectory(dir, getComparator()); |
| } |
| |
| /** |
| * Selects file type from the combo box below. |
| * |
| * @param filter a pattern for choosing a file type. |
| * @param comparator a comparator defining string comparision criteria |
| */ |
| public void selectFileType(String filter, StringComparator comparator) { |
| getQueueTool().waitEmpty(); |
| output.printTrace("Select \"" + filter + "\" file type in JFileChooser\n : " |
| + toStringSource()); |
| JComboBoxOperator comboOper = new JComboBoxOperator(getFileTypesCombo()); |
| comboOper.copyEnvironment(this); |
| comboOper.setOutput(output.createErrorOutput()); |
| //workaround |
| comboOper.setSelectedIndex(findFileTypeIndex(filter, comparator)); |
| // comboOper.selectItem(findFileTypeIndex(filter, comparator)); |
| waitPainted(-1); |
| } |
| |
| /** |
| * Selects file type from the combo box below. |
| * |
| * @param filter a pattern for choosing a file type. |
| * @param ce Compare exactly. If true, text can be a substring of caption. |
| * @param cc Compare case sensitively. If true, both text and caption are |
| * @deprecated Use selectFileType(String) or selectFileType(String, |
| * StringComparator) |
| */ |
| @Deprecated |
| public void selectFileType(String filter, boolean ce, boolean cc) { |
| selectFileType(filter, new DefaultStringComparator(ce, cc)); |
| } |
| |
| /** |
| * Selects file type from the combo box below. |
| * |
| * @param filter a pattern for choosing a file type. |
| */ |
| public void selectFileType(String filter) { |
| selectFileType(filter, getComparator()); |
| } |
| |
| /** |
| * Checks if file is currently displayed in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @param comparator a comparator defining string comparision criteria |
| * @return true if file is displayed. |
| */ |
| public boolean checkFileDisplayed(String file, StringComparator comparator) { |
| waitPainted(-1); |
| return findFileIndex(file, comparator) != -1; |
| } |
| |
| /** |
| * Checks if file is currently displayed in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @param ce Compare exactly. If true, text can be a substring of caption. |
| * @param cc Compare case sensitively. If true, both text and caption are |
| * @return true if file is displayed. |
| * @deprecated Use checkFileDisplayed(String) or checkFileDisplayed(String, |
| * StringComparator) |
| */ |
| @Deprecated |
| public boolean checkFileDisplayed(String file, boolean ce, boolean cc) { |
| return checkFileDisplayed(file, new DefaultStringComparator(ce, cc)); |
| } |
| |
| /** |
| * Checks if file is currently displayed in the list. |
| * |
| * @param file File name (foo.c). Do not use full path (/tmp/foo.c) here. |
| * @return true if file is displayed. |
| */ |
| public boolean checkFileDisplayed(String file) { |
| return checkFileDisplayed(file, getComparator()); |
| } |
| |
| /** |
| * Return count of files currently displayed. |
| * |
| * @return a number of items in the file list. |
| */ |
| public int getFileCount() { |
| waitPainted(-1); |
| Component list = getFileList(); |
| if(list instanceof JList) |
| return ((JList)list).getModel().getSize(); |
| else if(list instanceof JTable) |
| return ((JTable)list).getModel().getRowCount(); |
| else |
| throw new IllegalStateException("Wrong component type"); |
| } |
| |
| /** |
| * Return files currently displayed. |
| * |
| * @return an array of items from the file list. |
| */ |
| public File[] getFiles() { |
| waitPainted(-1); |
| Component list = getFileList(); |
| if(list instanceof JList) { |
| ListModel<?> listModel = ((JList)list).getModel(); |
| File[] result = new File[listModel.getSize()]; |
| for (int i = 0; i < listModel.getSize(); i++) { |
| result[i] = (File) listModel.getElementAt(i); |
| } |
| return result; |
| } else if(list instanceof JTable){ |
| TableModel listModel = ((JTable)list).getModel(); |
| File[] result = new File[listModel.getRowCount()]; |
| for (int i = 0; i < listModel.getRowCount(); i++) { |
| result[i] = (File) listModel.getValueAt(i, 0); |
| } |
| return result; |
| } else |
| throw new IllegalStateException("Wrong component type"); |
| } |
| |
| /** |
| * Waits for the file list to have required number of items. |
| * |
| * @param count Number of files to wait. |
| */ |
| public void waitFileCount(final int count) { |
| waitState(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return getFileCount() == count; |
| } |
| |
| @Override |
| public String getDescription() { |
| return ("Count of files to be equal " |
| + Integer.toString(count)); |
| } |
| |
| @Override |
| public String toString() { |
| return "JFileChooserOperator.waitFileCount.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }); |
| } |
| |
| /** |
| * Waits for a file to be displayed in the file list. |
| * |
| * @param fileName a file to wait. |
| */ |
| public void waitFileDisplayed(final String fileName) { |
| waitState(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return checkFileDisplayed(fileName); |
| } |
| |
| @Override |
| public String getDescription() { |
| return "\"" + fileName + "\"file to be displayed"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JFileChooserOperator.waitFileDisplayed.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }); |
| } |
| |
| //////////////////////////////////////////////////////// |
| //Mapping // |
| /** |
| * Maps {@code JFileChooser.accept(File)} through queue |
| */ |
| public boolean accept(final File file) { |
| return (runMapping(new MapBooleanAction("accept") { |
| @Override |
| public boolean map() { |
| return ((JFileChooser) getSource()).accept(file); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.addActionListener(ActionListener)} through queue |
| */ |
| public void addActionListener(final ActionListener actionListener) { |
| runMapping(new MapVoidAction("addActionListener") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).addActionListener(actionListener); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.addChoosableFileFilter(FileFilter)} through queue |
| */ |
| public void addChoosableFileFilter(final FileFilter fileFilter) { |
| runMapping(new MapVoidAction("addChoosableFileFilter") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).addChoosableFileFilter(fileFilter); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.approveSelection()} through queue |
| */ |
| public void approveSelection() { |
| runMapping(new MapVoidAction("approveSelection") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).approveSelection(); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.cancelSelection()} through queue |
| */ |
| public void cancelSelection() { |
| runMapping(new MapVoidAction("cancelSelection") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).cancelSelection(); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.changeToParentDirectory()} through queue |
| */ |
| public void changeToParentDirectory() { |
| runMapping(new MapVoidAction("changeToParentDirectory") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).changeToParentDirectory(); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.ensureFileIsVisible(File)} through queue |
| */ |
| public void ensureFileIsVisible(final File file) { |
| runMapping(new MapVoidAction("ensureFileIsVisible") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).ensureFileIsVisible(file); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getAcceptAllFileFilter()} through queue |
| */ |
| public FileFilter getAcceptAllFileFilter() { |
| return (runMapping(new MapAction<FileFilter>("getAcceptAllFileFilter") { |
| @Override |
| public FileFilter map() { |
| return ((JFileChooser) getSource()).getAcceptAllFileFilter(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getAccessory()} through queue |
| */ |
| public JComponent getAccessory() { |
| return (runMapping(new MapAction<JComponent>("getAccessory") { |
| @Override |
| public JComponent map() { |
| return ((JFileChooser) getSource()).getAccessory(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getApproveButtonMnemonic()} through queue |
| */ |
| public int getApproveButtonMnemonic() { |
| return (runMapping(new MapIntegerAction("getApproveButtonMnemonic") { |
| @Override |
| public int map() { |
| return ((JFileChooser) getSource()).getApproveButtonMnemonic(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getApproveButtonText()} through queue |
| */ |
| public String getApproveButtonText() { |
| return (runMapping(new MapAction<String>("getApproveButtonText") { |
| @Override |
| public String map() { |
| return ((JFileChooser) getSource()).getApproveButtonText(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getApproveButtonToolTipText()} through queue |
| */ |
| public String getApproveButtonToolTipText() { |
| return (runMapping(new MapAction<String>("getApproveButtonToolTipText") { |
| @Override |
| public String map() { |
| return ((JFileChooser) getSource()).getApproveButtonToolTipText(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getChoosableFileFilters()} through queue |
| */ |
| public FileFilter[] getChoosableFileFilters() { |
| return ((FileFilter[]) runMapping(new MapAction<Object>("getChoosableFileFilters") { |
| @Override |
| public Object map() { |
| return ((JFileChooser) getSource()).getChoosableFileFilters(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getCurrentDirectory()} through queue |
| */ |
| public File getCurrentDirectory() { |
| return (runMapping(new MapAction<File>("getCurrentDirectory") { |
| @Override |
| public File map() { |
| return ((JFileChooser) getSource()).getCurrentDirectory(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getDescription(File)} through queue |
| */ |
| public String getDescription(final File file) { |
| return (runMapping(new MapAction<String>("getDescription") { |
| @Override |
| public String map() { |
| return ((JFileChooser) getSource()).getDescription(file); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getDialogTitle()} through queue |
| */ |
| public String getDialogTitle() { |
| return (runMapping(new MapAction<String>("getDialogTitle") { |
| @Override |
| public String map() { |
| return ((JFileChooser) getSource()).getDialogTitle(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getDialogType()} through queue |
| */ |
| public int getDialogType() { |
| return (runMapping(new MapIntegerAction("getDialogType") { |
| @Override |
| public int map() { |
| return ((JFileChooser) getSource()).getDialogType(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getFileFilter()} through queue |
| */ |
| public FileFilter getFileFilter() { |
| return (runMapping(new MapAction<FileFilter>("getFileFilter") { |
| @Override |
| public FileFilter map() { |
| return ((JFileChooser) getSource()).getFileFilter(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getFileSelectionMode()} through queue |
| */ |
| public int getFileSelectionMode() { |
| return (runMapping(new MapIntegerAction("getFileSelectionMode") { |
| @Override |
| public int map() { |
| return ((JFileChooser) getSource()).getFileSelectionMode(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getFileSystemView()} through queue |
| */ |
| public FileSystemView getFileSystemView() { |
| return (runMapping(new MapAction<FileSystemView>("getFileSystemView") { |
| @Override |
| public FileSystemView map() { |
| return ((JFileChooser) getSource()).getFileSystemView(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getFileView()} through queue |
| */ |
| public FileView getFileView() { |
| return (runMapping(new MapAction<FileView>("getFileView") { |
| @Override |
| public FileView map() { |
| return ((JFileChooser) getSource()).getFileView(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getIcon(File)} through queue |
| */ |
| public Icon getIcon(final File file) { |
| return (runMapping(new MapAction<Icon>("getIcon") { |
| @Override |
| public Icon map() { |
| return ((JFileChooser) getSource()).getIcon(file); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getName(File)} through queue |
| */ |
| public String getName(final File file) { |
| return (runMapping(new MapAction<String>("getName") { |
| @Override |
| public String map() { |
| return ((JFileChooser) getSource()).getName(file); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getSelectedFile()} through queue |
| */ |
| public File getSelectedFile() { |
| return (runMapping(new MapAction<File>("getSelectedFile") { |
| @Override |
| public File map() { |
| return ((JFileChooser) getSource()).getSelectedFile(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getSelectedFiles()} through queue |
| */ |
| public File[] getSelectedFiles() { |
| return ((File[]) runMapping(new MapAction<Object>("getSelectedFiles") { |
| @Override |
| public Object map() { |
| return ((JFileChooser) getSource()).getSelectedFiles(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getTypeDescription(File)} through queue |
| */ |
| public String getTypeDescription(final File file) { |
| return (runMapping(new MapAction<String>("getTypeDescription") { |
| @Override |
| public String map() { |
| return ((JFileChooser) getSource()).getTypeDescription(file); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.getUI()} through queue |
| */ |
| public FileChooserUI getUI() { |
| return (runMapping(new MapAction<FileChooserUI>("getUI") { |
| @Override |
| public FileChooserUI map() { |
| return ((JFileChooser) getSource()).getUI(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.isDirectorySelectionEnabled()} through queue |
| */ |
| public boolean isDirectorySelectionEnabled() { |
| return (runMapping(new MapBooleanAction("isDirectorySelectionEnabled") { |
| @Override |
| public boolean map() { |
| return ((JFileChooser) getSource()).isDirectorySelectionEnabled(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.isFileHidingEnabled()} through queue |
| */ |
| public boolean isFileHidingEnabled() { |
| return (runMapping(new MapBooleanAction("isFileHidingEnabled") { |
| @Override |
| public boolean map() { |
| return ((JFileChooser) getSource()).isFileHidingEnabled(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.isFileSelectionEnabled()} through queue |
| */ |
| public boolean isFileSelectionEnabled() { |
| return (runMapping(new MapBooleanAction("isFileSelectionEnabled") { |
| @Override |
| public boolean map() { |
| return ((JFileChooser) getSource()).isFileSelectionEnabled(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.isMultiSelectionEnabled()} through queue |
| */ |
| public boolean isMultiSelectionEnabled() { |
| return (runMapping(new MapBooleanAction("isMultiSelectionEnabled") { |
| @Override |
| public boolean map() { |
| return ((JFileChooser) getSource()).isMultiSelectionEnabled(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.isTraversable(File)} through queue |
| */ |
| public boolean isTraversable(final File file) { |
| return (runMapping(new MapBooleanAction("isTraversable") { |
| @Override |
| public boolean map() { |
| return ((JFileChooser) getSource()).isTraversable(file); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.removeActionListener(ActionListener)} |
| * through queue |
| */ |
| public void removeActionListener(final ActionListener actionListener) { |
| runMapping(new MapVoidAction("removeActionListener") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).removeActionListener(actionListener); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.removeChoosableFileFilter(FileFilter)} |
| * through queue |
| */ |
| public boolean removeChoosableFileFilter(final FileFilter fileFilter) { |
| return (runMapping(new MapBooleanAction("removeChoosableFileFilter") { |
| @Override |
| public boolean map() { |
| return ((JFileChooser) getSource()).removeChoosableFileFilter(fileFilter); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.rescanCurrentDirectory()} through queue |
| */ |
| public void rescanCurrentDirectory() { |
| runMapping(new MapVoidAction("rescanCurrentDirectory") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).rescanCurrentDirectory(); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.resetChoosableFileFilters()} through queue |
| */ |
| public void resetChoosableFileFilters() { |
| runMapping(new MapVoidAction("resetChoosableFileFilters") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).resetChoosableFileFilters(); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setAccessory(JComponent)} through queue |
| */ |
| public void setAccessory(final JComponent jComponent) { |
| runMapping(new MapVoidAction("setAccessory") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setAccessory(jComponent); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setApproveButtonMnemonic(char)} through queue |
| */ |
| public void setApproveButtonMnemonic(final char c) { |
| runMapping(new MapVoidAction("setApproveButtonMnemonic") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setApproveButtonMnemonic(c); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setApproveButtonMnemonic(int)} through queue |
| */ |
| public void setApproveButtonMnemonic(final int i) { |
| runMapping(new MapVoidAction("setApproveButtonMnemonic") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setApproveButtonMnemonic(i); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setApproveButtonText(String)} through queue |
| */ |
| public void setApproveButtonText(final String string) { |
| runMapping(new MapVoidAction("setApproveButtonText") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setApproveButtonText(string); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setApproveButtonToolTipText(String)} |
| * through queue |
| */ |
| public void setApproveButtonToolTipText(final String string) { |
| runMapping(new MapVoidAction("setApproveButtonToolTipText") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setApproveButtonToolTipText(string); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setCurrentDirectory(File)} through queue |
| */ |
| public void setCurrentDirectory(final File file) { |
| runMapping(new MapVoidAction("setCurrentDirectory") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setCurrentDirectory(file); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setDialogTitle(String)} through queue |
| */ |
| public void setDialogTitle(final String string) { |
| runMapping(new MapVoidAction("setDialogTitle") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setDialogTitle(string); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setDialogType(int)} through queue |
| */ |
| public void setDialogType(final int i) { |
| runMapping(new MapVoidAction("setDialogType") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setDialogType(i); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setFileFilter(FileFilter)} through queue |
| */ |
| public void setFileFilter(final FileFilter fileFilter) { |
| runMapping(new MapVoidAction("setFileFilter") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setFileFilter(fileFilter); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setFileHidingEnabled(boolean)} through queue |
| */ |
| public void setFileHidingEnabled(final boolean b) { |
| runMapping(new MapVoidAction("setFileHidingEnabled") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setFileHidingEnabled(b); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setFileSelectionMode(int)} through queue |
| */ |
| public void setFileSelectionMode(final int i) { |
| runMapping(new MapVoidAction("setFileSelectionMode") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setFileSelectionMode(i); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setFileSystemView(FileSystemView)} through queue |
| */ |
| public void setFileSystemView(final FileSystemView fileSystemView) { |
| runMapping(new MapVoidAction("setFileSystemView") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setFileSystemView(fileSystemView); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setFileView(FileView)} through queue |
| */ |
| public void setFileView(final FileView fileView) { |
| runMapping(new MapVoidAction("setFileView") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setFileView(fileView); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setMultiSelectionEnabled(boolean)} through queue |
| */ |
| public void setMultiSelectionEnabled(final boolean b) { |
| runMapping(new MapVoidAction("setMultiSelectionEnabled") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setMultiSelectionEnabled(b); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setSelectedFile(File)} through queue |
| */ |
| public void setSelectedFile(final File file) { |
| runMapping(new MapVoidAction("setSelectedFile") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setSelectedFile(file); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.setSelectedFiles(File[])} through queue |
| */ |
| public void setSelectedFiles(final File[] file) { |
| runMapping(new MapVoidAction("setSelectedFiles") { |
| @Override |
| public void map() { |
| ((JFileChooser) getSource()).setSelectedFiles(file); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.showDialog(Component, String)} through queue |
| */ |
| public int showDialog(final Component component, final String string) { |
| return (runMapping(new MapIntegerAction("showDialog") { |
| @Override |
| public int map() { |
| return ((JFileChooser) getSource()).showDialog(component, string); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.showOpenDialog(Component)} through queue |
| */ |
| public int showOpenDialog(final Component component) { |
| return (runMapping(new MapIntegerAction("showOpenDialog") { |
| @Override |
| public int map() { |
| return ((JFileChooser) getSource()).showOpenDialog(component); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JFileChooser.showSaveDialog(Component)} through queue |
| */ |
| public int showSaveDialog(final Component component) { |
| return (runMapping(new MapIntegerAction("showSaveDialog") { |
| @Override |
| public int map() { |
| return ((JFileChooser) getSource()).showSaveDialog(component); |
| } |
| })); |
| } |
| |
| //End of mapping // |
| //////////////////////////////////////////////////////// |
| private void waitPainted(int index) { |
| Waiter<Rectangle, Integer> drawingWaiter = new Waiter<>(new Waitable<Rectangle, Integer>() { |
| @Override |
| public Rectangle actionProduced(Integer param) { |
| Component list = getFileList(); |
| int size; |
| if(list instanceof JList) |
| size = ((JList) list).getModel().getSize(); |
| else if(list instanceof JTable) |
| size = ((JTable)list).getModel().getRowCount(); |
| else |
| throw new IllegalStateException("Wrong component type"); |
| if (size == 0) { |
| return new Rectangle(); |
| } |
| int current = (param != null) ? param : 0; |
| try { |
| if(list instanceof JList) |
| if (((JList) list).getCellBounds(current, current) != null) |
| return ((JList) list).getCellBounds(size - 1, size - 1); |
| else |
| return null; |
| else if(list instanceof JTable) |
| if (((JTable)list).getCellRect(current, 0, false) != null) |
| return ((JTable)list).getCellRect(size - 1, 0, false); |
| else |
| return null; |
| else |
| throw new IllegalStateException("Wrong component type"); |
| } catch (NullPointerException e) { |
| //sometimes thrown from list.getCellBounds when item exists but not painted |
| return null; |
| } |
| } |
| |
| @Override |
| public String getDescription() { |
| return "List drawed"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JFileChooserOperator.waitPainted.Waitable{description = " + getDescription() + '}'; |
| } |
| }); |
| drawingWaiter.setTimeoutsToCloneOf(getTimeouts(), "JFileChooserOperator.WaitListPaintedTimeout"); |
| drawingWaiter.setOutput(getOutput().createErrorOutput()); |
| try { |
| drawingWaiter.waitAction((index != -1) ? index : null); |
| } catch (InterruptedException e) { |
| output.printStackTrace(e); |
| } |
| } |
| |
| private JComboBox<?> getCombo(int index) { |
| return ((JComboBox) innerSearcher. |
| findComponent(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return (comp != null |
| && comp instanceof JComboBox); |
| } |
| |
| @Override |
| public String getDescription() { |
| return "JComboBox"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JFileChooserOperator.getCombo.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }, index)); |
| } |
| |
| private JButton getNoTextButton(int index) { |
| return ((JButton) innerSearcher. |
| findComponent(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return (comp != null |
| && comp instanceof JButton |
| && !(comp.getParent() instanceof JComboBox) |
| && (((JButton) comp).getText() == null |
| || ((JButton) comp).getText().length() == 0)); |
| } |
| |
| @Override |
| public String getDescription() { |
| return "JButton"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JFileChooserOperator.getNoTextButton.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }, index)); |
| } |
| |
| private JToggleButton getToggleButton(int index) { |
| return ((JToggleButton) innerSearcher. |
| findComponent(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return (comp != null |
| && comp instanceof JToggleButton); |
| } |
| |
| @Override |
| public String getDescription() { |
| return "JToggleButton"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JFileChooserOperator.getToggleButton.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }, index)); |
| } |
| |
| private int findFileIndex(final String file, final StringComparator comparator) { |
| Waiter<Integer, Void> fileWaiter = new Waiter<>(new Waitable<Integer, Void>() { |
| @Override |
| public Integer actionProduced(Void obj) { |
| File[] files = getFiles(); |
| for (int i = 0; i < files.length; i++) { |
| if (comparator.equals(files[i].getName(), |
| file)) { |
| return i; |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public String getDescription() { |
| return "\"" + file + "\" file to be displayed"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JFileChooserOperator.findFileIndex.Waitable{description = " + getDescription() + '}'; |
| } |
| }); |
| fileWaiter.setOutput(getOutput().createErrorOutput()); |
| fileWaiter.setTimeoutsToCloneOf(getTimeouts(), "JFileChooserOperator.WaitListPaintedTimeout"); |
| try { |
| return fileWaiter.waitAction(null); |
| } catch (InterruptedException e) { |
| throw (new JemmyException("Waiting has been interrupted!")); |
| } |
| } |
| |
| private int findDirIndex(String dir, StringComparator comparator) { |
| ComboBoxModel<?> cbModel = getPathCombo().getModel(); |
| for (int i = cbModel.getSize() - 1; i >= 0; i--) { |
| if (comparator.equals(((File) cbModel.getElementAt(i)).getName(), |
| dir)) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| private int findFileTypeIndex(String fileType, StringComparator comparator) { |
| ComboBoxModel<?> cbModel = getFileTypesCombo().getModel(); |
| for (int i = 0; i < cbModel.getSize(); i++) { |
| if (comparator.equals(((FileFilter) cbModel.getElementAt(i)).getDescription(), |
| fileType)) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Allows to find a dialog containing JFileChooser. |
| */ |
| public static class JFileChooserJDialogFinder implements ComponentChooser { |
| |
| TestOut output; |
| ComponentChooser subChooser; |
| |
| /** |
| * Constructs JFileChooserJDialogFinder. |
| * |
| * @param output an output to put searching message into. |
| */ |
| public JFileChooserJDialogFinder(TestOut output) { |
| this.output = output; |
| subChooser = new JFileChooserFinder(); |
| } |
| |
| @Override |
| public boolean checkComponent(Component comp) { |
| if (comp != null |
| && comp instanceof Window |
| && comp.isVisible()) { |
| ComponentSearcher searcher |
| = new ComponentSearcher((Container) comp); |
| searcher.setOutput(output); |
| return searcher.findComponent(subChooser) != null; |
| } else { |
| return false; |
| } |
| } |
| |
| @Override |
| public String getDescription() { |
| return "JFileChooser's window"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JFileChooserJDialogFinder{" + "subChooser=" + subChooser + '}'; |
| } |
| } |
| |
| /** |
| * Checks component type. |
| */ |
| public static class JFileChooserFinder extends Finder { |
| |
| /** |
| * Constructs JFileChooserFinder. |
| * |
| * @param sf other searching criteria. |
| */ |
| public JFileChooserFinder(ComponentChooser sf) { |
| super(JFileChooser.class, sf); |
| } |
| |
| /** |
| * Constructs JFileChooserFinder. |
| */ |
| public JFileChooserFinder() { |
| super(JFileChooser.class); |
| } |
| } |
| |
| private static class ButtonFinder implements ComponentChooser { |
| |
| String text; |
| |
| public ButtonFinder(String text) { |
| this.text = text; |
| } |
| |
| @Override |
| public boolean checkComponent(Component comp) { |
| return (comp != null |
| && comp instanceof JButton |
| && ((JButton) comp).getText() != null |
| && ((JButton) comp).getText().equals(text)); |
| } |
| |
| @Override |
| public String getDescription() { |
| return "\"" + text + "\" button"; |
| } |
| |
| @Override |
| public String toString() { |
| return "ButtonFinder{" + "text=" + text + '}'; |
| } |
| } |
| |
| } |
