Package Summary Overview Summary

### class:JSpinner.DefaultEditor [NONE]
- All Implemented Interfaces: ImageObserver, LayoutManager, MenuContainer, PropertyChangeListener, Serializable, EventListener, Accessible, ChangeListener Direct Known Subclasses: JSpinner.DateEditor, JSpinner.ListEditor, JSpinner.NumberEditor Enclosing class: JSpinner
      public static class JSpinner.DefaultEditor
      extends JPanel
      implements ChangeListener, PropertyChangeListener, LayoutManager
A simple base class for more specialized editors that displays a read-only view of the model's current value with a `JFormattedTextField`. Subclasses can configure the `JFormattedTextField` to create an editor that's appropriate for the type of model they support and they may want to override the `stateChanged` and `propertyChanged` methods, which keep the model and the text field in sync. This class defines a `dismiss` method that removes the editors `ChangeListener` from the `JSpinner` that it's part of. The `setEditor` method knows about `DefaultEditor.dismiss`, so if the developer replaces an editor that's derived from `JSpinner.DefaultEditor` its `ChangeListener` connection back to the `JSpinner` will be removed. However after that, it's up to the developer to manage their editor listeners. Similarly, if a subclass overrides `createEditor`, it's up to the subclasser to deal with their editor subsequently being replaced (with `setEditor`). We expect that in most cases, and in editor installed with `setEditor` or created by a `createEditor` override, will not be replaced anyway. This class is the `LayoutManager` for it's single `JFormattedTextField` child. By default the child is just centered with the parents insets. Since: 1.4

### constructor:DefaultEditor(javax.swing.JSpinner) [NONE]
- #### DefaultEditor
      public DefaultEditor(JSpinner spinner)
Constructs an editor component for the specified `JSpinner`. This `DefaultEditor` is it's own layout manager and it is added to the spinner's `ChangeListener` list. The constructor creates a single `JFormattedTextField` child, initializes it's value to be the spinner model's current value and adds it to `this` `DefaultEditor`. Parameters: `spinner` - the spinner whose model `this` editor will monitor See Also: `getTextField()`, `JSpinner.addChangeListener(javax.swing.event.ChangeListener)`

### method:dismiss(javax.swing.JSpinner) [NONE]
- #### dismiss
      public void dismiss(JSpinner spinner)
Disconnect `this` editor from the specified `JSpinner`. By default, this method removes itself from the spinners `ChangeListener` list. Parameters: `spinner` - the `JSpinner` to disconnect this editor from; the same spinner as was passed to the constructor.

### method:getSpinner() [NONE]
- #### getSpinner
      public JSpinner getSpinner()
Returns the `JSpinner` ancestor of this editor or `null` if none of the ancestors are a `JSpinner`. Typically the editor's parent is a `JSpinner` however subclasses of `JSpinner` may override the the `createEditor` method and insert one or more containers between the `JSpinner` and it's editor. Returns: `JSpinner` ancestor; `null` if none of the ancestors are a `JSpinner` See Also: `JSpinner.createEditor(javax.swing.SpinnerModel)`

### method:getTextField() [NONE]
- #### getTextField
      public JFormattedTextField getTextField()
Returns the `JFormattedTextField` child of this editor. By default the text field is the first and only child of editor. Returns: the `JFormattedTextField` that gives the user access to the `SpinnerDateModel's` value. See Also: `getSpinner()`, `JSpinner.getModel()`

### method:stateChanged(javax.swing.event.ChangeEvent) [NONE]
- #### stateChanged
      public void stateChanged(ChangeEvent e)
This method is called when the spinner's model's state changes. It sets the `value` of the text field to the current value of the spinners model. Specified by: `stateChanged` in interface `ChangeListener` Parameters: `e` - the `ChangeEvent` whose source is the `JSpinner` whose model has changed. See Also: `getTextField()`, `JSpinner.getValue()`

### method:propertyChange(java.beans.PropertyChangeEvent) [NONE]
- #### propertyChange
      public void propertyChange(PropertyChangeEvent e)
Called by the `JFormattedTextField` `PropertyChangeListener`. When the `"value"` property changes, which implies that the user has typed a new number, we set the value of the spinners model. This class ignores `PropertyChangeEvents` whose source is not the `JFormattedTextField`, so subclasses may safely make `this` `DefaultEditor` a `PropertyChangeListener` on other objects. Specified by: `propertyChange` in interface `PropertyChangeListener` Parameters: `e` - the `PropertyChangeEvent` whose source is the `JFormattedTextField` created by this class. See Also: `getTextField()`

### method:addLayoutComponent(java.lang.String, java.awt.Component) [NONE]
- #### addLayoutComponent
      public void addLayoutComponent(String name,
                                     Component child)
This `LayoutManager` method does nothing. We're only managing a single child and there's no support for layout constraints. Specified by: `addLayoutComponent` in interface `LayoutManager` Parameters: `name` - ignored `child` - ignored

### method:removeLayoutComponent(java.awt.Component) [NONE]
- #### removeLayoutComponent
      public void removeLayoutComponent(Component child)
This `LayoutManager` method does nothing. There isn't any per-child state. Specified by: `removeLayoutComponent` in interface `LayoutManager` Parameters: `child` - ignored

### method:preferredLayoutSize(java.awt.Container) [NONE]
- #### preferredLayoutSize
      public Dimension preferredLayoutSize(Container parent)
Returns the preferred size of first (and only) child plus the size of the parents insets. Specified by: `preferredLayoutSize` in interface `LayoutManager` Parameters: `parent` - the Container that's managing the layout Returns: the preferred dimensions to lay out the subcomponents of the specified container. See Also: `LayoutManager.minimumLayoutSize(java.awt.Container)`

### method:minimumLayoutSize(java.awt.Container) [NONE]
- #### minimumLayoutSize
      public Dimension minimumLayoutSize(Container parent)
Returns the minimum size of first (and only) child plus the size of the parents insets. Specified by: `minimumLayoutSize` in interface `LayoutManager` Parameters: `parent` - the Container that's managing the layout Returns: the minimum dimensions needed to lay out the subcomponents of the specified container. See Also: `LayoutManager.preferredLayoutSize(java.awt.Container)`

### method:layoutContainer(java.awt.Container) [NONE]
- #### layoutContainer
      public void layoutContainer(Container parent)
Resize the one (and only) child to completely fill the area within the parents insets. Specified by: `layoutContainer` in interface `LayoutManager` Parameters: `parent` - the container to be laid out

### method:commitEdit() [NONE]
- #### commitEdit
      public void commitEdit()
                      throws ParseException
Pushes the currently edited value to the `SpinnerModel`. The default implementation invokes `commitEdit` on the `JFormattedTextField`. Throws: `ParseException` - if the edited value is not legal

### method:getBaseline(int, int) [NONE]
- #### getBaseline
      public int getBaseline(int width,
                             int height)
Returns the baseline. Overrides: `getBaseline` in class `JComponent` Parameters: `width` - the width to get the baseline for `height` - the height to get the baseline for Returns: the baseline or < 0 indicating there is no reasonable baseline Throws: `IllegalArgumentException` - if width or height is < 0 Since: 1.6 See Also: `JComponent.getBaseline(int,int)`, `JComponent.getBaselineResizeBehavior()`

### method:getBaselineResizeBehavior() [NONE]
- #### getBaselineResizeBehavior
      public Component.BaselineResizeBehavior getBaselineResizeBehavior()
Returns an enum indicating how the baseline of the component changes as the size changes. Overrides: `getBaselineResizeBehavior` in class `JComponent` Returns: an enum indicating how the baseline changes as the component size changes Throws: `NullPointerException` Since: 1.6 See Also: `JComponent.getBaseline(int, int)`