/*

 * Copyright 2000-2007 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

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.

 *

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

     * the editor to the <code>JSpinner</code> in an

     * <code>installUI</code> override.

     * <p>

     * Typically this method would be overridden to wrap the editor

     * with a container with a custom border, since one can't assume

     * that the editors border can be set directly.

     * <p>

     * The <code>replaceEditor</code> method is called when the spinners

     * editor is changed with <code>JSpinner.setEditor</code>.  If you've

     * overriden this method, then you'll probably want to override

     * <code>replaceEditor</code> as well.

     *

     * @return the JSpinners editor JComponent, spinner.getEditor() by default

     * @see #installUI

     * @see #replaceEditor

     * @see JSpinner#getEditor

     */

    protected JComponent createEditor() {

        JComponent editor = spinner.getEditor();

        maybeRemoveEditorBorder(editor);

        installEditorBorderListener(editor);

        editor.setInheritsPopupMenu(true);

        updateEditorAlignment(editor);

        return editor;

    }

    /**

     * Called by the <code>PropertyChangeListener</code> when the

     * <code>JSpinner</code> editor property changes.  It's the responsibility

     * of this method to remove the old editor and add the new one.  By

     * default this operation is just:

     * <pre>

     * spinner.remove(oldEditor);

     * spinner.add(newEditor, "Editor");

     * </pre>

     * The implementation of <code>replaceEditor</code> should be coordinated

     * with the <code>createEditor</code> method.

     *

     * @see #createEditor

     * @see #createPropertyChangeListener

     */

    protected void replaceEditor(JComponent oldEditor, JComponent newEditor) {

        spinner.remove(oldEditor);

        maybeRemoveEditorBorder(newEditor);

        installEditorBorderListener(newEditor);

        newEditor.setInheritsPopupMenu(true);

        spinner.add(newEditor, "Editor");

    }

    private void updateEditorAlignment(JComponent editor) {

        if (editor instanceof JSpinner.DefaultEditor) {

            // if editor alignment isn't set in LAF, we get 0 (CENTER) here

            int alignment = UIManager.getInt("Spinner.editorAlignment");

            JTextField text = ((JSpinner.DefaultEditor)editor).getTextField();

            text.setHorizontalAlignment(alignment);

        }

    }

    /**

     * Remove the border around the inner editor component for LaFs

     * that install an outside border around the spinner,

     */

    private void maybeRemoveEditorBorder(JComponent editor) {

        if (!UIManager.getBoolean("Spinner.editorBorderPainted")) {

            if (editor instanceof JPanel &&

                editor.getBorder() == null &&

                editor.getComponentCount() > 0) {

                editor = (JComponent)editor.getComponent(0);

            }

            if (editor != null && editor.getBorder() instanceof UIResource) {

                editor.setBorder(null);

            }

        }

    }

    /**

     * Remove the border around the inner editor component for LaFs

     * that install an outside border around the spinner,

     */

    private void installEditorBorderListener(JComponent editor) {

        if (!UIManager.getBoolean("Spinner.editorBorderPainted")) {

            if (editor instanceof JPanel &&

                editor.getBorder() == null &&

                editor.getComponentCount() > 0) {

                editor = (JComponent)editor.getComponent(0);

            }

            if (editor != null &&

                (editor.getBorder() == null ||

                 editor.getBorder() instanceof UIResource)) {

                editor.addPropertyChangeListener(getHandler());

            }

        }

    }

    private void removeEditorBorderListener(JComponent editor) {

        if (!UIManager.getBoolean("Spinner.editorBorderPainted")) {

            if (editor instanceof JPanel &&

                editor.getComponentCount() > 0) {

                editor = (JComponent)editor.getComponent(0);

            }

            if (editor != null) {

                editor.removePropertyChangeListener(getHandler());

            }

        }

    }

    /**

     * Updates the enabled state of the children Components based on the

     * enabled state of the <code>JSpinner</code>.

     */

    private void updateEnabledState() {

        updateEnabledState(spinner, spinner.isEnabled());

    }

    /**

     * Recursively updates the enabled state of the child

     * <code>Component</code>s of <code>c</code>.

     */

    private void updateEnabledState(Container c, boolean enabled) {

        for (int counter = c.getComponentCount() - 1; counter >= 0;counter--) {

            Component child = c.getComponent(counter);

            if (DefaultLookup.getBoolean(spinner, this,

                "Spinner.disableOnBoundaryValues", false)) {

                SpinnerModel model = spinner.getModel();

                if (child.getName() == "Spinner.nextButton" &&

                    model.getNextValue() == null) {

                    child.setEnabled(false);

                }

                else if (child.getName() == "Spinner.previousButton" &&

                         model.getPreviousValue() == null) {

                    child.setEnabled(false);

                }

                else {

                    child.setEnabled(enabled);

                }

            }

            else {

                child.setEnabled(enabled);

            }

            if (child instanceof Container) {

                updateEnabledState((Container)child, enabled);

            }

        }

    }

    /**

     * Installs the keyboard Actions onto the JSpinner.

     *

     * @since 1.5

     */

    protected void installKeyboardActions() {

        InputMap iMap = getInputMap(JComponent.