An AbstractFormatter can only be active in one JFormattedTextField at a time. JFormattedTextField invokes install when it is ready to use it followed by uninstall when done. Subclasses that wish to install additional state should override install and message super appropriately.

Subclasses must override the conversion methods stringToValue and valueToString. Optionally they can override getActions, getNavigationFilter and getDocumentFilter to restrict the JFormattedTextField in a particular way.

Subclasses that allow the JFormattedTextField to be in a temporarily invalid state should invoke setEditValid at the appropriate times. 

Also see:

setFocusLostBehavior

Also see:

setFocusLostBehavior

Also see:

setFocusLostBehavior

Also see:

setFocusLostBehavior

 public JFormattedTextField() 
{
        super();
        enableEvents(AWTEvent.FOCUS_EVENT_MASK);
        setFocusLostBehavior(COMMIT_OR_REVERT);
}

Creates a JFormattedTextField with no AbstractFormatterFactory. Use setMask or setFormatterFactory to configure the JFormattedTextField to edit a particular type of value.

 public JFormattedTextField(Object value) 
{
        this();
        setValue(value);
}

Creates a JFormattedTextField with the specified value. This will create an AbstractFormatterFactory based on the type of value.

Parameters:

value - Initial value for the JFormattedTextField

 public JFormattedTextField(Format format) 
{
        this();
        setFormatterFactory(getDefaultFormatterFactory(format));
}

Creates a JFormattedTextField. format is wrapped in an appropriate AbstractFormatter which is then wrapped in an AbstractFormatterFactory.

Parameters:

format - Format used to look up an AbstractFormatter

 public JFormattedTextField(AbstractFormatter formatter) 
{
        this(new DefaultFormatterFactory(formatter));
}

Creates a JFormattedTextField with the specified AbstractFormatter. The AbstractFormatter is placed in an AbstractFormatterFactory.

Parameters:

formatter - AbstractFormatter to use for formatting.

 public JFormattedTextField(AbstractFormatterFactory factory) 
{
        this();
        setFormatterFactory(factory);
}

Creates a JFormattedTextField with the specified AbstractFormatterFactory.

Parameters:

factory - AbstractFormatterFactory used for formatting.

 public JFormattedTextField(AbstractFormatterFactory factory,
    Object currentValue) 
{
        this(currentValue);
        setFormatterFactory(factory);
}

Creates a JFormattedTextField with the specified AbstractFormatterFactory and initial value.

Parameters:

factory - AbstractFormatterFactory used for formatting.

currentValue - Initial value to use

 public  void commitEdit() throws ParseException 
{
        AbstractFormatter format = getFormatter();
        if (format != null) {
            setValue(format.stringToValue(getText()), false, true);
        }
}

Forces the current value to be taken from the AbstractFormatter and set as the current value. This has no effect if there is no current AbstractFormatter installed.

 public Action[] getActions() 
{
        return TextAction.augmentList(super.getActions(), defaultActions);
}

Fetches the command list for the editor. This is the list of commands supported by the plugged-in UI augmented by the collection of commands that the editor itself supports. These are useful for binding to events, such as in a keymap.

 public int getFocusLostBehavior() 
{
        return focusLostBehavior;
}

Returns the behavior when focus is lost. This will be one of COMMIT_OR_REVERT, COMMIT, REVERT or PERSIST Note that some AbstractFormatters may push changes as they occur, so that the value of this will have no effect.

 public AbstractFormatter getFormatter() 
{
        return format;
}

Returns the AbstractFormatter that is used to format and parse the current value.

 public AbstractFormatterFactory getFormatterFactory() 
{
        return factory;
}

Returns the current AbstractFormatterFactory.

 public String getUIClassID() 
{
        return uiClassID;
}

Gets the class ID for a UI.

 public Object getValue() 
{
        return value;
}

Returns the last valid value. Based on the editing policy of the AbstractFormatter this may not return the current value. The currently edited value can be obtained by invoking commitEdit followed by getValue.

 protected  void invalidEdit() 
{
        UIManager.getLookAndFeel().provideErrorFeedback(JFormattedTextField.this);
}

Invoked when the user inputs an invalid value. This gives the component a chance to provide feedback. The default implementation beeps.

 public boolean isEditValid() 
{
        return editValid;
}

Returns true if the current value being edited is valid. The value of this is managed by the current AbstractFormatter, as such there is no public setter for it.

 protected  void processFocusEvent(FocusEvent e) 
{
        super.processFocusEvent(e);
        // ignore temporary focus event
        if (e.isTemporary()) {
            return;
        }
        if (isEdited() && e.getID() == FocusEvent.FOCUS_LOST) {
            InputContext ic = getInputContext();
            if (focusLostHandler == null) {
                focusLostHandler = new FocusLostHandler();
            }
            // if there is a composed text, process it first
            if ((ic != null) && composedTextExists) {
                ic.endComposition();
                EventQueue.invokeLater(focusLostHandler);
            } else {
                focusLostHandler.run();
            }
        }
        else if (!isEdited()) {
            // reformat
            setValue(getValue(), true, true);
        }
}

Processes any focus events, such as FocusEvent.FOCUS_GAINED or FocusEvent.FOCUS_LOST.

 protected  void processInputMethodEvent(InputMethodEvent e) 
{
        AttributedCharacterIterator text = e.getText();
        int commitCount = e.getCommittedCharacterCount();
        // Keep track of the composed text
        if (text != null) {
            int begin = text.getBeginIndex();
            int end = text.getEndIndex();
            composedTextExists = ((end - begin)  > commitCount);
        } else {
            composedTextExists = false;
        }
        super.processInputMethodEvent(e);
}

Processes any input method events, such as InputMethodEvent.INPUT_METHOD_TEXT_CHANGED or InputMethodEvent.CARET_POSITION_CHANGED.

 public  void setDocument(Document doc) 
{
        if (documentListener != null && getDocument() != null) {
            getDocument().removeDocumentListener(documentListener);
        }
        super.setDocument(doc);
        if (documentListener == null) {
            documentListener = new DocumentHandler();
        }
        doc.addDocumentListener(documentListener);
}

Associates the editor with a text document. The currently registered factory is used to build a view for the document, which gets displayed by the editor after revalidation. A PropertyChange event ("document") is propagated to each listener.

 public  void setFocusLostBehavior(int behavior) 
{
        if (behavior != COMMIT && behavior != COMMIT_OR_REVERT &&
            behavior != PERSIST && behavior != REVERT) {
            throw new IllegalArgumentException("setFocusLostBehavior must be one of: JFormattedTextField.COMMIT, JFormattedTextField.COMMIT_OR_REVERT, JFormattedTextField.PERSIST or JFormattedTextField.REVERT");
        }
        focusLostBehavior = behavior;
}

Sets the behavior when focus is lost. This will be one of JFormattedTextField.COMMIT_OR_REVERT, JFormattedTextField.REVERT, JFormattedTextField.COMMIT or JFormattedTextField.PERSIST Note that some AbstractFormatters may push changes as they occur, so that the value of this will have no effect.

This will throw an IllegalArgumentException if the object passed in is not one of the afore mentioned values.

The default value of this property is JFormattedTextField.COMMIT_OR_REVERT.

 protected  void setFormatter(AbstractFormatter format) 
{
        AbstractFormatter oldFormat = this.format;
        if (oldFormat != null) {
            oldFormat.uninstall();
        }
        setEditValid(true);
        this.format = format;
        if (format != null) {
            format.install(this);
        }
        setEdited(false);
        firePropertyChange("textFormatter", oldFormat, format);
}

Sets the current AbstractFormatter.

You should not normally invoke this, instead set the AbstractFormatterFactory or set the value. JFormattedTextField will invoke this as the state of the JFormattedTextField changes and requires the value to be reset. JFormattedTextField passes in the AbstractFormatter obtained from the AbstractFormatterFactory.

This is a JavaBeans bound property.

 public  void setFormatterFactory(AbstractFormatterFactory tf) 
{
        AbstractFormatterFactory oldFactory = factory;
        factory = tf;
        firePropertyChange("formatterFactory", oldFactory, tf);
        setValue(getValue(), true, false);
}

Sets the AbstractFormatterFactory. AbstractFormatterFactory is able to return an instance of AbstractFormatter that is used to format a value for display, as well an enforcing an editing policy.

If you have not explicitly set an AbstractFormatterFactory by way of this method (or a constructor) an AbstractFormatterFactory and consequently an AbstractFormatter will be used based on the Class of the value. NumberFormatter will be used for Numbers, DateFormatter will be used for Dates, otherwise DefaultFormatter will be used.

This is a JavaBeans bound property.

 public  void setValue(Object value) 
{
        if (value != null && getFormatterFactory() == null) {
            setFormatterFactory(getDefaultFormatterFactory(value));
        }
        setValue(value, true, true);
}

Sets the value that will be formatted by an AbstractFormatter obtained from the current AbstractFormatterFactory. If no AbstractFormatterFactory has been specified, this will attempt to create one based on the type of value.

The default value of this property is null.

This is a JavaBeans bound property.