| /* |
| * 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.Dimension; |
| import java.awt.Point; |
| import java.awt.Rectangle; |
| import java.beans.PropertyVetoException; |
| import java.util.Hashtable; |
| |
| import javax.swing.Icon; |
| import javax.swing.JDesktopPane; |
| import javax.swing.JInternalFrame; |
| import javax.swing.JInternalFrame.JDesktopIcon; |
| import javax.swing.JLayeredPane; |
| import javax.swing.JMenuBar; |
| import javax.swing.JScrollPane; |
| import javax.swing.UIManager; |
| import javax.swing.event.InternalFrameListener; |
| import javax.swing.plaf.InternalFrameUI; |
| |
| import org.netbeans.jemmy.ComponentChooser; |
| import org.netbeans.jemmy.ComponentSearcher; |
| import org.netbeans.jemmy.JemmyInputException; |
| import org.netbeans.jemmy.JemmyProperties; |
| import org.netbeans.jemmy.Outputable; |
| import org.netbeans.jemmy.TestOut; |
| import org.netbeans.jemmy.TimeoutExpiredException; |
| import org.netbeans.jemmy.Timeoutable; |
| import org.netbeans.jemmy.Timeouts; |
| import org.netbeans.jemmy.drivers.DriverManager; |
| import org.netbeans.jemmy.drivers.FrameDriver; |
| import org.netbeans.jemmy.drivers.InternalFrameDriver; |
| import org.netbeans.jemmy.drivers.WindowDriver; |
| import org.netbeans.jemmy.util.EmptyVisualizer; |
| import org.netbeans.jemmy.util.LookAndFeel; |
| import org.netbeans.jemmy.util.Platform; |
| |
| /** |
| * Class provides necessary functionality to operate with |
| * javax.swing.JInternalFrame component. |
| * |
| * Some methods can throw WrongInternalFrameStateException exception. |
| * |
| * <BR><BR>Timeouts used: <BR> |
| * ComponentOperator.WaitComponentTimeout - time to wait component displayed |
| * <BR> |
| * ComponentOperator.MouseClickTimeout - time between mouse pressing and |
| * releasing <BR> |
| * AbstractButtonOperator.PushButtonTimeout - time between button pressing and |
| * releasing<BR> |
| * JScrollBarOperator.WholeScrollTimeout - time for the whole scrolling <BR>. |
| * |
| * @see org.netbeans.jemmy.Timeouts |
| * @see WrongInternalFrameStateException |
| * @author Alexandre Iline (alexandre.iline@oracle.com) |
| */ |
| public class JInternalFrameOperator extends JComponentOperator |
| implements Outputable, Timeoutable { |
| |
| /** |
| * Identifier for a "title" property. |
| * |
| * @see #getDump |
| */ |
| public static final String TITLE_DPROP = "Title"; |
| |
| /** |
| * Identifier for a "state" property. |
| * |
| * @see #getDump |
| */ |
| public static final String STATE_DPROP = "State"; |
| |
| /** |
| * Identifier for a "normal" value of "state" property. |
| * |
| * @see #getDump |
| */ |
| public static final String STATE_NORMAL_DPROP_VALUE = "NORMAL"; |
| |
| /** |
| * Identifier for a "closed" value of "state" property. |
| * |
| * @see #getDump |
| */ |
| public static final String STATE_CLOSED_DPROP_VALUE = "CLOSED"; |
| |
| /** |
| * Identifier for a "iconified" value of "state" property. |
| * |
| * @see #getDump |
| */ |
| public static final String STATE_ICONIFIED_DPROP_VALUE = "ICONIFIED"; |
| |
| /** |
| * Identifier for a "maximized" value of "state" property. |
| * |
| * @see #getDump |
| */ |
| public static final String STATE_MAXIMAZED_DPROP_VALUE = "MAXIMIZED"; |
| |
| /** |
| * Identifier for a "resizable" property. |
| * |
| * @see #getDump |
| */ |
| public static final String IS_RESIZABLE_DPROP = "Resizable"; |
| |
| /** |
| * Identifier for a "selected" property. |
| * |
| * @see #getDump |
| */ |
| public static final String IS_SELECTED_DPROP = "Selected"; |
| |
| /** |
| * Maximize button tool tip key |
| */ |
| public static final String MAXIMIZE_BUTTON_TOOLTIP = |
| UIManager.getString("InternalFrame.maxButtonToolTip"); |
| |
| /** |
| * Close button tool tip key |
| */ |
| public static final String CLOSE_BUTTON_TOOLTIP = |
| UIManager.getString("InternalFrame.closeButtonToolTip"); |
| |
| /** |
| * Minimize button tool tip key |
| */ |
| public static final String MINIMIZE_BUTTON_TOOLTIP = |
| UIManager.getString("InternalFrame.iconButtonToolTip"); |
| |
| /** |
| * A minimizing button. |
| */ |
| protected JButtonOperator minOper = null; |
| |
| /** |
| * A maximizing button. |
| */ |
| protected JButtonOperator maxOper = null; |
| |
| /** |
| * A close button. |
| */ |
| protected JButtonOperator closeOper = null; |
| |
| protected JButtonOperator popupButtonOper = null; |
| |
| /** |
| * A title operator. |
| */ |
| protected ContainerOperator<?> titleOperator = null; |
| private TestOut output; |
| private Timeouts timeouts; |
| private JDesktopIconOperator iconOperator; |
| |
| WindowDriver wDriver; |
| FrameDriver fDriver; |
| InternalFrameDriver iDriver; |
| |
| /** |
| * Constructor. |
| * |
| * @param b a component |
| */ |
| public JInternalFrameOperator(JInternalFrame b) { |
| super(b); |
| wDriver = DriverManager.getWindowDriver(getClass()); |
| fDriver = DriverManager.getFrameDriver(getClass()); |
| iDriver = DriverManager.getInternalFrameDriver(getClass()); |
| } |
| |
| /** |
| * Constructs a JInternalFrameOperator object. |
| * |
| * @param cont a container |
| * @param chooser a component chooser specifying searching criteria. |
| * @param index an index between appropriate ones. |
| */ |
| public JInternalFrameOperator(ContainerOperator<?> cont, ComponentChooser chooser, int index) { |
| this(waitJInternalFrame((Container)cont.getSource(), |
| chooser, index)); |
| copyEnvironment(cont); |
| } |
| |
| /** |
| * Constructs a JInternalFrameOperator object. |
| * |
| * @param cont a container |
| * @param chooser a component chooser specifying searching criteria. |
| */ |
| public JInternalFrameOperator(ContainerOperator<?> cont, ComponentChooser chooser) { |
| this(cont, chooser, 0); |
| } |
| |
| /** |
| * Constructor. Waits component in container first. Uses cont's timeout and |
| * output for waiting and to init operator. |
| * |
| * @param cont a container |
| * @param text Button text. |
| * @param index Ordinal component index. |
| * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean) |
| * |
| */ |
| public JInternalFrameOperator(ContainerOperator<?> cont, String text, int index) { |
| this(findOne(cont, text, index)); |
| copyEnvironment(cont); |
| } |
| |
| /** |
| * Constructor. Waits component in container first. Uses cont's timeout and |
| * output for waiting and to init operator. |
| * |
| * @param cont a container |
| * @param text Button text. |
| * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean) |
| * |
| */ |
| public JInternalFrameOperator(ContainerOperator<?> cont, String text) { |
| this(cont, text, 0); |
| } |
| |
| /** |
| * Constructor. Waits component in container first. Uses cont's timeout and |
| * output for waiting and to init operator. |
| * |
| * @param cont a container |
| * @param index Ordinal component index. |
| * |
| */ |
| public JInternalFrameOperator(ContainerOperator<?> cont, int index) { |
| this(waitJInternalFrame((Container)cont.getSource(), |
| new JInternalFrameFinder(), |
| index)); |
| copyEnvironment(cont); |
| } |
| |
| /** |
| * Constructor. Waits component in container first. Uses cont's timeout and |
| * output for waiting and to init operator. |
| * |
| * @param cont a container |
| * |
| */ |
| public JInternalFrameOperator(ContainerOperator<?> cont) { |
| this(cont, 0); |
| } |
| |
| /** |
| * Searches JInternalframe in container. |
| * |
| * @param cont Container to search component in. |
| * @param chooser a component chooser specifying searching criteria. |
| * @param index Ordinal component index. |
| * @return JInternalframe instance or null if component was not found. |
| */ |
| public static JInternalFrame findJInternalFrame(Container cont, ComponentChooser chooser, int index) { |
| Component res = findComponent(cont, new JInternalFrameFinder(chooser), index); |
| if (res instanceof JInternalFrame) { |
| return (JInternalFrame) res; |
| } else if (res instanceof JInternalFrame.JDesktopIcon) { |
| return ((JInternalFrame.JDesktopIcon) res).getInternalFrame(); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Searches JInternalframe in container. |
| * |
| * @param cont Container to search component in. |
| * @param chooser a component chooser specifying searching criteria. |
| * @return JInternalframe instance or null if component was not found. |
| */ |
| public static JInternalFrame findJInternalFrame(Container cont, ComponentChooser chooser) { |
| return findJInternalFrame(cont, chooser, 0); |
| } |
| |
| /** |
| * Searches JInternalframe by title. |
| * |
| * @param cont Container to search component in. |
| * @param text Component text. |
| * @param ce Compare text exactly. |
| * @param ccs Compare text case sensitively. |
| * @param index Ordinal component index. |
| * @return JInternalframe instance or null if component was not found. |
| * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean) |
| */ |
| public static JInternalFrame findJInternalFrame(Container cont, String text, boolean ce, boolean ccs, int index) { |
| return (findJInternalFrame(cont, |
| new JInternalFrameByTitleFinder(text, |
| new DefaultStringComparator(ce, ccs)), |
| index)); |
| } |
| |
| /** |
| * Searches JInternalframe by title. |
| * |
| * @param cont Container to search component in. |
| * @param text Component text. |
| * @param ce Compare text exactly. |
| * @param ccs Compare text case sensitively. |
| * @return JInternalframe instance or null if component was not found. |
| * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean) |
| */ |
| public static JInternalFrame findJInternalFrame(Container cont, String text, boolean ce, boolean ccs) { |
| return findJInternalFrame(cont, text, ce, ccs, 0); |
| } |
| |
| /** |
| * Searches JInternalFrame object which component lies on. |
| * |
| * @param comp Component to find JInternalFrame under. |
| * @param chooser org.netbeans.jemmy.ComponentChooser implementation. |
| * @return JInternalFrame instance or null if component was not found. |
| */ |
| public static JInternalFrame findJInternalFrameUnder(Component comp, ComponentChooser chooser) { |
| return (JInternalFrame) findContainerUnder(comp, new JInternalFrameFinder(chooser)); |
| } |
| |
| /** |
| * Searches JInternalFrame object which component lies on. |
| * |
| * @param comp Component to find JInternalFrame under. |
| * @return JInternalFrame instance or null if component was not found. |
| */ |
| public static JInternalFrame findJInternalFrameUnder(Component comp) { |
| return findJInternalFrameUnder(comp, new JInternalFrameFinder()); |
| } |
| |
| /** |
| * Waits JInternalframe in container. |
| * |
| * @param cont Container to search component in. |
| * @param chooser a component chooser specifying searching criteria. |
| * @param index Ordinal component index. |
| * @return JInternalframe instance. |
| * |
| */ |
| public static JInternalFrame waitJInternalFrame(final Container cont, final ComponentChooser chooser, final int index) { |
| Component res = waitComponent(cont, new JInternalFrameFinder(chooser), index); |
| if (res instanceof JInternalFrame) { |
| return (JInternalFrame) res; |
| } else if (res instanceof JInternalFrame.JDesktopIcon) { |
| return ((JInternalFrame.JDesktopIcon) res).getInternalFrame(); |
| } else { |
| throw (new TimeoutExpiredException(chooser.getDescription())); |
| } |
| } |
| |
| /** |
| * Waits JInternalframe in container. |
| * |
| * @param cont Container to search component in. |
| * @param chooser a component chooser specifying searching criteria. |
| * @return JInternalframe instance. |
| * |
| */ |
| public static JInternalFrame waitJInternalFrame(Container cont, ComponentChooser chooser) { |
| return waitJInternalFrame(cont, chooser, 0); |
| } |
| |
| /** |
| * Waits JInternalframe by title. |
| * |
| * @param cont Container to search component in. |
| * @param text Component text. |
| * @param ce Compare text exactly. |
| * @param ccs Compare text case sensitively. |
| * @param index Ordinal component index. |
| * @return JInternalframe instance. |
| * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean) |
| * |
| */ |
| public static JInternalFrame waitJInternalFrame(Container cont, String text, boolean ce, boolean ccs, int index) { |
| return (waitJInternalFrame(cont, |
| new JInternalFrameByTitleFinder(text, |
| new DefaultStringComparator(ce, ccs)), |
| index)); |
| } |
| |
| /** |
| * Waits JInternalframe by title. |
| * |
| * @param cont Container to search component in. |
| * @param text Component text. |
| * @param ce Compare text exactly. |
| * @param ccs Compare text case sensitively. |
| * @return JInternalframe instance. |
| * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean) |
| * |
| */ |
| public static JInternalFrame waitJInternalFrame(Container cont, String text, boolean ce, boolean ccs) { |
| return waitJInternalFrame(cont, text, ce, ccs, 0); |
| } |
| |
| @Override |
| public void setOutput(TestOut out) { |
| output = out; |
| super.setOutput(output.createErrorOutput()); |
| } |
| |
| @Override |
| public TestOut getOutput() { |
| return output; |
| } |
| |
| @Override |
| public void setTimeouts(Timeouts times) { |
| timeouts = times; |
| super.setTimeouts(timeouts); |
| } |
| |
| @Override |
| public Timeouts getTimeouts() { |
| return timeouts; |
| } |
| |
| /** |
| * Iconifies frame. Note: frame should not be iconified and should be |
| * iconifiable. |
| * |
| * @throws WrongInternalFrameStateException |
| * |
| */ |
| public void iconify() { |
| output.printLine("Iconify JInternalFrame\n : " + toStringSource()); |
| output.printGolden("Iconify JInternalFrame \"" + getTitle() + "\""); |
| checkIconified(false); |
| makeComponentVisible(); |
| fDriver.iconify(this); |
| if (getVerification()) { |
| waitIcon(true); |
| } |
| } |
| |
| /** |
| * Deiconifies frame. Note: frame should be iconified. |
| * |
| * @throws WrongInternalFrameStateException |
| * |
| */ |
| public void deiconify() { |
| output.printLine("Deiconify JInternalFrame\n : " + toStringSource()); |
| output.printGolden("Deiconify JInternalFrame \"" + getTitle() + "\""); |
| checkIconified(true); |
| fDriver.deiconify(this); |
| if (getVerification()) { |
| waitIcon(false); |
| } |
| } |
| |
| /** |
| * Maximizes frame. Note: frame should not be iconified. |
| * |
| * @throws WrongInternalFrameStateException |
| */ |
| public void maximize() { |
| output.printLine("Maximize JInternalFrame\n : " + toStringSource()); |
| output.printGolden("Maximize JInternalFrame \"" + getTitle() + "\""); |
| checkIconified(false); |
| makeComponentVisible(); |
| fDriver.maximize(this); |
| if (getVerification()) { |
| waitMaximum(true); |
| } |
| } |
| |
| /** |
| * Demaximizes frame. Note: frame should not be iconified. |
| * |
| * @throws WrongInternalFrameStateException |
| */ |
| public void demaximize() { |
| output.printLine("Demaximize JInternalFrame\n : " + toStringSource()); |
| output.printGolden("Demaximize JInternalFrame \"" + getTitle() + "\""); |
| checkIconified(false); |
| makeComponentVisible(); |
| fDriver.demaximize(this); |
| if (getVerification()) { |
| waitMaximum(false); |
| } |
| } |
| |
| /** |
| * Moves frame to new location. Note: frame should not be iconified. |
| * |
| * @param x X coordinate of a new frame location. |
| * @param y Y coordinate of a new frame location. |
| * @throws WrongInternalFrameStateException |
| */ |
| public void move(int x, int y) { |
| checkIconified(false); |
| output.printLine("Move JInternalFrame to (" |
| + Integer.toString(x) + "," |
| + Integer.toString(y) + ")" |
| + " position\n : " + toStringSource()); |
| output.printGolden("Move " + getTitle() |
| + " JInternalFrame to (" |
| + Integer.toString(x) + "," |
| + Integer.toString(y) + ")" |
| + " position"); |
| checkIconified(false); |
| wDriver.move(this, x, y); |
| if (getVerification()) { |
| waitComponentLocation(new Point(x, y)); |
| } |
| } |
| |
| /** |
| * Resizes frame. Note: frame should not be iconified. |
| * |
| * @param width New frame width. |
| * @param height New frame height. |
| * @throws WrongInternalFrameStateException |
| */ |
| public void resize(int width, int height) { |
| output.printLine("Resize JInternalFrame to (" |
| + Integer.toString(width) + "," |
| + Integer.toString(height) + ")" |
| + " size\n : " + toStringSource()); |
| output.printGolden("Resize " + getTitle() |
| + " JInternalFrame to (" |
| + Integer.toString(width) + "," |
| + Integer.toString(height) + ")" |
| + " size"); |
| checkIconified(false); |
| wDriver.resize(this, width, height); |
| if (getVerification()) { |
| waitComponentSize(new Dimension(width, height)); |
| } |
| } |
| |
| /** |
| * Activates frame. Note: frame should not be iconified. |
| * |
| * @throws WrongInternalFrameStateException |
| */ |
| public void activate() { |
| checkIconified(false); |
| wDriver.activate(this); |
| if (getVerification()) { |
| waitActivate(true); |
| } |
| } |
| |
| /** |
| * Closes the frame. |
| */ |
| public void close() { |
| checkIconified(false); |
| wDriver.requestClose(this); |
| if (getVerification()) { |
| waitClosed(); |
| } |
| } |
| |
| /** |
| * Scrolls to internal frame's rectangle. |
| * |
| * @param x Horizontal rectangle coordinate |
| * @param y Vertical rectangle coordinate |
| * @param width rectangle width |
| * @param height rectangle height |
| * |
| */ |
| public void scrollToRectangle(int x, int y, int width, int height) { |
| output.printTrace("Scroll desktop pane to make \"" + getTitle() + "\" internal frame visible"); |
| output.printGolden("Scroll desktop pane to make \"" + getTitle() + "\" internal frame visible"); |
| makeComponentVisible(); |
| //try to find JScrollPane under. |
| JScrollPane scroll; |
| if (isIcon()) { |
| scroll |
| = (JScrollPane) iconOperator.getContainer(new JScrollPaneOperator.JScrollPaneFinder(ComponentSearcher. |
| getTrueChooser("JScrollPane"))); |
| } else { |
| scroll |
| = (JScrollPane) getContainer(new JScrollPaneOperator.JScrollPaneFinder(ComponentSearcher. |
| getTrueChooser("JScrollPane"))); |
| } |
| if (scroll == null) { |
| return; |
| } |
| JScrollPaneOperator scroller = new JScrollPaneOperator(scroll); |
| scroller.copyEnvironment(this); |
| scroller.setVisualizer(new EmptyVisualizer()); |
| scroller.scrollToComponentRectangle(isIcon() ? iconOperator.getSource() : getSource(), |
| x, y, width, height); |
| } |
| |
| /** |
| * Scrolls to internal frame's rectangle. |
| * |
| * @param rect a rectangle to scroll to. |
| */ |
| public void scrollToRectangle(Rectangle rect) { |
| scrollToRectangle(rect.x, rect.y, rect.width, rect.height); |
| } |
| |
| /** |
| * Scrolls to internal frame. |
| * |
| */ |
| public void scrollToFrame() { |
| if (isIcon()) { |
| scrollToRectangle(0, 0, iconOperator.getWidth(), iconOperator.getHeight()); |
| } else { |
| scrollToRectangle(0, 0, getWidth(), getHeight()); |
| } |
| } |
| |
| /** |
| * Waits for a minimize button inside the title pane. |
| * |
| * @return a button operator |
| */ |
| public JButtonOperator getMinimizeButton() { |
| initOperators(); |
| return minOper; |
| } |
| |
| /** |
| * Waits for a maximize button inside the title pane. |
| * |
| * @return a button operator |
| */ |
| public JButtonOperator getMaximizeButton() { |
| initOperators(); |
| return maxOper; |
| } |
| |
| /** |
| * Waits for a close button inside the title pane. |
| * |
| * @return a button operator |
| */ |
| public JButtonOperator getCloseButton() { |
| initOperators(); |
| return closeOper; |
| } |
| |
| public JButtonOperator getPopupButton() { |
| initOperators(); |
| return popupButtonOper; |
| } |
| |
| /** |
| * Waits for the title pane. |
| * |
| * @return a button operator |
| */ |
| public ContainerOperator<?> getTitleOperator() { |
| initOperators(); |
| return titleOperator; |
| } |
| |
| /** |
| * Creates an operator for an desktop icon. |
| * |
| * @return an icon operator. |
| */ |
| public JDesktopIconOperator getIconOperator() { |
| if(Platform.isOSX()) { |
| initIconOperator(); |
| } else { |
| initOperators(); |
| } |
| return iconOperator; |
| } |
| |
| /** |
| * Waits for the frame to be iconified or deiconified. |
| * |
| * @param isIconified whether the frame needs to be iconified or deiconified. |
| */ |
| public void waitIcon(final boolean isIconified) { |
| waitStateOnQueue(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return isIcon() == isIconified; |
| } |
| |
| @Override |
| public String getDescription() { |
| return "Internal Frame is " + (isIconified ? "iconified" : "deiconified"); |
| } |
| |
| @Override |
| public String toString() { |
| return "JInternalFrameOperator.waitIcon.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }); |
| } |
| |
| /** |
| * Waits for the frame to be activated or deactivated. |
| * |
| * @param isActivate whether the frame needs to be activated or deactivated. |
| */ |
| public void waitActivate(final boolean isActivate) { |
| waitStateOnQueue(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return isSelected() == isActivate; |
| } |
| |
| @Override |
| public String getDescription() { |
| return "Internal Frame is " + (isActivate ? "activated" : "deactivated"); |
| } |
| |
| @Override |
| public String toString() { |
| return "JInternalFrameOperator.waitActivate.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }); |
| } |
| |
| /** |
| * Waits for the frame to be closed. |
| */ |
| public void waitClosed() { |
| waitStateOnQueue(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return isClosed(); |
| } |
| |
| @Override |
| public String getDescription() { |
| return "Internal Frame is closed"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JInternalFrameOperator.waitClosed.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }); |
| } |
| |
| /** |
| * Waits for the frame to be maximized or demaximized. |
| * |
| * @param isMaximum whether the frame needs to be maximized or demaximized. |
| */ |
| public void waitMaximum(final boolean isMaximum) { |
| waitStateOnQueue(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return isMaximum() == isMaximum; |
| } |
| |
| @Override |
| public String getDescription() { |
| return "Internal Frame is " + (isMaximum ? "maximizied" : "demaximizied"); |
| } |
| |
| @Override |
| public String toString() { |
| return "JInternalFrameOperator.waitMaximum.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }); |
| } |
| |
| /** |
| * Returns information about component. |
| */ |
| @Override |
| public Hashtable<String, Object> getDump() { |
| Hashtable<String, Object> result = super.getDump(); |
| result.put(TITLE_DPROP, ((JInternalFrame) getSource()).getTitle()); |
| String state = STATE_NORMAL_DPROP_VALUE; |
| if (((JInternalFrame) getSource()).isClosed()) { |
| state = STATE_CLOSED_DPROP_VALUE; |
| } else if (((JInternalFrame) getSource()).isIcon()) { |
| state = STATE_ICONIFIED_DPROP_VALUE; |
| } else if (((JInternalFrame) getSource()).isMaximum()) { |
| state = STATE_MAXIMAZED_DPROP_VALUE; |
| } |
| result.put(STATE_DPROP, state); |
| result.put(IS_RESIZABLE_DPROP, ((JInternalFrame) getSource()).isResizable() ? "true" : "false"); |
| result.put(IS_SELECTED_DPROP, ((JInternalFrame) getSource()).isSelected() ? "true" : "false"); |
| return result; |
| } |
| |
| //////////////////////////////////////////////////////// |
| //Mapping // |
| /** |
| * Maps |
| * {@code JInternalFrame.addInternalFrameListener(InternalFrameListener)} |
| * through queue |
| */ |
| public void addInternalFrameListener(final InternalFrameListener internalFrameListener) { |
| runMapping(new MapVoidAction("addInternalFrameListener") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).addInternalFrameListener(internalFrameListener); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.dispose()} through queue |
| */ |
| public void dispose() { |
| runMapping(new MapVoidAction("dispose") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).dispose(); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getContentPane()} through queue |
| */ |
| public Container getContentPane() { |
| return (runMapping(new MapAction<Container>("getContentPane") { |
| @Override |
| public Container map() { |
| return ((JInternalFrame) getSource()).getContentPane(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getDefaultCloseOperation()} through queue |
| */ |
| public int getDefaultCloseOperation() { |
| return (runMapping(new MapIntegerAction("getDefaultCloseOperation") { |
| @Override |
| public int map() { |
| return ((JInternalFrame) getSource()).getDefaultCloseOperation(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getDesktopIcon()} through queue |
| */ |
| public JDesktopIcon getDesktopIcon() { |
| return (runMapping(new MapAction<JDesktopIcon>("getDesktopIcon") { |
| @Override |
| public JDesktopIcon map() { |
| return ((JInternalFrame) getSource()).getDesktopIcon(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getDesktopPane()} through queue |
| */ |
| public JDesktopPane getDesktopPane() { |
| return (runMapping(new MapAction<JDesktopPane>("getDesktopPane") { |
| @Override |
| public JDesktopPane map() { |
| return ((JInternalFrame) getSource()).getDesktopPane(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getFrameIcon()} through queue |
| */ |
| public Icon getFrameIcon() { |
| return (runMapping(new MapAction<Icon>("getFrameIcon") { |
| @Override |
| public Icon map() { |
| return ((JInternalFrame) getSource()).getFrameIcon(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getGlassPane()} through queue |
| */ |
| public Component getGlassPane() { |
| return (runMapping(new MapAction<Component>("getGlassPane") { |
| @Override |
| public Component map() { |
| return ((JInternalFrame) getSource()).getGlassPane(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getJMenuBar()} through queue |
| */ |
| public JMenuBar getJMenuBar() { |
| return (runMapping(new MapAction<JMenuBar>("getJMenuBar") { |
| @Override |
| public JMenuBar map() { |
| return ((JInternalFrame) getSource()).getJMenuBar(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getLayer()} through queue |
| */ |
| public int getLayer() { |
| return (runMapping(new MapIntegerAction("getLayer") { |
| @Override |
| public int map() { |
| return ((JInternalFrame) getSource()).getLayer(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getLayeredPane()} through queue |
| */ |
| public JLayeredPane getLayeredPane() { |
| return (runMapping(new MapAction<JLayeredPane>("getLayeredPane") { |
| @Override |
| public JLayeredPane map() { |
| return ((JInternalFrame) getSource()).getLayeredPane(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getTitle()} through queue |
| */ |
| public String getTitle() { |
| return (runMapping(new MapAction<String>("getTitle") { |
| @Override |
| public String map() { |
| return ((JInternalFrame) getSource()).getTitle(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getUI()} through queue |
| */ |
| public InternalFrameUI getUI() { |
| return (runMapping(new MapAction<InternalFrameUI>("getUI") { |
| @Override |
| public InternalFrameUI map() { |
| return ((JInternalFrame) getSource()).getUI(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.getWarningString()} through queue |
| */ |
| public String getWarningString() { |
| return (runMapping(new MapAction<String>("getWarningString") { |
| @Override |
| public String map() { |
| return ((JInternalFrame) getSource()).getWarningString(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.isClosable()} through queue |
| */ |
| public boolean isClosable() { |
| return (runMapping(new MapBooleanAction("isClosable") { |
| @Override |
| public boolean map() { |
| return ((JInternalFrame) getSource()).isClosable(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.isClosed()} through queue |
| */ |
| public boolean isClosed() { |
| return (runMapping(new MapBooleanAction("isClosed") { |
| @Override |
| public boolean map() { |
| return ((JInternalFrame) getSource()).isClosed(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.isIcon()} through queue |
| */ |
| public boolean isIcon() { |
| return (runMapping(new MapBooleanAction("isIcon") { |
| @Override |
| public boolean map() { |
| return ((JInternalFrame) getSource()).isIcon(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.isIconifiable()} through queue |
| */ |
| public boolean isIconifiable() { |
| return (runMapping(new MapBooleanAction("isIconifiable") { |
| @Override |
| public boolean map() { |
| return ((JInternalFrame) getSource()).isIconifiable(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.isMaximizable()} through queue |
| */ |
| public boolean isMaximizable() { |
| return (runMapping(new MapBooleanAction("isMaximizable") { |
| @Override |
| public boolean map() { |
| return ((JInternalFrame) getSource()).isMaximizable(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.isMaximum()} through queue |
| */ |
| public boolean isMaximum() { |
| return (runMapping(new MapBooleanAction("isMaximum") { |
| @Override |
| public boolean map() { |
| return ((JInternalFrame) getSource()).isMaximum(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.isResizable()} through queue |
| */ |
| public boolean isResizable() { |
| return (runMapping(new MapBooleanAction("isResizable") { |
| @Override |
| public boolean map() { |
| return ((JInternalFrame) getSource()).isResizable(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.isSelected()} through queue |
| */ |
| public boolean isSelected() { |
| return (runMapping(new MapBooleanAction("isSelected") { |
| @Override |
| public boolean map() { |
| return ((JInternalFrame) getSource()).isSelected(); |
| } |
| })); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.moveToBack()} through queue |
| */ |
| public void moveToBack() { |
| runMapping(new MapVoidAction("moveToBack") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).moveToBack(); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.moveToFront()} through queue |
| */ |
| public void moveToFront() { |
| runMapping(new MapVoidAction("moveToFront") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).moveToFront(); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.pack()} through queue |
| */ |
| public void pack() { |
| runMapping(new MapVoidAction("pack") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).pack(); |
| } |
| }); |
| } |
| |
| /** |
| * Maps |
| * {@code JInternalFrame.removeInternalFrameListener(InternalFrameListener)} |
| * through queue |
| */ |
| public void removeInternalFrameListener(final InternalFrameListener internalFrameListener) { |
| runMapping(new MapVoidAction("removeInternalFrameListener") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).removeInternalFrameListener(internalFrameListener); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setClosable(boolean)} through queue |
| */ |
| public void setClosable(final boolean b) { |
| runMapping(new MapVoidAction("setClosable") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setClosable(b); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setClosed(boolean)} through queue |
| */ |
| public void setClosed(final boolean b) { |
| runMapping(new MapVoidAction("setClosed") { |
| @Override |
| public void map() throws PropertyVetoException { |
| ((JInternalFrame) getSource()).setClosed(b); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setContentPane(Container)} through queue |
| */ |
| public void setContentPane(final Container container) { |
| runMapping(new MapVoidAction("setContentPane") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setContentPane(container); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setDefaultCloseOperation(int)} through queue |
| */ |
| public void setDefaultCloseOperation(final int i) { |
| runMapping(new MapVoidAction("setDefaultCloseOperation") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setDefaultCloseOperation(i); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setDesktopIcon(JDesktopIcon)} through queue |
| */ |
| public void setDesktopIcon(final JDesktopIcon jDesktopIcon) { |
| runMapping(new MapVoidAction("setDesktopIcon") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setDesktopIcon(jDesktopIcon); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setFrameIcon(Icon)} through queue |
| */ |
| public void setFrameIcon(final Icon icon) { |
| runMapping(new MapVoidAction("setFrameIcon") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setFrameIcon(icon); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setGlassPane(Component)} through queue |
| */ |
| public void setGlassPane(final Component component) { |
| runMapping(new MapVoidAction("setGlassPane") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setGlassPane(component); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setIcon(boolean)} through queue |
| */ |
| public void setIcon(final boolean b) { |
| runMapping(new MapVoidAction("setIcon") { |
| @Override |
| public void map() throws PropertyVetoException { |
| ((JInternalFrame) getSource()).setIcon(b); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setIconifiable(boolean)} through queue |
| */ |
| public void setIconifiable(final boolean b) { |
| runMapping(new MapVoidAction("setIconifiable") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setIconifiable(b); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setJMenuBar(JMenuBar)} through queue |
| */ |
| public void setJMenuBar(final JMenuBar jMenuBar) { |
| runMapping(new MapVoidAction("setJMenuBar") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setJMenuBar(jMenuBar); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setLayer(Integer)} through queue |
| */ |
| public void setLayer(final Integer integer) { |
| runMapping(new MapVoidAction("setLayer") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setLayer(integer); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setLayeredPane(JLayeredPane)} through queue |
| */ |
| public void setLayeredPane(final JLayeredPane jLayeredPane) { |
| runMapping(new MapVoidAction("setLayeredPane") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setLayeredPane(jLayeredPane); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setMaximizable(boolean)} through queue |
| */ |
| public void setMaximizable(final boolean b) { |
| runMapping(new MapVoidAction("setMaximizable") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setMaximizable(b); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setMaximum(boolean)} through queue |
| */ |
| public void setMaximum(final boolean b) { |
| runMapping(new MapVoidAction("setMaximum") { |
| @Override |
| public void map() throws PropertyVetoException { |
| ((JInternalFrame) getSource()).setMaximum(b); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setResizable(boolean)} through queue |
| */ |
| public void setResizable(final boolean b) { |
| runMapping(new MapVoidAction("setResizable") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setResizable(b); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setSelected(boolean)} through queue |
| */ |
| public void setSelected(final boolean b) { |
| runMapping(new MapVoidAction("setSelected") { |
| @Override |
| public void map() throws PropertyVetoException { |
| ((JInternalFrame) getSource()).setSelected(b); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setTitle(String)} through queue |
| */ |
| public void setTitle(final String string) { |
| runMapping(new MapVoidAction("setTitle") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setTitle(string); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.setUI(InternalFrameUI)} through queue |
| */ |
| public void setUI(final InternalFrameUI internalFrameUI) { |
| runMapping(new MapVoidAction("setUI") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).setUI(internalFrameUI); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.toBack()} through queue |
| */ |
| public void toBack() { |
| runMapping(new MapVoidAction("toBack") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).toBack(); |
| } |
| }); |
| } |
| |
| /** |
| * Maps {@code JInternalFrame.toFront()} through queue |
| */ |
| public void toFront() { |
| runMapping(new MapVoidAction("toFront") { |
| @Override |
| public void map() { |
| ((JInternalFrame) getSource()).toFront(); |
| } |
| }); |
| } |
| |
| //End of mapping // |
| //////////////////////////////////////////////////////// |
| /** |
| * Uses InternalframeDriver to get a title pane. |
| * |
| * @return a title pane. |
| */ |
| protected Container findTitlePane() { |
| return (Container) iDriver.getTitlePane(this); |
| } |
| |
| /** |
| * Initialize icon operator |
| */ |
| protected void initIconOperator() { |
| iconOperator = new JDesktopIconOperator(((JInternalFrame) getSource()).getDesktopIcon()); |
| iconOperator.copyEnvironment(this); |
| } |
| |
| /** |
| * Initiaites suboperators. |
| */ |
| protected void initOperators() { |
| initIconOperator(); |
| if(Platform.isOSX()) { |
| throw new UnsupportedOperationException( |
| "Jemmy doesn't support getting or initializing title" |
| + " related operators on Mac OSx"); |
| } else { |
| Container titlePane = findTitlePane(); |
| if (!isIcon() && titlePane != null) { |
| if (titleOperator == null) { |
| titleOperator = new ContainerOperator<>(titlePane); |
| if (getContainer(new ComponentChooser() { |
| @Override |
| public boolean checkComponent(Component comp) { |
| return comp instanceof JDesktopPane; |
| } |
| |
| @Override |
| public String getDescription() { |
| return "Desktop pane"; |
| } |
| |
| @Override |
| public String toString() { |
| return "JInternalFrameOperator.initOperators.ComponentChooser{description = " + getDescription() + '}'; |
| } |
| }) != null) { |
| if(LookAndFeel.isMotif()) { |
| popupButtonOper = new JButtonOperator(titleOperator, 0); |
| } else { |
| minOper = new JButtonOperator(titleOperator, |
| new JComponentByTipFinder(MINIMIZE_BUTTON_TOOLTIP)); |
| if (((JInternalFrame) getSource()).isMaximizable()) { |
| maxOper = new JButtonOperator(titleOperator, |
| new JComponentByTipFinder(MAXIMIZE_BUTTON_TOOLTIP)); |
| } else { |
| maxOper = null; |
| } |
| } |
| } else { |
| minOper = null; |
| maxOper = null; |
| } |
| if (isClosable()) { |
| if(!LookAndFeel.isMotif()) { |
| closeOper = new JButtonOperator(titleOperator, |
| new JComponentByTipFinder(CLOSE_BUTTON_TOOLTIP)); |
| } |
| } else { |
| closeOper = null; |
| } |
| } |
| } else { |
| titleOperator = null; |
| minOper = null; |
| maxOper = null; |
| closeOper = null; |
| } |
| } |
| } |
| |
| //throw exception if state is wrong |
| private void checkIconified(boolean shouldBeIconified) { |
| if (shouldBeIconified && !isIcon() |
| || !shouldBeIconified && isIcon()) { |
| throw (new WrongInternalFrameStateException("JInternal frame should " |
| + (shouldBeIconified ? "" : "not") |
| + " be iconified to produce this operation", |
| getSource())); |
| } |
| } |
| |
| private static JInternalFrame findOne(ContainerOperator<?> cont, String text, int index) { |
| Component source = waitComponent(cont, |
| new JInternalFrameByTitleFinder(text, |
| cont.getComparator()), |
| index); |
| if (source instanceof JInternalFrame) { |
| return (JInternalFrame) source; |
| } else if (source instanceof JInternalFrame.JDesktopIcon) { |
| return ((JInternalFrame.JDesktopIcon) source).getInternalFrame(); |
| } else { |
| throw (new TimeoutExpiredException("No internal frame was found")); |
| } |
| } |
| |
| /** |
| * Exception can be throwht if as a result of an attempt to produce |
| * operation for the frame in incorrect state. Like activate iconified |
| * frame, for example. |
| */ |
| public static class WrongInternalFrameStateException extends JemmyInputException { |
| |
| private static final long serialVersionUID = 42L; |
| |
| /** |
| * Constructs a JInternalFrameOperator$WrongInternalFrameStateException |
| * object. |
| * |
| * @param message an exception message. |
| * @param comp an internal frame. |
| */ |
| public WrongInternalFrameStateException(String message, Component comp) { |
| super(message, comp); |
| } |
| } |
| |
| /** |
| * Allows to find component by title. |
| */ |
| public static class JInternalFrameByTitleFinder implements ComponentChooser { |
| |
| String label; |
| StringComparator comparator; |
| |
| /** |
| * Constructs JInternalFrameByTitleFinder. |
| * |
| * @param lb a text pattern |
| * @param comparator specifies string comparision algorithm. |
| */ |
| public JInternalFrameByTitleFinder(String lb, StringComparator comparator) { |
| label = lb; |
| this.comparator = comparator; |
| } |
| |
| /** |
| * Constructs JInternalFrameByTitleFinder. |
| * |
| * @param lb a text pattern |
| */ |
| public JInternalFrameByTitleFinder(String lb) { |
| this(lb, Operator.getDefaultStringComparator()); |
| } |
| |
| @Override |
| public boolean checkComponent(Component comp) { |
| if (comp instanceof JInternalFrame || comp instanceof JInternalFrame.JDesktopIcon) { |
| JInternalFrame frame = null; |
| if (comp instanceof JInternalFrame) { |
| frame = (JInternalFrame) comp; |
| } else { |
| JDesktopIconOperator io = new JDesktopIconOperator((JInternalFrame.JDesktopIcon) comp); |
| frame = io.getInternalFrame(); |
| } |
| if (frame.getTitle() != null) { |
| return (comparator.equals(frame.getTitle(), |
| label)); |
| } |
| } |
| return false; |
| } |
| |
| @Override |
| public String getDescription() { |
| return "JInternalFrame with title \"" + label + "\""; |
| } |
| |
| @Override |
| public String toString() { |
| return "JInternalFrameByTitleFinder{" + "label=" + label + ", comparator=" + comparator + '}'; |
| } |
| } |
| |
| /** |
| * Class to operate with javax.swing.JInternalFrame.JDesktopIconOperator |
| * component. |
| */ |
| public static class JDesktopIconOperator extends JComponentOperator |
| implements Outputable, Timeoutable { |
| |
| private TestOut output; |
| private Timeouts timeouts; |
| |
| /** |
| * Constructs JDesktopIconOperator. |
| * |
| * @param b a component |
| */ |
| public JDesktopIconOperator(JInternalFrame.JDesktopIcon b) { |
| super(b); |
| setOutput(JemmyProperties.getCurrentOutput()); |
| setTimeouts(JemmyProperties.getCurrentTimeouts()); |
| } |
| |
| @Override |
| public void setOutput(TestOut out) { |
| output = out; |
| super.setOutput(output.createErrorOutput()); |
| } |
| |
| @Override |
| public TestOut getOutput() { |
| return output; |
| } |
| |
| @Override |
| public void setTimeouts(Timeouts times) { |
| timeouts = times; |
| super.setTimeouts(timeouts); |
| } |
| |
| @Override |
| public Timeouts getTimeouts() { |
| return timeouts; |
| } |
| |
| /** |
| * Creates an operator for the correspondent internal frame. |
| * |
| * @return an operator. |
| */ |
| public JInternalFrame getInternalFrame() { |
| return (runMapping(new MapAction<JInternalFrame>("getInternalFrame") { |
| @Override |
| public JInternalFrame map() { |
| return ((JInternalFrame.JDesktopIcon) getSource()).getInternalFrame(); |
| } |
| })); |
| } |
| |
| /** |
| * Pushs the deiconifying button. |
| */ |
| public void pushButton() { |
| this.clickMouse(2); |
| } |
| } |
| |
| /** |
| * Checks component type. |
| */ |
| public static class JInternalFrameFinder implements ComponentChooser { |
| |
| ComponentChooser sf = null; |
| |
| /** |
| * Constructs JInternalFrameFinder. |
| * |
| * @param sf other searching criteria. |
| */ |
| public JInternalFrameFinder(ComponentChooser sf) { |
| this.sf = sf; |
| } |
| |
| /** |
| * Constructs JInternalFrameFinder. |
| */ |
| public JInternalFrameFinder() { |
| this(ComponentSearcher.getTrueChooser("JInternalFrame or JInternalFrame.JDesktopIcon")); |
| } |
| |
| @Override |
| public boolean checkComponent(Component comp) { |
| return ((comp instanceof JInternalFrame || comp instanceof JInternalFrame.JDesktopIcon) |
| && sf.checkComponent(comp)); |
| } |
| |
| @Override |
| public String getDescription() { |
| return sf.getDescription(); |
| } |
| |
| @Override |
| public String toString() { |
| return "JInternalFrameFinder{" + "sf=" + sf + '}'; |
| } |
| } |
| |
| } |
