| /* |
| * Copyright (c) 2000, 2010, 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 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); |
| } |
| |
| /** |
| * Creates 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(); |
| } |
| |
| |
| /** |
| * Creates 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(); |
| } |
| |
| |
| /** |
| * Creates a decrement button, i.e. component that replaces the spinner |
| * value with the object returned by <code>spinner.getPreviousValue</code>. |
| * By default the <code>previousButton</code> is a {@code JButton}. If the |
| * decrement button is not needed this method should return {@code null}. |
| * |
| * @return a component that will replace the spinner's value with the |
| * previous value in the sequence, or {@code null} |
| * @see #installUI |
| * @see #createNextButton |
| * @see #installPreviousButtonListeners |
| */ |
| protected Component createPreviousButton() { |
| Component c = createArrowButton(SwingConstants.SOUTH); |
| c.setName("Spinner.previousButton"); |
| installPreviousButtonListeners(c); |
| return c; |
| } |
| |
| |
| /** |
| * Creates an increment button, i.e. component that replaces the spinner |
| * value with the object returned by <code>spinner.getNextValue</code>. |
| * By default the <code>nextButton</code> is a {@code JButton}. If the |
| * increment button is not needed this method should return {@code null}. |
| * |
| * @return a component that will replace the spinner's value with the |
| * next value in the sequence, or {@code 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. |
| WHEN_ANCESTOR_OF_FOCUSED_COMPONENT); |
| |
| SwingUtilities.replaceUIInputMap(spinner, JComponent. |
| WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, |
| iMap); |
| |
| LazyActionMap.installLazyActionMap(spinner, BasicSpinnerUI.class, |
| "Spinner.actionMap"); |
| } |
| |
| /** |
| * Returns the InputMap to install for <code>condition</code>. |
| */ |
| private InputMap getInputMap(int condition) { |
| if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) { |
| return (InputMap)DefaultLookup.get(spinner, this, |
| "Spinner.ancestorInputMap"); |
| } |
| return null; |
| } |
| |
| static void loadActionMap(LazyActionMap map) { |
| map.put("increment", nextButtonHandler); |
| map.put("decrement", previousButtonHandler); |
| } |
| |
| /** |
| * Returns the baseline. |
| * |
| * @throws NullPointerException {@inheritDoc} |
| * @throws IllegalArgumentException {@inheritDoc} |
| * @see javax.swing.JComponent#getBaseline(int, int) |
| * @since 1.6 |
| */ |
| public int getBaseline(JComponent c, int width, int height) { |
| super.getBaseline(c, width, height); |
| JComponent editor = spinner.getEditor(); |
| Insets insets = spinner.getInsets(); |
| width = width - insets.left - insets.right; |
| height = height - insets.top - insets.bottom; |
| if (width >= 0 && height >= 0) { |
| int baseline = editor.getBaseline(width, height); |
| if (baseline >= 0) { |
| return insets.top + baseline; |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Returns an enum indicating how the baseline of the component |
| * changes as the size changes. |
| * |
| * @throws NullPointerException {@inheritDoc} |
| * @see javax.swing.JComponent#getBaseline(int, int) |
| * @since 1.6 |
| */ |
| public Component.BaselineResizeBehavior getBaselineResizeBehavior( |
| JComponent c) { |
| super.getBaselineResizeBehavior(c); |
| return spinner.getEditor().getBaselineResizeBehavior(); |
| } |
| |
| /** |
| * A handler for spinner arrow button mouse and action events. When |
| * a left mouse pressed event occurs we look up the (enabled) spinner |
| * that's the source of the event and start the autorepeat timer. The |
| * timer fires action events until any button is released at which |
| * point the timer is stopped and the reference to the spinner cleared. |
| * The timer doesn't start until after a 300ms delay, so often the |
| * source of the initial (and final) action event is just the button |
| * logic for mouse released - which means that we're relying on the fact |
| * that our mouse listener runs after the buttons mouse listener. |
| * <p> |
| * Note that one instance of this handler is shared by all slider previous |
| * arrow buttons and likewise for all of the next buttons, |
| * so it doesn't have any state that persists beyond the limits |
| * of a single button pressed/released gesture. |
| */ |
| private static class ArrowButtonHandler extends AbstractAction |
| implements FocusListener, MouseListener, UIResource { |
| final javax.swing.Timer autoRepeatTimer; |
| final boolean isNext; |
| JSpinner spinner = null; |
| JButton arrowButton = null; |
| |
| ArrowButtonHandler(String name, boolean isNext) { |
| super(name); |
| this.isNext = isNext; |
| autoRepeatTimer = new javax.swing.Timer(60, this); |
| autoRepeatTimer.setInitialDelay(300); |
| } |
| |
| private JSpinner eventToSpinner(AWTEvent e) { |
| Object src = e.getSource(); |
| while ((src instanceof Component) && !(src instanceof JSpinner)) { |
| src = ((Component)src).getParent(); |
| } |
| return (src instanceof JSpinner) ? (JSpinner)src : null; |
| } |
| |
| public void actionPerformed(ActionEvent e) { |
| JSpinner spinner = this.spinner; |
| |
| if (!(e.getSource() instanceof javax.swing.Timer)) { |
| // Most likely resulting from being in ActionMap. |
| spinner = eventToSpinner(e); |
| if (e.getSource() instanceof JButton) { |
| arrowButton = (JButton)e.getSource(); |
| } |
| } else { |
| if (arrowButton!=null && !arrowButton.getModel().isPressed() |
| && autoRepeatTimer.isRunning()) { |
| autoRepeatTimer.stop(); |
| spinner = null; |
| arrowButton = null; |
| } |
| } |
| if (spinner != null) { |
| try { |
| int calendarField = getCalendarField(spinner); |
| spinner.commitEdit(); |
| if (calendarField != -1) { |
| ((SpinnerDateModel)spinner.getModel()). |
| setCalendarField(calendarField); |
| } |
| Object value = (isNext) ? spinner.getNextValue() : |
| spinner.getPreviousValue(); |
| if (value != null) { |
| spinner.setValue(value); |
| select(spinner); |
| } |
| } catch (IllegalArgumentException iae) { |
| UIManager.getLookAndFeel().provideErrorFeedback(spinner); |
| } catch (ParseException pe) { |
| UIManager.getLookAndFeel().provideErrorFeedback(spinner); |
| } |
| } |
| } |
| |
| /** |
| * If the spinner's editor is a DateEditor, this selects the field |
| * associated with the value that is being incremented. |
| */ |
| private void select(JSpinner spinner) { |
| JComponent editor = spinner.getEditor(); |
| |
| if (editor instanceof JSpinner.DateEditor) { |
| JSpinner.DateEditor dateEditor = (JSpinner.DateEditor)editor; |
| JFormattedTextField ftf = dateEditor.getTextField(); |
| Format format = dateEditor.getFormat(); |
| Object value; |
| |
| if (format != null && (value = spinner.getValue()) != null) { |
| SpinnerDateModel model = dateEditor.getModel(); |
| DateFormat.Field field = DateFormat.Field.ofCalendarField( |
| model.getCalendarField()); |
| |
| if (field != null) { |
| try { |
| AttributedCharacterIterator iterator = format. |
| formatToCharacterIterator(value); |
| if (!select(ftf, iterator, field) && |
| field == DateFormat.Field.HOUR0) { |
| select(ftf, iterator, DateFormat.Field.HOUR1); |
| } |
| } |
| catch (IllegalArgumentException iae) {} |
| } |
| } |
| } |
| } |
| |
| /** |
| * Selects the passed in field, returning true if it is found, |
| * false otherwise. |
| */ |
| private boolean select(JFormattedTextField ftf, |
| AttributedCharacterIterator iterator, |
| DateFormat.Field field) { |
| int max = ftf.getDocument().getLength(); |
| |
| iterator.first(); |
| do { |
| Map attrs = iterator.getAttributes(); |
| |
| if (attrs != null && attrs.containsKey(field)){ |
| int start = iterator.getRunStart(field); |
| int end = iterator.getRunLimit(field); |
| |
| if (start != -1 && end != -1 && start <= max && |
| end <= max) { |
| ftf.select(start, end); |
| } |
| return true; |
| } |
| } while (iterator.next() != CharacterIterator.DONE); |
| return false; |
| } |
| |
| /** |
| * Returns the calendarField under the start of the selection, or |
| * -1 if there is no valid calendar field under the selection (or |
| * the spinner isn't editing dates. |
| */ |
| private int getCalendarField(JSpinner spinner) { |
| JComponent editor = spinner.getEditor(); |
| |
| if (editor instanceof JSpinner.DateEditor) { |
| JSpinner.DateEditor dateEditor = (JSpinner.DateEditor)editor; |
| JFormattedTextField ftf = dateEditor.getTextField(); |
| int start = ftf.getSelectionStart(); |
| JFormattedTextField.AbstractFormatter formatter = |
| ftf.getFormatter(); |
| |
| if (formatter instanceof InternationalFormatter) { |
| Format.Field[] fields = ((InternationalFormatter) |
| formatter).getFields(start); |
| |
| for (int counter = 0; counter < fields.length; counter++) { |
| if (fields[counter] instanceof DateFormat.Field) { |
| int calendarField; |
| |
| if (fields[counter] == DateFormat.Field.HOUR1) { |
| calendarField = Calendar.HOUR; |
| } |
| else { |
| calendarField = ((DateFormat.Field) |
| fields[counter]).getCalendarField(); |
| } |
| if (calendarField != -1) { |
| return calendarField; |
| } |
| } |
| } |
| } |
| } |
| return -1; |
| } |
| |
| public void mousePressed(MouseEvent e) { |
| if (SwingUtilities.isLeftMouseButton(e) && e.getComponent().isEnabled()) { |
| spinner = eventToSpinner(e); |
| autoRepeatTimer.start(); |
| |
| focusSpinnerIfNecessary(); |
| } |
| } |
| |
| public void mouseReleased(MouseEvent e) { |
| autoRepeatTimer.stop(); |
| arrowButton = null; |
| spinner = null; |
| } |
| |
| public void mouseClicked(MouseEvent e) { |
| } |
| |
| public void mouseEntered(MouseEvent e) { |
| if (spinner != null && !autoRepeatTimer.isRunning() && spinner == eventToSpinner(e)) { |
| autoRepeatTimer.start(); |
| } |
| } |
| |
| public void mouseExited(MouseEvent e) { |
| if (autoRepeatTimer.isRunning()) { |
| autoRepeatTimer.stop(); |
| } |
| } |
| |
| /** |
| * Requests focus on a child of the spinner if the spinner doesn't |
| * have focus. |
| */ |
| private void focusSpinnerIfNecessary() { |
| Component fo = KeyboardFocusManager. |
| getCurrentKeyboardFocusManager().getFocusOwner(); |
| if (spinner.isRequestFocusEnabled() && ( |
| fo == null || |
| !SwingUtilities.isDescendingFrom(fo, spinner))) { |
| Container root = spinner; |
| |
| if (!root.isFocusCycleRoot()) { |
| root = root.getFocusCycleRootAncestor(); |
| } |
| if (root != null) { |
| FocusTraversalPolicy ftp = root.getFocusTraversalPolicy(); |
| Component child = ftp.getComponentAfter(root, spinner); |
| |
| if (child != null && SwingUtilities.isDescendingFrom( |
| child, spinner)) { |
| child.requestFocus(); |
| } |
| } |
| } |
| } |
| |
| public void focusGained(FocusEvent e) { |
| } |
| |
| public void focusLost(FocusEvent e) { |
| if (spinner == eventToSpinner(e)) { |
| if (autoRepeatTimer.isRunning()) { |
| autoRepeatTimer.stop(); |
| } |
| spinner = null; |
| if (arrowButton != null) { |
| ButtonModel model = arrowButton.getModel(); |
| model.setPressed(false); |
| model.setArmed(false); |
| arrowButton = null; |
| } |
| } |
| } |
| } |
| |
| |
| private static class Handler implements LayoutManager, |
| PropertyChangeListener, ChangeListener { |
| // |
| // LayoutManager |
| // |
| private Component nextButton = null; |
| private Component previousButton = null; |
| private Component editor = null; |
| |
| public void addLayoutComponent(String name, Component c) { |
| if ("Next".equals(name)) { |
| nextButton = c; |
| } |
| else if ("Previous".equals(name)) { |
| previousButton = c; |
| } |
| else if ("Editor".equals(name)) { |
| editor = c; |
| } |
| } |
| |
| public void removeLayoutComponent(Component c) { |
| if (c == nextButton) { |
| nextButton = null; |
| } |
| else if (c == previousButton) { |
| previousButton = null; |
| } |
| else if (c == editor) { |
| editor = null; |
| } |
| } |
| |
| private Dimension preferredSize(Component c) { |
| return (c == null) ? zeroSize : c.getPreferredSize(); |
| } |
| |
| public Dimension preferredLayoutSize(Container parent) { |
| Dimension nextD = preferredSize(nextButton); |
| Dimension previousD = preferredSize(previousButton); |
| Dimension editorD = preferredSize(editor); |
| |
| /* Force the editors height to be a multiple of 2 |
| */ |
| editorD.height = ((editorD.height + 1) / 2) * 2; |
| |
| Dimension size = new Dimension(editorD.width, editorD.height); |
| size.width += Math.max(nextD.width, previousD.width); |
| Insets insets = parent.getInsets(); |
| size.width += insets.left + insets.right; |
| size.height += insets.top + insets.bottom; |
| return size; |
| } |
| |
| public Dimension minimumLayoutSize(Container parent) { |
| return preferredLayoutSize(parent); |
| } |
| |
| private void setBounds(Component c, int x, int y, int width, int height) { |
| if (c != null) { |
| c.setBounds(x, y, width, height); |
| } |
| } |
| |
| public void layoutContainer(Container parent) { |
| int width = parent.getWidth(); |
| int height = parent.getHeight(); |
| |
| Insets insets = parent.getInsets(); |
| |
| if (nextButton == null && previousButton == null) { |
| setBounds(editor, insets.left, insets.top, width - insets.left - insets.right, |
| height - insets.top - insets.bottom); |
| |
| return; |
| } |
| |
| Dimension nextD = preferredSize(nextButton); |
| Dimension previousD = preferredSize(previousButton); |
| int buttonsWidth = Math.max(nextD.width, previousD.width); |
| int editorHeight = height - (insets.top + insets.bottom); |
| |
| // The arrowButtonInsets value is used instead of the JSpinner's |
| // insets if not null. Defining this to be (0, 0, 0, 0) causes the |
| // buttons to be aligned with the outer edge of the spinner's |
| // border, and leaving it as "null" places the buttons completely |
| // inside the spinner's border. |
| Insets buttonInsets = UIManager.getInsets("Spinner.arrowButtonInsets"); |
| if (buttonInsets == null) { |
| buttonInsets = insets; |
| } |
| |
| /* Deal with the spinner's componentOrientation property. |
| */ |
| int editorX, editorWidth, buttonsX; |
| if (parent.getComponentOrientation().isLeftToRight()) { |
| editorX = insets.left; |
| editorWidth = width - insets.left - buttonsWidth - buttonInsets.right; |
| buttonsX = width - buttonsWidth - buttonInsets.right; |
| } else { |
| buttonsX = buttonInsets.left; |
| editorX = buttonsX + buttonsWidth; |
| editorWidth = width - buttonInsets.left - buttonsWidth - insets.right; |
| } |
| |
| int nextY = buttonInsets.top; |
| int nextHeight = (height / 2) + (height % 2) - nextY; |
| int previousY = buttonInsets.top + nextHeight; |
| int previousHeight = height - previousY - buttonInsets.bottom; |
| |
| setBounds(editor, editorX, insets.top, editorWidth, editorHeight); |
| setBounds(nextButton, buttonsX, nextY, buttonsWidth, nextHeight); |
| setBounds(previousButton, buttonsX, previousY, buttonsWidth, previousHeight); |
| } |
| |
| |
| // |
| // PropertyChangeListener |
| // |
| public void propertyChange(PropertyChangeEvent e) |
| { |
| String propertyName = e.getPropertyName(); |
| if (e.getSource() instanceof JSpinner) { |
| JSpinner spinner = (JSpinner)(e.getSource()); |
| SpinnerUI spinnerUI = spinner.getUI(); |
| |
| if (spinnerUI instanceof BasicSpinnerUI) { |
| BasicSpinnerUI ui = (BasicSpinnerUI)spinnerUI; |
| |
| if ("editor".equals(propertyName)) { |
| JComponent oldEditor = (JComponent)e.getOldValue(); |
| JComponent newEditor = (JComponent)e.getNewValue(); |
| ui.replaceEditor(oldEditor, newEditor); |
| ui.updateEnabledState(); |
| if (oldEditor instanceof JSpinner.DefaultEditor) { |
| JTextField tf = |
| ((JSpinner.DefaultEditor)oldEditor).getTextField(); |
| if (tf != null) { |
| tf.removeFocusListener(nextButtonHandler); |
| tf.removeFocusListener(previousButtonHandler); |
| } |
| } |
| if (newEditor instanceof JSpinner.DefaultEditor) { |
| JTextField tf = |
| ((JSpinner.DefaultEditor)newEditor).getTextField(); |
| if (tf != null) { |
| if (tf.getFont() instanceof UIResource) { |
| tf.setFont(spinner.getFont()); |
| } |
| tf.addFocusListener(nextButtonHandler); |
| tf.addFocusListener(previousButtonHandler); |
| } |
| } |
| } |
| else if ("enabled".equals(propertyName) || |
| "model".equals(propertyName)) { |
| ui.updateEnabledState(); |
| } |
| else if ("font".equals(propertyName)) { |
| JComponent editor = spinner.getEditor(); |
| if (editor!=null && editor instanceof JSpinner.DefaultEditor) { |
| JTextField tf = |
| ((JSpinner.DefaultEditor)editor).getTextField(); |
| if (tf != null) { |
| if (tf.getFont() instanceof UIResource) { |
| tf.setFont(spinner.getFont()); |
| } |
| } |
| } |
| } |
| else if (JComponent.TOOL_TIP_TEXT_KEY.equals(propertyName)) { |
| updateToolTipTextForChildren(spinner); |
| } |
| } |
| } else if (e.getSource() instanceof JComponent) { |
| JComponent c = (JComponent)e.getSource(); |
| if ((c.getParent() instanceof JPanel) && |
| (c.getParent().getParent() instanceof JSpinner) && |
| "border".equals(propertyName)) { |
| |
| JSpinner spinner = (JSpinner)c.getParent().getParent(); |
| SpinnerUI spinnerUI = spinner.getUI(); |
| if (spinnerUI instanceof BasicSpinnerUI) { |
| BasicSpinnerUI ui = (BasicSpinnerUI)spinnerUI; |
| ui.maybeRemoveEditorBorder(c); |
| } |
| } |
| } |
| } |
| |
| // Syncronizes the ToolTip text for the components within the spinner |
| // to be the same value as the spinner ToolTip text. |
| private void updateToolTipTextForChildren(JComponent spinner) { |
| String toolTipText = spinner.getToolTipText(); |
| Component[] children = spinner.getComponents(); |
| for (int i = 0; i < children.length; i++) { |
| if (children[i] instanceof JSpinner.DefaultEditor) { |
| JTextField tf = ((JSpinner.DefaultEditor)children[i]).getTextField(); |
| if (tf != null) { |
| tf.setToolTipText(toolTipText); |
| } |
| } else if (children[i] instanceof JComponent) { |
| ((JComponent)children[i]).setToolTipText( spinner.getToolTipText() ); |
| } |
| } |
| } |
| |
| public void stateChanged(ChangeEvent e) { |
| if (e.getSource() instanceof JSpinner) { |
| JSpinner spinner = (JSpinner)e.getSource(); |
| SpinnerUI spinnerUI = spinner.getUI(); |
| if (DefaultLookup.getBoolean(spinner, spinnerUI, |
| "Spinner.disableOnBoundaryValues", false) && |
| spinnerUI instanceof BasicSpinnerUI) { |
| BasicSpinnerUI ui = (BasicSpinnerUI)spinnerUI; |
| ui.updateEnabledState(); |
| } |
| } |
| } |
| } |
| } |
