| /* |
| * Copyright (c) 1997, 2008, 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 javax.swing.plaf.basic; |
| |
| import sun.swing.DefaultLookup; |
| import sun.swing.UIAction; |
| import javax.swing.border.Border; |
| import javax.swing.border.EmptyBorder; |
| import javax.swing.*; |
| import javax.swing.event.*; |
| import javax.swing.plaf.ActionMapUIResource; |
| import javax.swing.plaf.ComponentUI; |
| import javax.swing.plaf.OptionPaneUI; |
| import java.awt.*; |
| import java.awt.event.*; |
| import java.beans.PropertyChangeEvent; |
| import java.beans.PropertyChangeListener; |
| import java.util.Locale; |
| import java.security.AccessController; |
| |
| import sun.security.action.GetPropertyAction; |
| |
| |
| /** |
| * Provides the basic look and feel for a <code>JOptionPane</code>. |
| * <code>BasicMessagePaneUI</code> provides a means to place an icon, |
| * message and buttons into a <code>Container</code>. |
| * Generally, the layout will look like:<p> |
| * <pre> |
| * ------------------ |
| * | i | message | |
| * | c | message | |
| * | o | message | |
| * | n | message | |
| * ------------------ |
| * | buttons | |
| * |________________| |
| * </pre> |
| * icon is an instance of <code>Icon</code> that is wrapped inside a |
| * <code>JLabel</code>. The message is an opaque object and is tested |
| * for the following: if the message is a <code>Component</code> it is |
| * added to the <code>Container</code>, if it is an <code>Icon</code> |
| * it is wrapped inside a <code>JLabel</code> and added to the |
| * <code>Container</code> otherwise it is wrapped inside a <code>JLabel</code>. |
| * <p> |
| * The above layout is used when the option pane's |
| * <code>ComponentOrientation</code> property is horizontal, left-to-right. |
| * The layout will be adjusted appropriately for other orientations. |
| * <p> |
| * The <code>Container</code>, message, icon, and buttons are all |
| * determined from abstract methods. |
| * |
| * @author James Gosling |
| * @author Scott Violet |
| * @author Amy Fowler |
| */ |
| public class BasicOptionPaneUI extends OptionPaneUI { |
| |
| public static final int MinimumWidth = 262; |
| public static final int MinimumHeight = 90; |
| |
| private static String newline; |
| |
| /** |
| * <code>JOptionPane</code> that the receiver is providing the |
| * look and feel for. |
| */ |
| protected JOptionPane optionPane; |
| |
| protected Dimension minimumSize; |
| |
| /** JComponent provide for input if optionPane.getWantsInput() returns |
| * true. */ |
| protected JComponent inputComponent; |
| |
| /** Component to receive focus when messaged with selectInitialValue. */ |
| protected Component initialFocusComponent; |
| |
| /** This is set to true in validateComponent if a Component is contained |
| * in either the message or the buttons. */ |
| protected boolean hasCustomComponents; |
| |
| protected PropertyChangeListener propertyChangeListener; |
| |
| private Handler handler; |
| |
| |
| static { |
| newline = java.security.AccessController.doPrivileged( |
| new GetPropertyAction("line.separator")); |
| if (newline == null) { |
| newline = "\n"; |
| } |
| } |
| |
| static void loadActionMap(LazyActionMap map) { |
| map.put(new Actions(Actions.CLOSE)); |
| BasicLookAndFeel.installAudioActionMap(map); |
| } |
| |
| |
| |
| /** |
| * Creates a new BasicOptionPaneUI instance. |
| */ |
| public static ComponentUI createUI(JComponent x) { |
| return new BasicOptionPaneUI(); |
| } |
| |
| /** |
| * Installs the receiver as the L&F for the passed in |
| * <code>JOptionPane</code>. |
| */ |
| public void installUI(JComponent c) { |
| optionPane = (JOptionPane)c; |
| installDefaults(); |
| optionPane.setLayout(createLayoutManager()); |
| installComponents(); |
| installListeners(); |
| installKeyboardActions(); |
| } |
| |
| /** |
| * Removes the receiver from the L&F controller of the passed in split |
| * pane. |
| */ |
| public void uninstallUI(JComponent c) { |
| uninstallComponents(); |
| optionPane.setLayout(null); |
| uninstallKeyboardActions(); |
| uninstallListeners(); |
| uninstallDefaults(); |
| optionPane = null; |
| } |
| |
| protected void installDefaults() { |
| LookAndFeel.installColorsAndFont(optionPane, "OptionPane.background", |
| "OptionPane.foreground", "OptionPane.font"); |
| LookAndFeel.installBorder(optionPane, "OptionPane.border"); |
| minimumSize = UIManager.getDimension("OptionPane.minimumSize"); |
| LookAndFeel.installProperty(optionPane, "opaque", Boolean.TRUE); |
| } |
| |
| protected void uninstallDefaults() { |
| LookAndFeel.uninstallBorder(optionPane); |
| } |
| |
| protected void installComponents() { |
| optionPane.add(createMessageArea()); |
| |
| Container separator = createSeparator(); |
| if (separator != null) { |
| optionPane.add(separator); |
| } |
| optionPane.add(createButtonArea()); |
| optionPane.applyComponentOrientation(optionPane.getComponentOrientation()); |
| } |
| |
| protected void uninstallComponents() { |
| hasCustomComponents = false; |
| inputComponent = null; |
| initialFocusComponent = null; |
| optionPane.removeAll(); |
| } |
| |
| protected LayoutManager createLayoutManager() { |
| return new BoxLayout(optionPane, BoxLayout.Y_AXIS); |
| } |
| |
| protected void installListeners() { |
| if ((propertyChangeListener = createPropertyChangeListener()) != null) { |
| optionPane.addPropertyChangeListener(propertyChangeListener); |
| } |
| } |
| |
| protected void uninstallListeners() { |
| if (propertyChangeListener != null) { |
| optionPane.removePropertyChangeListener(propertyChangeListener); |
| propertyChangeListener = null; |
| } |
| handler = null; |
| } |
| |
| protected PropertyChangeListener createPropertyChangeListener() { |
| return getHandler(); |
| } |
| |
| private Handler getHandler() { |
| if (handler == null) { |
| handler = new Handler(); |
| } |
| return handler; |
| } |
| |
| protected void installKeyboardActions() { |
| InputMap map = getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW); |
| |
| SwingUtilities.replaceUIInputMap(optionPane, JComponent. |
| WHEN_IN_FOCUSED_WINDOW, map); |
| |
| LazyActionMap.installLazyActionMap(optionPane, BasicOptionPaneUI.class, |
| "OptionPane.actionMap"); |
| } |
| |
| protected void uninstallKeyboardActions() { |
| SwingUtilities.replaceUIInputMap(optionPane, JComponent. |
| WHEN_IN_FOCUSED_WINDOW, null); |
| SwingUtilities.replaceUIActionMap(optionPane, null); |
| } |
| |
| InputMap getInputMap(int condition) { |
| if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) { |
| Object[] bindings = (Object[])DefaultLookup.get( |
| optionPane, this, "OptionPane.windowBindings"); |
| if (bindings != null) { |
| return LookAndFeel.makeComponentInputMap(optionPane, bindings); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the minimum size the option pane should be. Primarily |
| * provided for subclassers wishing to offer a different minimum size. |
| */ |
| public Dimension getMinimumOptionPaneSize() { |
| if (minimumSize == null) { |
| return new Dimension(MinimumWidth, MinimumHeight); |
| } |
| return new Dimension(minimumSize.width, |
| minimumSize.height); |
| } |
| |
| /** |
| * If <code>c</code> is the <code>JOptionPane</code> the receiver |
| * is contained in, the preferred |
| * size that is returned is the maximum of the preferred size of |
| * the <code>LayoutManager</code> for the <code>JOptionPane</code>, and |
| * <code>getMinimumOptionPaneSize</code>. |
| */ |
| public Dimension getPreferredSize(JComponent c) { |
| if (c == optionPane) { |
| Dimension ourMin = getMinimumOptionPaneSize(); |
| LayoutManager lm = c.getLayout(); |
| |
| if (lm != null) { |
| Dimension lmSize = lm.preferredLayoutSize(c); |
| |
| if (ourMin != null) |
| return new Dimension |
| (Math.max(lmSize.width, ourMin.width), |
| Math.max(lmSize.height, ourMin.height)); |
| return lmSize; |
| } |
| return ourMin; |
| } |
| return null; |
| } |
| |
| /** |
| * Messaged from installComponents to create a Container containing the |
| * body of the message. The icon is the created by calling |
| * <code>addIcon</code>. |
| */ |
| protected Container createMessageArea() { |
| JPanel top = new JPanel(); |
| Border topBorder = (Border)DefaultLookup.get(optionPane, this, |
| "OptionPane.messageAreaBorder"); |
| if (topBorder != null) { |
| top.setBorder(topBorder); |
| } |
| top.setLayout(new BorderLayout()); |
| |
| /* Fill the body. */ |
| Container body = new JPanel(new GridBagLayout()); |
| Container realBody = new JPanel(new BorderLayout()); |
| |
| body.setName("OptionPane.body"); |
| realBody.setName("OptionPane.realBody"); |
| |
| if (getIcon() != null) { |
| JPanel sep = new JPanel(); |
| sep.setName("OptionPane.separator"); |
| sep.setPreferredSize(new Dimension(15, 1)); |
| realBody.add(sep, BorderLayout.BEFORE_LINE_BEGINS); |
| } |
| realBody.add(body, BorderLayout.CENTER); |
| |
| GridBagConstraints cons = new GridBagConstraints(); |
| cons.gridx = cons.gridy = 0; |
| cons.gridwidth = GridBagConstraints.REMAINDER; |
| cons.gridheight = 1; |
| cons.anchor = DefaultLookup.getInt(optionPane, this, |
| "OptionPane.messageAnchor", GridBagConstraints.CENTER); |
| cons.insets = new Insets(0,0,3,0); |
| |
| addMessageComponents(body, cons, getMessage(), |
| getMaxCharactersPerLineCount(), false); |
| top.add(realBody, BorderLayout.CENTER); |
| |
| addIcon(top); |
| return top; |
| } |
| |
| /** |
| * Creates the appropriate object to represent <code>msg</code> and |
| * places it into <code>container</code>. If <code>msg</code> is an |
| * instance of Component, it is added directly, if it is an Icon, |
| * a JLabel is created to represent it, otherwise a JLabel is |
| * created for the string, if <code>d</code> is an Object[], this |
| * method will be recursively invoked for the children. |
| * <code>internallyCreated</code> is true if Objc is an instance |
| * of Component and was created internally by this method (this is |
| * used to correctly set hasCustomComponents only if !internallyCreated). |
| */ |
| protected void addMessageComponents(Container container, |
| GridBagConstraints cons, |
| Object msg, int maxll, |
| boolean internallyCreated) { |
| if (msg == null) { |
| return; |
| } |
| if (msg instanceof Component) { |
| // To workaround problem where Gridbad will set child |
| // to its minimum size if its preferred size will not fit |
| // within allocated cells |
| if (msg instanceof JScrollPane || msg instanceof JPanel) { |
| cons.fill = GridBagConstraints.BOTH; |
| cons.weighty = 1; |
| } else { |
| cons.fill = GridBagConstraints.HORIZONTAL; |
| } |
| cons.weightx = 1; |
| |
| container.add((Component) msg, cons); |
| cons.weightx = 0; |
| cons.weighty = 0; |
| cons.fill = GridBagConstraints.NONE; |
| cons.gridy++; |
| if (!internallyCreated) { |
| hasCustomComponents = true; |
| } |
| |
| } else if (msg instanceof Object[]) { |
| Object [] msgs = (Object[]) msg; |
| for (Object o : msgs) { |
| addMessageComponents(container, cons, o, maxll, false); |
| } |
| |
| } else if (msg instanceof Icon) { |
| JLabel label = new JLabel( (Icon)msg, SwingConstants.CENTER ); |
| configureMessageLabel(label); |
| addMessageComponents(container, cons, label, maxll, true); |
| |
| } else { |
| String s = msg.toString(); |
| int len = s.length(); |
| if (len <= 0) { |
| return; |
| } |
| int nl; |
| int nll = 0; |
| |
| if ((nl = s.indexOf(newline)) >= 0) { |
| nll = newline.length(); |
| } else if ((nl = s.indexOf("\r\n")) >= 0) { |
| nll = 2; |
| } else if ((nl = s.indexOf('\n')) >= 0) { |
| nll = 1; |
| } |
| if (nl >= 0) { |
| // break up newlines |
| if (nl == 0) { |
| JPanel breakPanel = new JPanel() { |
| public Dimension getPreferredSize() { |
| Font f = getFont(); |
| |
| if (f != null) { |
| return new Dimension(1, f.getSize() + 2); |
| } |
| return new Dimension(0, 0); |
| } |
| }; |
| breakPanel.setName("OptionPane.break"); |
| addMessageComponents(container, cons, breakPanel, maxll, |
| true); |
| } else { |
| addMessageComponents(container, cons, s.substring(0, nl), |
| maxll, false); |
| } |
| addMessageComponents(container, cons, s.substring(nl + nll), maxll, |
| false); |
| |
| } else if (len > maxll) { |
| Container c = Box.createVerticalBox(); |
| c.setName("OptionPane.verticalBox"); |
| burstStringInto(c, s, maxll); |
| addMessageComponents(container, cons, c, maxll, true ); |
| |
| } else { |
| JLabel label; |
| label = new JLabel( s, JLabel.LEADING ); |
| label.setName("OptionPane.label"); |
| configureMessageLabel(label); |
| addMessageComponents(container, cons, label, maxll, true); |
| } |
| } |
| } |
| |
| /** |
| * Returns the message to display from the JOptionPane the receiver is |
| * providing the look and feel for. |
| */ |
| protected Object getMessage() { |
| inputComponent = null; |
| if (optionPane != null) { |
| if (optionPane.getWantsInput()) { |
| /* Create a user component to capture the input. If the |
| selectionValues are non null the component and there |
| are < 20 values it'll be a combobox, if non null and |
| >= 20, it'll be a list, otherwise it'll be a textfield. */ |
| Object message = optionPane.getMessage(); |
| Object[] sValues = optionPane.getSelectionValues(); |
| Object inputValue = optionPane |
| .getInitialSelectionValue(); |
| JComponent toAdd; |
| |
| if (sValues != null) { |
| if (sValues.length < 20) { |
| JComboBox cBox = new JComboBox(); |
| |
| cBox.setName("OptionPane.comboBox"); |
| for(int counter = 0, maxCounter = sValues.length; |
| counter < maxCounter; counter++) { |
| cBox.addItem(sValues[counter]); |
| } |
| if (inputValue != null) { |
| cBox.setSelectedItem(inputValue); |
| } |
| inputComponent = cBox; |
| toAdd = cBox; |
| |
| } else { |
| JList list = new JList(sValues); |
| JScrollPane sp = new JScrollPane(list); |
| |
| sp.setName("OptionPane.scrollPane"); |
| list.setName("OptionPane.list"); |
| list.setVisibleRowCount(10); |
| list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); |
| if(inputValue != null) |
| list.setSelectedValue(inputValue, true); |
| list.addMouseListener(getHandler()); |
| toAdd = sp; |
| inputComponent = list; |
| } |
| |
| } else { |
| MultiplexingTextField tf = new MultiplexingTextField(20); |
| |
| tf.setName("OptionPane.textField"); |
| tf.setKeyStrokes(new KeyStroke[] { |
| KeyStroke.getKeyStroke("ENTER") } ); |
| if (inputValue != null) { |
| String inputString = inputValue.toString(); |
| tf.setText(inputString); |
| tf.setSelectionStart(0); |
| tf.setSelectionEnd(inputString.length()); |
| } |
| tf.addActionListener(getHandler()); |
| toAdd = inputComponent = tf; |
| } |
| |
| Object[] newMessage; |
| |
| if (message == null) { |
| newMessage = new Object[1]; |
| newMessage[0] = toAdd; |
| |
| } else { |
| newMessage = new Object[2]; |
| newMessage[0] = message; |
| newMessage[1] = toAdd; |
| } |
| return newMessage; |
| } |
| return optionPane.getMessage(); |
| } |
| return null; |
| } |
| |
| /** |
| * Creates and adds a JLabel representing the icon returned from |
| * <code>getIcon</code> to <code>top</code>. This is messaged from |
| * <code>createMessageArea</code> |
| */ |
| protected void addIcon(Container top) { |
| /* Create the icon. */ |
| Icon sideIcon = getIcon(); |
| |
| if (sideIcon != null) { |
| JLabel iconLabel = new JLabel(sideIcon); |
| |
| iconLabel.setName("OptionPane.iconLabel"); |
| iconLabel.setVerticalAlignment(SwingConstants.TOP); |
| top.add(iconLabel, BorderLayout.BEFORE_LINE_BEGINS); |
| } |
| } |
| |
| /** |
| * Returns the icon from the JOptionPane the receiver is providing |
| * the look and feel for, or the default icon as returned from |
| * <code>getDefaultIcon</code>. |
| */ |
| protected Icon getIcon() { |
| Icon mIcon = (optionPane == null ? null : optionPane.getIcon()); |
| |
| if(mIcon == null && optionPane != null) |
| mIcon = getIconForType(optionPane.getMessageType()); |
| return mIcon; |
| } |
| |
| /** |
| * Returns the icon to use for the passed in type. |
| */ |
| protected Icon getIconForType(int messageType) { |
| if(messageType < 0 || messageType > 3) |
| return null; |
| String propertyName = null; |
| switch(messageType) { |
| case 0: |
| propertyName = "OptionPane.errorIcon"; |
| break; |
| case 1: |
| propertyName = "OptionPane.informationIcon"; |
| break; |
| case 2: |
| propertyName = "OptionPane.warningIcon"; |
| break; |
| case 3: |
| propertyName = "OptionPane.questionIcon"; |
| break; |
| } |
| if (propertyName != null) { |
| return (Icon)DefaultLookup.get(optionPane, this, propertyName); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the maximum number of characters to place on a line. |
| */ |
| protected int getMaxCharactersPerLineCount() { |
| return optionPane.getMaxCharactersPerLineCount(); |
| } |
| |
| /** |
| * Recursively creates new JLabel instances to represent <code>d</code>. |
| * Each JLabel instance is added to <code>c</code>. |
| */ |
| protected void burstStringInto(Container c, String d, int maxll) { |
| // Primitive line wrapping |
| int len = d.length(); |
| if (len <= 0) |
| return; |
| if (len > maxll) { |
| int p = d.lastIndexOf(' ', maxll); |
| if (p <= 0) |
| p = d.indexOf(' ', maxll); |
| if (p > 0 && p < len) { |
| burstStringInto(c, d.substring(0, p), maxll); |
| burstStringInto(c, d.substring(p + 1), maxll); |
| return; |
| } |
| } |
| JLabel label = new JLabel(d, JLabel.LEFT); |
| label.setName("OptionPane.label"); |
| configureMessageLabel(label); |
| c.add(label); |
| } |
| |
| protected Container createSeparator() { |
| return null; |
| } |
| |
| /** |
| * Creates and returns a Container containing the buttons. The buttons |
| * are created by calling <code>getButtons</code>. |
| */ |
| protected Container createButtonArea() { |
| JPanel bottom = new JPanel(); |
| Border border = (Border)DefaultLookup.get(optionPane, this, |
| "OptionPane.buttonAreaBorder"); |
| bottom.setName("OptionPane.buttonArea"); |
| if (border != null) { |
| bottom.setBorder(border); |
| } |
| bottom.setLayout(new ButtonAreaLayout( |
| DefaultLookup.getBoolean(optionPane, this, |
| "OptionPane.sameSizeButtons", true), |
| DefaultLookup.getInt(optionPane, this, "OptionPane.buttonPadding", |
| 6), |
| DefaultLookup.getInt(optionPane, this, |
| "OptionPane.buttonOrientation", SwingConstants.CENTER), |
| DefaultLookup.getBoolean(optionPane, this, "OptionPane.isYesLast", |
| false))); |
| addButtonComponents(bottom, getButtons(), getInitialValueIndex()); |
| return bottom; |
| } |
| |
| /** |
| * Creates the appropriate object to represent each of the objects in |
| * <code>buttons</code> and adds it to <code>container</code>. This |
| * differs from addMessageComponents in that it will recurse on |
| * <code>buttons</code> and that if button is not a Component |
| * it will create an instance of JButton. |
| */ |
| protected void addButtonComponents(Container container, Object[] buttons, |
| int initialIndex) { |
| if (buttons != null && buttons.length > 0) { |
| boolean sizeButtonsToSame = getSizeButtonsToSameWidth(); |
| boolean createdAll = true; |
| int numButtons = buttons.length; |
| JButton[] createdButtons = null; |
| int maxWidth = 0; |
| |
| if (sizeButtonsToSame) { |
| createdButtons = new JButton[numButtons]; |
| } |
| |
| for(int counter = 0; counter < numButtons; counter++) { |
| Object button = buttons[counter]; |
| Component newComponent; |
| |
| if (button instanceof Component) { |
| createdAll = false; |
| newComponent = (Component)button; |
| container.add(newComponent); |
| hasCustomComponents = true; |
| |
| } else { |
| JButton aButton; |
| |
| if (button instanceof ButtonFactory) { |
| aButton = ((ButtonFactory)button).createButton(); |
| } |
| else if (button instanceof Icon) |
| aButton = new JButton((Icon)button); |
| else |
| aButton = new JButton(button.toString()); |
| |
| aButton.setName("OptionPane.button"); |
| aButton.setMultiClickThreshhold(DefaultLookup.getInt( |
| optionPane, this, "OptionPane.buttonClickThreshhold", |
| 0)); |
| configureButton(aButton); |
| |
| container.add(aButton); |
| |
| ActionListener buttonListener = createButtonActionListener(counter); |
| if (buttonListener != null) { |
| aButton.addActionListener(buttonListener); |
| } |
| newComponent = aButton; |
| } |
| if (sizeButtonsToSame && createdAll && |
| (newComponent instanceof JButton)) { |
| createdButtons[counter] = (JButton)newComponent; |
| maxWidth = Math.max(maxWidth, |
| newComponent.getMinimumSize().width); |
| } |
| if (counter == initialIndex) { |
| initialFocusComponent = newComponent; |
| if (initialFocusComponent instanceof JButton) { |
| JButton defaultB = (JButton)initialFocusComponent; |
| defaultB.addHierarchyListener(new HierarchyListener() { |
| public void hierarchyChanged(HierarchyEvent e) { |
| if ((e.getChangeFlags() & |
| HierarchyEvent.PARENT_CHANGED) != 0) { |
| JButton defaultButton = (JButton) e.getComponent(); |
| JRootPane root = |
| SwingUtilities.getRootPane(defaultButton); |
| if (root != null) { |
| root.setDefaultButton(defaultButton); |
| } |
| } |
| } |
| }); |
| } |
| } |
| } |
| ((ButtonAreaLayout)container.getLayout()). |
| setSyncAllWidths((sizeButtonsToSame && createdAll)); |
| /* Set the padding, windows seems to use 8 if <= 2 components, |
| otherwise 4 is used. It may actually just be the size of the |
| buttons is always the same, not sure. */ |
| if (DefaultLookup.getBoolean(optionPane, this, |
| "OptionPane.setButtonMargin", true) && sizeButtonsToSame && |
| createdAll) { |
| JButton aButton; |
| int padSize; |
| |
| padSize = (numButtons <= 2? 8 : 4); |
| |
| for(int counter = 0; counter < numButtons; counter++) { |
| aButton = createdButtons[counter]; |
| aButton.setMargin(new Insets(2, padSize, 2, padSize)); |
| } |
| } |
| } |
| } |
| |
| protected ActionListener createButtonActionListener(int buttonIndex) { |
| return new ButtonActionListener(buttonIndex); |
| } |
| |
| /** |
| * Returns the buttons to display from the JOptionPane the receiver is |
| * providing the look and feel for. If the JOptionPane has options |
| * set, they will be provided, otherwise if the optionType is |
| * YES_NO_OPTION, yesNoOptions is returned, if the type is |
| * YES_NO_CANCEL_OPTION yesNoCancelOptions is returned, otherwise |
| * defaultButtons are returned. |
| */ |
| protected Object[] getButtons() { |
| if (optionPane != null) { |
| Object[] suppliedOptions = optionPane.getOptions(); |
| |
| if (suppliedOptions == null) { |
| Object[] defaultOptions; |
| int type = optionPane.getOptionType(); |
| Locale l = optionPane.getLocale(); |
| int minimumWidth = |
| DefaultLookup.getInt(optionPane, this, |
| "OptionPane.buttonMinimumWidth",-1); |
| if (type == JOptionPane.YES_NO_OPTION) { |
| defaultOptions = new ButtonFactory[2]; |
| defaultOptions[0] = new ButtonFactory( |
| UIManager.getString("OptionPane.yesButtonText", l), |
| getMnemonic("OptionPane.yesButtonMnemonic", l), |
| (Icon)DefaultLookup.get(optionPane, this, |
| "OptionPane.yesIcon"), minimumWidth); |
| defaultOptions[1] = new ButtonFactory( |
| UIManager.getString("OptionPane.noButtonText", l), |
| getMnemonic("OptionPane.noButtonMnemonic", l), |
| (Icon)DefaultLookup.get(optionPane, this, |
| "OptionPane.noIcon"), minimumWidth); |
| } else if (type == JOptionPane.YES_NO_CANCEL_OPTION) { |
| defaultOptions = new ButtonFactory[3]; |
| defaultOptions[0] = new ButtonFactory( |
| UIManager.getString("OptionPane.yesButtonText", l), |
| getMnemonic("OptionPane.yesButtonMnemonic", l), |
| (Icon)DefaultLookup.get(optionPane, this, |
| "OptionPane.yesIcon"), minimumWidth); |
| defaultOptions[1] = new ButtonFactory( |
| UIManager.getString("OptionPane.noButtonText",l), |
| getMnemonic("OptionPane.noButtonMnemonic", l), |
| (Icon)DefaultLookup.get(optionPane, this, |
| "OptionPane.noIcon"), minimumWidth); |
| defaultOptions[2] = new ButtonFactory( |
| UIManager.getString("OptionPane.cancelButtonText",l), |
| getMnemonic("OptionPane.cancelButtonMnemonic", l), |
| (Icon)DefaultLookup.get(optionPane, this, |
| "OptionPane.cancelIcon"), minimumWidth); |
| } else if (type == JOptionPane.OK_CANCEL_OPTION) { |
| defaultOptions = new ButtonFactory[2]; |
| defaultOptions[0] = new ButtonFactory( |
| UIManager.getString("OptionPane.okButtonText",l), |
| getMnemonic("OptionPane.okButtonMnemonic", l), |
| (Icon)DefaultLookup.get(optionPane, this, |
| "OptionPane.okIcon"), minimumWidth); |
| defaultOptions[1] = new ButtonFactory( |
| UIManager.getString("OptionPane.cancelButtonText",l), |
| getMnemonic("OptionPane.cancelButtonMnemonic", l), |
| (Icon)DefaultLookup.get(optionPane, this, |
| "OptionPane.cancelIcon"), minimumWidth); |
| } else { |
| defaultOptions = new ButtonFactory[1]; |
| defaultOptions[0] = new ButtonFactory( |
| UIManager.getString("OptionPane.okButtonText",l), |
| getMnemonic("OptionPane.okButtonMnemonic", l), |
| (Icon)DefaultLookup.get(optionPane, this, |
| "OptionPane.okIcon"), minimumWidth); |
| } |
| return defaultOptions; |
| |
| } |
| return suppliedOptions; |
| } |
| return null; |
| } |
| |
| private int getMnemonic(String key, Locale l) { |
| String value = (String)UIManager.get(key, l); |
| |
| if (value == null) { |
| return 0; |
| } |
| try { |
| return Integer.parseInt(value); |
| } |
| catch (NumberFormatException nfe) { } |
| return 0; |
| } |
| |
| /** |
| * Returns true, basic L&F wants all the buttons to have the same |
| * width. |
| */ |
| protected boolean getSizeButtonsToSameWidth() { |
| return true; |
| } |
| |
| /** |
| * Returns the initial index into the buttons to select. The index |
| * is calculated from the initial value from the JOptionPane and |
| * options of the JOptionPane or 0. |
| */ |
| protected int getInitialValueIndex() { |
| if (optionPane != null) { |
| Object iv = optionPane.getInitialValue(); |
| Object[] options = optionPane.getOptions(); |
| |
| if(options == null) { |
| return 0; |
| } |
| else if(iv != null) { |
| for(int counter = options.length - 1; counter >= 0; counter--){ |
| if(options[counter].equals(iv)) |
| return counter; |
| } |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Sets the input value in the option pane the receiver is providing |
| * the look and feel for based on the value in the inputComponent. |
| */ |
| protected void resetInputValue() { |
| if(inputComponent != null && (inputComponent instanceof JTextField)) { |
| optionPane.setInputValue(((JTextField)inputComponent).getText()); |
| |
| } else if(inputComponent != null && |
| (inputComponent instanceof JComboBox)) { |
| optionPane.setInputValue(((JComboBox)inputComponent) |
| .getSelectedItem()); |
| } else if(inputComponent != null) { |
| optionPane.setInputValue(((JList)inputComponent) |
| .getSelectedValue()); |
| } |
| } |
| |
| |
| /** |
| * If inputComponent is non-null, the focus is requested on that, |
| * otherwise request focus on the default value |
| */ |
| public void selectInitialValue(JOptionPane op) { |
| if (inputComponent != null) |
| inputComponent.requestFocus(); |
| else { |
| if (initialFocusComponent != null) |
| initialFocusComponent.requestFocus(); |
| |
| if (initialFocusComponent instanceof JButton) { |
| JRootPane root = SwingUtilities.getRootPane(initialFocusComponent); |
| if (root != null) { |
| root.setDefaultButton((JButton)initialFocusComponent); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns true if in the last call to validateComponent the message |
| * or buttons contained a subclass of Component. |
| */ |
| public boolean containsCustomComponents(JOptionPane op) { |
| return hasCustomComponents; |
| } |
| |
| |
| /** |
| * <code>ButtonAreaLayout</code> behaves in a similar manner to |
| * <code>FlowLayout</code>. It lays out all components from left to |
| * right. If <code>syncAllWidths</code> is true, the widths of each |
| * component will be set to the largest preferred size width. |
| * |
| * This class should be treated as a "protected" inner class. |
| * Instantiate it only within subclasses of {@code BasicOptionPaneUI}. |
| */ |
| public static class ButtonAreaLayout implements LayoutManager { |
| protected boolean syncAllWidths; |
| protected int padding; |
| /** If true, children are lumped together in parent. */ |
| protected boolean centersChildren; |
| private int orientation; |
| private boolean reverseButtons; |
| /** |
| * Indicates whether or not centersChildren should be used vs |
| * the orientation. This is done for backward compatability |
| * for subclassers. |
| */ |
| private boolean useOrientation; |
| |
| public ButtonAreaLayout(boolean syncAllWidths, int padding) { |
| this.syncAllWidths = syncAllWidths; |
| this.padding = padding; |
| centersChildren = true; |
| useOrientation = false; |
| } |
| |
| ButtonAreaLayout(boolean syncAllSizes, int padding, int orientation, |
| boolean reverseButtons) { |
| this(syncAllSizes, padding); |
| useOrientation = true; |
| this.orientation = orientation; |
| this.reverseButtons = reverseButtons; |
| } |
| |
| public void setSyncAllWidths(boolean newValue) { |
| syncAllWidths = newValue; |
| } |
| |
| public boolean getSyncAllWidths() { |
| return syncAllWidths; |
| } |
| |
| public void setPadding(int newPadding) { |
| this.padding = newPadding; |
| } |
| |
| public int getPadding() { |
| return padding; |
| } |
| |
| public void setCentersChildren(boolean newValue) { |
| centersChildren = newValue; |
| useOrientation = false; |
| } |
| |
| public boolean getCentersChildren() { |
| return centersChildren; |
| } |
| |
| private int getOrientation(Container container) { |
| if (!useOrientation) { |
| return SwingConstants.CENTER; |
| } |
| if (container.getComponentOrientation().isLeftToRight()) { |
| return orientation; |
| } |
| switch (orientation) { |
| case SwingConstants.LEFT: |
| return SwingConstants.RIGHT; |
| case SwingConstants.RIGHT: |
| return SwingConstants.LEFT; |
| case SwingConstants.CENTER: |
| return SwingConstants.CENTER; |
| } |
| return SwingConstants.LEFT; |
| } |
| |
| public void addLayoutComponent(String string, Component comp) { |
| } |
| |
| public void layoutContainer(Container container) { |
| Component[] children = container.getComponents(); |
| |
| if(children != null && children.length > 0) { |
| int numChildren = children.length; |
| Insets insets = container.getInsets(); |
| int maxWidth = 0; |
| int maxHeight = 0; |
| int totalButtonWidth = 0; |
| int x = 0; |
| int xOffset = 0; |
| boolean ltr = container.getComponentOrientation(). |
| isLeftToRight(); |
| boolean reverse = (ltr) ? reverseButtons : !reverseButtons; |
| |
| for(int counter = 0; counter < numChildren; counter++) { |
| Dimension pref = children[counter].getPreferredSize(); |
| maxWidth = Math.max(maxWidth, pref.width); |
| maxHeight = Math.max(maxHeight, pref.height); |
| totalButtonWidth += pref.width; |
| } |
| if (getSyncAllWidths()) { |
| totalButtonWidth = maxWidth * numChildren; |
| } |
| totalButtonWidth += (numChildren - 1) * padding; |
| |
| switch (getOrientation(container)) { |
| case SwingConstants.LEFT: |
| x = insets.left; |
| break; |
| case SwingConstants.RIGHT: |
| x = container.getWidth() - insets.right - totalButtonWidth; |
| break; |
| case SwingConstants.CENTER: |
| if (getCentersChildren() || numChildren < 2) { |
| x = (container.getWidth() - totalButtonWidth) / 2; |
| } |
| else { |
| x = insets.left; |
| if (getSyncAllWidths()) { |
| xOffset = (container.getWidth() - insets.left - |
| insets.right - totalButtonWidth) / |
| (numChildren - 1) + maxWidth; |
| } |
| else { |
| xOffset = (container.getWidth() - insets.left - |
| insets.right - totalButtonWidth) / |
| (numChildren - 1); |
| } |
| } |
| break; |
| } |
| |
| for (int counter = 0; counter < numChildren; counter++) { |
| int index = (reverse) ? numChildren - counter - 1 : |
| counter; |
| Dimension pref = children[index].getPreferredSize(); |
| |
| if (getSyncAllWidths()) { |
| children[index].setBounds(x, insets.top, |
| maxWidth, maxHeight); |
| } |
| else { |
| children[index].setBounds(x, insets.top, pref.width, |
| pref.height); |
| } |
| if (xOffset != 0) { |
| x += xOffset; |
| } |
| else { |
| x += children[index].getWidth() + padding; |
| } |
| } |
| } |
| } |
| |
| public Dimension minimumLayoutSize(Container c) { |
| if(c != null) { |
| Component[] children = c.getComponents(); |
| |
| if(children != null && children.length > 0) { |
| Dimension aSize; |
| int numChildren = children.length; |
| int height = 0; |
| Insets cInsets = c.getInsets(); |
| int extraHeight = cInsets.top + cInsets.bottom; |
| int extraWidth = cInsets.left + cInsets.right; |
| |
| if (syncAllWidths) { |
| int maxWidth = 0; |
| |
| for(int counter = 0; counter < numChildren; counter++){ |
| aSize = children[counter].getPreferredSize(); |
| height = Math.max(height, aSize.height); |
| maxWidth = Math.max(maxWidth, aSize.width); |
| } |
| return new Dimension(extraWidth + (maxWidth * numChildren) + |
| (numChildren - 1) * padding, |
| extraHeight + height); |
| } |
| else { |
| int totalWidth = 0; |
| |
| for(int counter = 0; counter < numChildren; counter++){ |
| aSize = children[counter].getPreferredSize(); |
| height = Math.max(height, aSize.height); |
| totalWidth += aSize.width; |
| } |
| totalWidth += ((numChildren - 1) * padding); |
| return new Dimension(extraWidth + totalWidth, extraHeight + height); |
| } |
| } |
| } |
| return new Dimension(0, 0); |
| } |
| |
| public Dimension preferredLayoutSize(Container c) { |
| return minimumLayoutSize(c); |
| } |
| |
| public void removeLayoutComponent(Component c) { } |
| } |
| |
| |
| /** |
| * This class should be treated as a "protected" inner class. |
| * Instantiate it only within subclasses of {@code BasicOptionPaneUI}. |
| */ |
| public class PropertyChangeHandler implements PropertyChangeListener { |
| /** |
| * If the source of the PropertyChangeEvent <code>e</code> equals the |
| * optionPane and is one of the ICON_PROPERTY, MESSAGE_PROPERTY, |
| * OPTIONS_PROPERTY or INITIAL_VALUE_PROPERTY, |
| * validateComponent is invoked. |
| */ |
| public void propertyChange(PropertyChangeEvent e) { |
| getHandler().propertyChange(e); |
| } |
| } |
| |
| /** |
| * Configures any necessary colors/fonts for the specified label |
| * used representing the message. |
| */ |
| private void configureMessageLabel(JLabel label) { |
| Color color = (Color)DefaultLookup.get(optionPane, this, |
| "OptionPane.messageForeground"); |
| if (color != null) { |
| label.setForeground(color); |
| } |
| Font messageFont = (Font)DefaultLookup.get(optionPane, this, |
| "OptionPane.messageFont"); |
| if (messageFont != null) { |
| label.setFont(messageFont); |
| } |
| } |
| |
| /** |
| * Configures any necessary colors/fonts for the specified button |
| * used representing the button portion of the optionpane. |
| */ |
| private void configureButton(JButton button) { |
| Font buttonFont = (Font)DefaultLookup.get(optionPane, this, |
| "OptionPane.buttonFont"); |
| if (buttonFont != null) { |
| button.setFont(buttonFont); |
| } |
| } |
| |
| /** |
| * This class should be treated as a "protected" inner class. |
| * Instantiate it only within subclasses of {@code BasicOptionPaneUI}. |
| */ |
| public class ButtonActionListener implements ActionListener { |
| protected int buttonIndex; |
| |
| public ButtonActionListener(int buttonIndex) { |
| this.buttonIndex = buttonIndex; |
| } |
| |
| public void actionPerformed(ActionEvent e) { |
| if (optionPane != null) { |
| int optionType = optionPane.getOptionType(); |
| Object[] options = optionPane.getOptions(); |
| |
| /* If the option pane takes input, then store the input value |
| * if custom options were specified, if the option type is |
| * DEFAULT_OPTION, OR if option type is set to a predefined |
| * one and the user chose the affirmative answer. |
| */ |
| if (inputComponent != null) { |
| if (options != null || |
| optionType == JOptionPane.DEFAULT_OPTION || |
| ((optionType == JOptionPane.YES_NO_OPTION || |
| optionType == JOptionPane.YES_NO_CANCEL_OPTION || |
| optionType == JOptionPane.OK_CANCEL_OPTION) && |
| buttonIndex == 0)) { |
| resetInputValue(); |
| } |
| } |
| if (options == null) { |
| if (optionType == JOptionPane.OK_CANCEL_OPTION && |
| buttonIndex == 1) { |
| optionPane.setValue(Integer.valueOf(2)); |
| |
| } else { |
| optionPane.setValue(Integer.valueOf(buttonIndex)); |
| } |
| } else { |
| optionPane.setValue(options[buttonIndex]); |
| } |
| } |
| } |
| } |
| |
| |
| private class Handler implements ActionListener, MouseListener, |
| PropertyChangeListener { |
| // |
| // ActionListener |
| // |
| public void actionPerformed(ActionEvent e) { |
| optionPane.setInputValue(((JTextField)e.getSource()).getText()); |
| } |
| |
| |
| // |
| // MouseListener |
| // |
| public void mouseClicked(MouseEvent e) { |
| } |
| |
| public void mouseReleased(MouseEvent e) { |
| } |
| |
| public void mouseEntered(MouseEvent e) { |
| } |
| |
| public void mouseExited(MouseEvent e) { |
| } |
| |
| public void mousePressed(MouseEvent e) { |
| if (e.getClickCount() == 2) { |
| JList list = (JList)e.getSource(); |
| int index = list.locationToIndex(e.getPoint()); |
| |
| optionPane.setInputValue(list.getModel().getElementAt(index)); |
| optionPane.setValue(JOptionPane.OK_OPTION); |
| } |
| } |
| |
| // |
| // PropertyChangeListener |
| // |
| public void propertyChange(PropertyChangeEvent e) { |
| if(e.getSource() == optionPane) { |
| // Option Pane Auditory Cue Activation |
| // only respond to "ancestor" changes |
| // the idea being that a JOptionPane gets a JDialog when it is |
| // set to appear and loses it's JDialog when it is dismissed. |
| if ("ancestor" == e.getPropertyName()) { |
| JOptionPane op = (JOptionPane)e.getSource(); |
| boolean isComingUp; |
| |
| // if the old value is null, then the JOptionPane is being |
| // created since it didn't previously have an ancestor. |
| if (e.getOldValue() == null) { |
| isComingUp = true; |
| } else { |
| isComingUp = false; |
| } |
| |
| // figure out what to do based on the message type |
| switch (op.getMessageType()) { |
| case JOptionPane.PLAIN_MESSAGE: |
| if (isComingUp) { |
| BasicLookAndFeel.playSound(optionPane, |
| "OptionPane.informationSound"); |
| } |
| break; |
| case JOptionPane.QUESTION_MESSAGE: |
| if (isComingUp) { |
| BasicLookAndFeel.playSound(optionPane, |
| "OptionPane.questionSound"); |
| } |
| break; |
| case JOptionPane.INFORMATION_MESSAGE: |
| if (isComingUp) { |
| BasicLookAndFeel.playSound(optionPane, |
| "OptionPane.informationSound"); |
| } |
| break; |
| case JOptionPane.WARNING_MESSAGE: |
| if (isComingUp) { |
| BasicLookAndFeel.playSound(optionPane, |
| "OptionPane.warningSound"); |
| } |
| break; |
| case JOptionPane.ERROR_MESSAGE: |
| if (isComingUp) { |
| BasicLookAndFeel.playSound(optionPane, |
| "OptionPane.errorSound"); |
| } |
| break; |
| default: |
| System.err.println("Undefined JOptionPane type: " + |
| op.getMessageType()); |
| break; |
| } |
| } |
| // Visual activity |
| String changeName = e.getPropertyName(); |
| |
| if(changeName == JOptionPane.OPTIONS_PROPERTY || |
| changeName == JOptionPane.INITIAL_VALUE_PROPERTY || |
| changeName == JOptionPane.ICON_PROPERTY || |
| changeName == JOptionPane.MESSAGE_TYPE_PROPERTY || |
| changeName == JOptionPane.OPTION_TYPE_PROPERTY || |
| changeName == JOptionPane.MESSAGE_PROPERTY || |
| changeName == JOptionPane.SELECTION_VALUES_PROPERTY || |
| changeName == JOptionPane.INITIAL_SELECTION_VALUE_PROPERTY || |
| changeName == JOptionPane.WANTS_INPUT_PROPERTY) { |
| uninstallComponents(); |
| installComponents(); |
| optionPane.validate(); |
| } |
| else if (changeName == "componentOrientation") { |
| ComponentOrientation o = (ComponentOrientation)e.getNewValue(); |
| JOptionPane op = (JOptionPane)e.getSource(); |
| if (o != e.getOldValue()) { |
| op.applyComponentOrientation(o); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| // |
| // Classes used when optionPane.getWantsInput returns true. |
| // |
| |
| /** |
| * A JTextField that allows you to specify an array of KeyStrokes that |
| * that will have their bindings processed regardless of whether or |
| * not they are registered on the JTextField. This is used as we really |
| * want the ActionListener to be notified so that we can push the |
| * change to the JOptionPane, but we also want additional bindings |
| * (those of the JRootPane) to be processed as well. |
| */ |
| private static class MultiplexingTextField extends JTextField { |
| private KeyStroke[] strokes; |
| |
| MultiplexingTextField(int cols) { |
| super(cols); |
| } |
| |
| /** |
| * Sets the KeyStrokes that will be additional processed for |
| * ancestor bindings. |
| */ |
| void setKeyStrokes(KeyStroke[] strokes) { |
| this.strokes = strokes; |
| } |
| |
| protected boolean processKeyBinding(KeyStroke ks, KeyEvent e, |
| int condition, boolean pressed) { |
| boolean processed = super.processKeyBinding(ks, e, condition, |
| pressed); |
| |
| if (processed && condition != JComponent.WHEN_IN_FOCUSED_WINDOW) { |
| for (int counter = strokes.length - 1; counter >= 0; |
| counter--) { |
| if (strokes[counter].equals(ks)) { |
| // Returning false will allow further processing |
| // of the bindings, eg our parent Containers will get a |
| // crack at them. |
| return false; |
| } |
| } |
| } |
| return processed; |
| } |
| } |
| |
| |
| |
| /** |
| * Registered in the ActionMap. Sets the value of the option pane |
| * to <code>JOptionPane.CLOSED_OPTION</code>. |
| */ |
| private static class Actions extends UIAction { |
| private static final String CLOSE = "close"; |
| |
| Actions(String key) { |
| super(key); |
| } |
| |
| public void actionPerformed(ActionEvent e) { |
| if (getName() == CLOSE) { |
| JOptionPane optionPane = (JOptionPane)e.getSource(); |
| |
| optionPane.setValue(Integer.valueOf(JOptionPane.CLOSED_OPTION)); |
| } |
| } |
| } |
| |
| |
| /** |
| * This class is used to create the default buttons. This indirection is |
| * used so that addButtonComponents can tell which Buttons were created |
| * by us vs subclassers or from the JOptionPane itself. |
| */ |
| private static class ButtonFactory { |
| private String text; |
| private int mnemonic; |
| private Icon icon; |
| private int minimumWidth = -1; |
| |
| ButtonFactory(String text, int mnemonic, Icon icon, int minimumWidth) { |
| this.text = text; |
| this.mnemonic = mnemonic; |
| this.icon = icon; |
| this.minimumWidth = minimumWidth; |
| } |
| |
| JButton createButton() { |
| JButton button; |
| |
| if (minimumWidth > 0) { |
| button = new ConstrainedButton(text, minimumWidth); |
| } else { |
| button = new JButton(text); |
| } |
| if (icon != null) { |
| button.setIcon(icon); |
| } |
| if (mnemonic != 0) { |
| button.setMnemonic(mnemonic); |
| } |
| return button; |
| } |
| |
| private static class ConstrainedButton extends JButton { |
| int minimumWidth; |
| |
| ConstrainedButton(String text, int minimumWidth) { |
| super(text); |
| this.minimumWidth = minimumWidth; |
| } |
| |
| public Dimension getMinimumSize() { |
| Dimension min = super.getMinimumSize(); |
| min.width = Math.max(min.width, minimumWidth); |
| return min; |
| } |
| |
| public Dimension getPreferredSize() { |
| Dimension pref = super.getPreferredSize(); |
| pref.width = Math.max(pref.width, minimumWidth); |
| return pref; |
| } |
| } |
| } |
| } |
