/* * @(#)BasicSpinnerUI.java	1.28 06/04/10 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package javax.swing.plaf.basic;import java.awt.*;import java.awt.event.*;import java.text.ParseException;import javax.swing.*;import javax.swing.border.*;import javax.swing.event.*;import javax.swing.plaf.*;import javax.swing.text.*;import java.beans.*;import java.text.*;import java.util.*;import sun.swing.DefaultLookup;/** * The default Spinner UI delegate. * * @version 1.28 04/10/06 * @author Hans Muller * @since 1.4 */public class BasicSpinnerUI extends SpinnerUI{    /**     * The spinner that we're a UI delegate for.  Initialized by      * the <code>installUI</code> method, and reset to null     * by <code>uninstallUI</code>.     *      * @see #installUI     * @see #uninstallUI     */    protected JSpinner spinner;      private Handler handler;    /**     * The mouse/action listeners that are added to the spinner's      * arrow buttons.  These listeners are shared by all      * spinner arrow buttons.     *      * @see #createNextButton     * @see #createPreviousButton     */    private static final ArrowButtonHandler nextButtonHandler = new ArrowButtonHandler("increment", true);    private static final ArrowButtonHandler previousButtonHandler = new ArrowButtonHandler("decrement", false);    private PropertyChangeListener propertyChangeListener;    /**     * Used by the default LayoutManager class - SpinnerLayout for      * missing (null) editor/nextButton/previousButton children.     */    private static final Dimension zeroSize = new Dimension(0, 0);    /**     * Returns a new instance of BasicSpinnerUI.  SpinnerListUI      * delegates are allocated one per JSpinner.       *      * @param c the JSpinner (not used)     * @see ComponentUI#createUI     * @return a new BasicSpinnerUI object     */    public static ComponentUI createUI(JComponent c) {        return new BasicSpinnerUI();    }    private void maybeAdd(Component c, String s) {	if (c != null) {	    spinner.add(c, s);	}    }    /**     * Calls <code>installDefaults</code>, <code>installListeners</code>,     * and then adds the components returned by <code>createNextButton</code>,     * <code>createPreviousButton</code>, and <code>createEditor</code>.     *      * @param c the JSpinner     * @see #installDefaults     * @see #installListeners     * @see #createNextButton     * @see #createPreviousButton     * @see #createEditor     */    public void installUI(JComponent c) {	this.spinner = (JSpinner)c;	installDefaults();	installListeners();	maybeAdd(createNextButton(), "Next");	maybeAdd(createPreviousButton(), "Previous");	maybeAdd(createEditor(), "Editor");        updateEnabledState();        installKeyboardActions();    }    /**     * Calls <code>uninstallDefaults</code>, <code>uninstallListeners</code>,     * and then removes all of the spinners children.     *      * @param c the JSpinner (not used)     */    public void uninstallUI(JComponent c) {	uninstallDefaults();	uninstallListeners();	this.spinner = null;	c.removeAll();    }        /**     * Initializes <code>PropertyChangeListener</code> with      * a shared object that delegates interesting PropertyChangeEvents     * to protected methods.     * <p>     * This method is called by <code>installUI</code>.     *      * @see #replaceEditor     * @see #uninstallListeners     */    protected void installListeners() {        propertyChangeListener = createPropertyChangeListener();        spinner.addPropertyChangeListener(propertyChangeListener);	if (DefaultLookup.getBoolean(spinner, this,	    "Spinner.disableOnBoundaryValues", false)) {	    spinner.addChangeListener(getHandler());	}	JComponent editor = spinner.getEditor();	if (editor != null && editor instanceof JSpinner.DefaultEditor) {	    JTextField tf = ((JSpinner.DefaultEditor)editor).getTextField();	    if (tf != null) {		tf.addFocusListener(nextButtonHandler);		tf.addFocusListener(previousButtonHandler);	    }	}    }    /**     * Removes the <code>PropertyChangeListener</code> added     * by installListeners.     * <p>     * This method is called by <code>uninstallUI</code>.     *      * @see #installListeners     */    protected void uninstallListeners() {	spinner.removePropertyChangeListener(propertyChangeListener);	spinner.removeChangeListener(handler);	JComponent editor = spinner.getEditor();	removeEditorBorderListener(editor);	if (editor instanceof JSpinner.DefaultEditor) {	    JTextField tf = ((JSpinner.DefaultEditor)editor).getTextField();	    if (tf != null) {		tf.removeFocusListener(nextButtonHandler);		tf.removeFocusListener(previousButtonHandler);	    }	}        propertyChangeListener = null;        handler = null;    }    /**     * Initialize the <code>JSpinner</code> <code>border</code>,      * <code>foreground</code>, and <code>background</code>, properties      * based on the corresponding "Spinner.*" properties from defaults table.       * The <code>JSpinners</code> layout is set to the value returned by     * <code>createLayout</code>.  This method is called by <code>installUI</code>.     *     * @see #uninstallDefaults     * @see #installUI     * @see #createLayout     * @see LookAndFeel#installBorder     * @see LookAndFeel#installColors     */    protected void installDefaults() {	spinner.setLayout(createLayout());        LookAndFeel.installBorder(spinner, "Spinner.border");        LookAndFeel.installColorsAndFont(spinner, "Spinner.background", "Spinner.foreground", "Spinner.font");        LookAndFeel.installProperty(spinner, "opaque", Boolean.TRUE);    }    /**     * Sets the <code>JSpinner's</code> layout manager to null.  This     * method is called by <code>uninstallUI</code>.     *      * @see #installDefaults     * @see #uninstallUI     */    protected void uninstallDefaults() {	spinner.setLayout(null);    }    private Handler getHandler() {        if (handler == null) {            handler = new Handler();        }        return handler;    }    /**     * Installs the necessary listeners on the next button, <code>c</code>,     * to update the <code>JSpinner</code> in response to a user gesture.     *     * @param c Component to install the listeners on     * @throws NullPointerException if <code>c</code> is null.     * @see #createNextButton     * @since 1.5     */    protected void installNextButtonListeners(Component c) {        installButtonListeners(c, nextButtonHandler);    }    /**     * Installs the necessary listeners on the previous button, <code>c</code>,     * to update the <code>JSpinner</code> in response to a user gesture.     *     * @param c Component to install the listeners on.     * @throws NullPointerException if <code>c</code> is null.     * @see #createPreviousButton     * @since 1.5     */    protected void installPreviousButtonListeners(Component c) {        installButtonListeners(c, previousButtonHandler);    }    private void installButtonListeners(Component c,                                        ArrowButtonHandler handler) {        if (c instanceof JButton) {            ((JButton)c).addActionListener(handler);        }        c.addMouseListener(handler);    }    /**     * Create a <code>LayoutManager</code> that manages the <code>editor</code>,      * <code>nextButton</code>, and <code>previousButton</code>      * children of the JSpinner.  These three children must be     * added with a constraint that identifies their role:      * "Editor", "Next", and "Previous". The default layout manager      * can handle the absence of any of these children.     *      * @return a LayoutManager for the editor, next button, and previous button.     * @see #createNextButton     * @see #createPreviousButton     * @see #createEditor     */    protected LayoutManager createLayout() {        return getHandler();    }    /**     * Create a <code>PropertyChangeListener</code> that can be     * added to the JSpinner itself.  Typically, this listener     * will call replaceEditor when the "editor" property changes,      * since it's the <code>SpinnerUI's</code> responsibility to      * add the editor to the JSpinner (and remove the old one).     * This method is called by <code>installListeners</code>.     *      * @return A PropertyChangeListener for the JSpinner itself     * @see #installListeners     */    protected PropertyChangeListener createPropertyChangeListener() {        return getHandler();    }    /**     * Create a component that will replace the spinner models value     * with the object returned by <code>spinner.getPreviousValue</code>.     * By default the <code>previousButton</code> is a JButton. This     * method invokes <code>installPreviousButtonListeners</code> to     * install the necessary listeners to update the <code>JSpinner</code>'s     * model in response to a user gesture. If a previousButton isn't needed     * (in a subclass) then override this method to return null.     *     * @return a component that will replace the spinners model with the     *     next value in the sequence, or null     * @see #installUI     * @see #createNextButton     * @see #installPreviousButtonListeners     */    protected Component createPreviousButton() {	Component c = createArrowButton(SwingConstants.SOUTH);        c.setName("Spinner.previousButton");        installPreviousButtonListeners(c);        return c;    }    /**     * Create a component that will replace the spinner models value     * with the object returned by <code>spinner.getNextValue</code>.     * By default the <code>nextButton</code> is a JButton     * who's <code>ActionListener</code> updates it's <code>JSpinner</code>     * ancestors model.  If a nextButton isn't needed (in a subclass)     * then override this method to return null.     *     * @return a component that will replace the spinners model with the     *     next value in the sequence, or null     * @see #installUI     * @see #createPreviousButton     * @see #installNextButtonListeners     */    protected Component createNextButton() {	Component c = createArrowButton(SwingConstants.NORTH);        c.setName("Spinner.nextButton");        installNextButtonListeners(c);        return c;    }    private Component createArrowButton(int direction) {	JButton b = new BasicArrowButton(direction);	Border buttonBorder = UIManager.getBorder("Spinner.arrowButtonBorder");	if (buttonBorder instanceof UIResource) {	    // Wrap the border to avoid having the UIResource be replaced by	    // the ButtonUI. This is the opposite of using BorderUIResource.	    b.setBorder(new CompoundBorder(buttonBorder, null));	} else {	    b.setBorder(buttonBorder);	}        b.setInheritsPopupMenu(true);	return b;    }    /**     * This method is called by installUI to get the editor component     * of the <code>JSpinner</code>.  By default it just returns      * <code>JSpinner.getEditor()</code>.  Subclasses can override     * <code>createEditor</code> to return a component that contains      * the spinner's editor or null, if they're going to handle adding