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. 

 public JSpinner() 
{
        this(new SpinnerNumberModel());
}

Constructs a spinner with an Integer SpinnerNumberModel with initial value 0 and no minimum or maximum limits.

 public JSpinner(SpinnerModel model) 
{
                                       
        if (model == null) {
            throw new NullPointerException("model cannot be null");
        }
        this.model = model;
        this.editor = createEditor(model);
        setOpaque(true);
        updateUI();
}

Constructs a spinner for the given model. The spinner has a set of previous/next buttons, and an editor appropriate for the model.

Throws:

NullPointerException - if the model is {@code null}

 public  void addChangeListener(ChangeListener listener) 
{
        if (modelListener == null) {
            modelListener = new ModelListener();
            getModel().addChangeListener(modelListener);
        }
        listenerList.add(ChangeListener.class, listener);
}

Adds a listener to the list that is notified each time a change to the model occurs. The source of ChangeEvents delivered to ChangeListeners will be this JSpinner. Note also that replacing the model will not affect listeners added directly to JSpinner. Applications can add listeners to the model directly. In that case is that the source of the event would be the SpinnerModel.

 public  void commitEdit() throws ParseException 
{
        JComponent editor = getEditor();
        if (editor instanceof DefaultEditor) {
            ((DefaultEditor)editor).commitEdit();
        }
}

Commits the currently edited value to the SpinnerModel.

If the editor is an instance of DefaultEditor, the call if forwarded to the editor, otherwise this does nothing.

 protected JComponent createEditor(SpinnerModel model) 
{
        if (model instanceof SpinnerDateModel) {
            return new DateEditor(this);
        }
        else if (model instanceof SpinnerListModel) {
            return new ListEditor(this);
        }
        else if (model instanceof SpinnerNumberModel) {
            return new NumberEditor(this);
        }
        else {
            return new DefaultEditor(this);
        }
}

This method is called by the constructors to create the JComponent that displays the current value of the sequence. The editor may also allow the user to enter an element of the sequence directly. An editor must listen for ChangeEvents on the model and keep the value it displays in sync with the value of the model.

Subclasses may override this method to add support for new SpinnerModel classes. Alternatively one can just replace the editor created here with the setEditor method. The default mapping from model type to editor is:

• SpinnerNumberModel => JSpinner.NumberEditor
• SpinnerDateModel => JSpinner.DateEditor
• SpinnerListModel => JSpinner.ListEditor
• all others => JSpinner.DefaultEditor

 protected  void fireStateChanged() 
{
        Object[] listeners = listenerList.getListenerList();
        for (int i = listeners.length - 2; i  >= 0; i -= 2) {
            if (listeners[i] == ChangeListener.class) {
                if (changeEvent == null) {
                    changeEvent = new ChangeEvent(this);
                }
                ((ChangeListener)listeners[i+1]).stateChanged(changeEvent);
            }
        }
}

Sends a ChangeEvent, whose source is this JSpinner, to each ChangeListener. When a ChangeListener has been added to the spinner, this method method is called each time a ChangeEvent is received from the model.

 public AccessibleContext getAccessibleContext() 
{
        if (accessibleContext == null) {
            accessibleContext = new AccessibleJSpinner();
        }
        return accessibleContext;
}

Gets the AccessibleContext for the JSpinner

 public ChangeListener[] getChangeListeners() 
{
        return (ChangeListener[])listenerList.getListeners(
                ChangeListener.class);
}

Returns an array of all the ChangeListeners added to this JSpinner with addChangeListener().

 public JComponent getEditor() 
{
        return editor;
}

Returns the component that displays and potentially changes the model's value.

 public SpinnerModel getModel() 
{
        return model;
}

Returns the SpinnerModel that defines this spinners sequence of values.

 public Object getNextValue() 
{
        return getModel().getNextValue();
}

Returns the object in the sequence that comes after the object returned by getValue(). If the end of the sequence has been reached then return null. Calling this method does not effect value.

This method simply delegates to the model. It is equivalent to:

getModel().getNextValue()

 public Object getPreviousValue() 
{
        return getModel().getPreviousValue();
}

Returns the object in the sequence that comes before the object returned by getValue(). If the end of the sequence has been reached then return null. Calling this method does not effect value.

This method simply delegates to the model. It is equivalent to:

getModel().getPreviousValue()

 public SpinnerUI getUI() 
{
        return (SpinnerUI)ui;
}

Returns the look and feel (L&F) object that renders this component.

 public String getUIClassID() 
{
        return uiClassID;
}

Returns the suffix used to construct the name of the look and feel (L&F) class used to render this component.

 public Object getValue() 
{
        return getModel().getValue();
}

Returns the current value of the model, typically this value is displayed by the editor. If the user has changed the value displayed by the editor it is possible for the model's value to differ from that of the editor, refer to the class level javadoc for examples of how to deal with this.

This method simply delegates to the model. It is equivalent to:

getModel().getValue()

 public  void removeChangeListener(ChangeListener listener) 
{
        listenerList.remove(ChangeListener.class, listener);
}

Removes a ChangeListener from this spinner.

 public  void setEditor(JComponent editor) 
{
        if (editor == null) {
            throw new IllegalArgumentException("null editor");
        }
        if (!editor.equals(this.editor)) {
            JComponent oldEditor = this.editor;
            this.editor = editor;
            if (oldEditor instanceof DefaultEditor) {
                ((DefaultEditor)oldEditor).dismiss(this);
            }
            editorExplicitlySet = true;
            firePropertyChange("editor", oldEditor, editor);
            revalidate();
            repaint();
        }
}

Changes the JComponent that displays the current value of the SpinnerModel. It is the responsibility of this method to disconnect the old editor from the model and to connect the new editor. This may mean removing the old editors ChangeListener from the model or the spinner itself and adding one for the new editor.

 public  void setModel(SpinnerModel model) 
{
        if (model == null) {
            throw new IllegalArgumentException("null model");
        }
        if (!model.equals(this.model)) {
            SpinnerModel oldModel = this.model;
            this.model = model;
            if (modelListener != null) {
                oldModel.removeChangeListener(modelListener);
                this.model.addChangeListener(modelListener);
            }
            firePropertyChange("model", oldModel, model);
            if (!editorExplicitlySet) {
                setEditor(createEditor(model)); // sets editorExplicitlySet true
                editorExplicitlySet = false;
            }
            repaint();
            revalidate();
        }
}

Changes the model that represents the value of this spinner. If the editor property has not been explicitly set, the editor property is (implicitly) set after the "model" PropertyChangeEvent has been fired. The editor property is set to the value returned by createEditor, as in:

setEditor(createEditor(model));

 public  void setUI(SpinnerUI ui) 
{
        super.setUI(ui);
}

Sets the look and feel (L&F) object that renders this component.

 public  void setValue(Object value) 
{
        getModel().setValue(value);
}

Changes current value of the model, typically this value is displayed by the editor. If the SpinnerModel implementation doesn't support the specified value then an IllegalArgumentException is thrown.

This method simply delegates to the model. It is equivalent to:

getModel().setValue(value)

 public  void updateUI() 
{
        setUI((SpinnerUI)UIManager.getUI(this));
        invalidate();
}

Resets the UI property with the value from the current look and feel.