JTable Edit and Validation

TableFTFEditDemo found in Sun's tutorial shows how to validate cell
editing in a JTable. This example uses Integer as the data type.

However in my case I need something similar but it is not Integer data
type, it is custom format that can be either numeric or hyphen
character only. In this case how to go about incorporating the
functionality to validate?

I have subclassed the DefaultFormatter as shown below:

package test.validation;

import java.text.ParseException;

import javax.swing.text.DefaultFormatter;

public class CheckNumberFormatter extends DefaultFormatter {
    private static final long serialVersionUID = 4023521971680137972L;

    private String enteredValue;

    public CheckNumberFormatter() {
    }

    public CheckNumberFormatter(String enteredValue) {
        this.enteredValue = enteredValue;
    }

    public void setEnteredValue(String enteredValue) {
      this.enteredValue = enteredValue;
    }

    public Object stringToValue(String text) throws ParseException {

        if (enteredValue != null) {
            if(FormatUtil.isNumericOrHyphen(enteredValue)) {
                return super.stringToValue(enteredValue);
            } else {
                throw new ParseException("Format is invalid. Must
contain numeric or hyphen only.", 0);
            }
        }
        return text;
    }
}

However the following line from the example:
table.setDefaultEditor(Integer.class, new IntegerEditor());

has to be replaced with something like:
table.setDefaultEditor(String.class, new CheckNumberEditor());

where the CheckNumberEditor is shown below:

package test.validation;

import java.awt.Component;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;

import javax.swing.AbstractAction;
import javax.swing.DefaultCellEditor;
import javax.swing.JFormattedTextField;
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.KeyStroke;
import javax.swing.SwingUtilities;
import javax.swing.text.DefaultFormatterFactory;

/**
 * Implements a cell editor that uses a formatted text field
 * to edit Numeric and hyphen values.
 */
public class CheckNumberEditor extends DefaultCellEditor {
    private static final long serialVersionUID = 6191759433903247429L;

    private JFormattedTextField ftf;

    public CheckNumberEditor() {
        super(new JFormattedTextField());
        ftf = (JFormattedTextField)getComponent();

        //Set up the editor for the check number cells.

        CheckNumberFormatter formatter = new CheckNumberFormatter();

        ftf.setFormatterFactory(
                new DefaultFormatterFactory(formatter));
        ftf.setHorizontalAlignment(JTextField.TRAILING);
        ftf.setFocusLostBehavior(JFormattedTextField.PERSIST);

        //React when the user presses Enter while the editor is
        //active. (Tab is handled as specified by
        //JFormattedTextField's focusLostBehavior property.)
        ftf.getInputMap().put(KeyStroke.getKeyStroke(
                                        KeyEvent.VK_ENTER, 0),
                                        "check");
        ftf.getActionMap().put("check", new AbstractAction() {
            public void actionPerformed(ActionEvent e) {
        if (!ftf.isEditValid()) { //The text is invalid.
                    if (userSaysRevert()) { //reverted
                ftf.postActionEvent(); //inform the editor
            }
                } else try { //The text is valid,
                    ftf.commitEdit(); //so use it.
                    ftf.postActionEvent(); //stop editing
                } catch (java.text.ParseException exc) { }
            }
        });
    }

    //Override to invoke setValue on the formatted text field.
    public Component getTableCellEditorComponent(JTable table,
            Object value, boolean isSelected,
            int row, int column) {
        JFormattedTextField ftf =
            (JFormattedTextField)super.getTableCellEditorComponent(
                table, value, isSelected, row, column);
        ftf.setValue(value);
        return ftf;
    }

    //Override to ensure that the value remains an Integer.
    public Object getCellEditorValue() {
        JFormattedTextField ftf = (JFormattedTextField)getComponent();
        Object o = ftf.getValue();

        if (FormatUtil.isNumericOrHyphen((String)o)) {
         return (String)o;
        } else
        {
             return null;
        }
    }

    //Override to check whether the edit is valid,
    //setting the value if it is and complaining if
    //it isn't. If it's OK for the editor to go
    //away, we need to invoke the superclass's version
    //of this method so that everything gets cleaned up.
    public boolean stopCellEditing() {
        JFormattedTextField ftf = (JFormattedTextField)getComponent();
        if (ftf.isEditValid()) {
            try {
                ftf.commitEdit();
            } catch (java.text.ParseException exc) { }

        } else { //text is invalid
            if (!userSaysRevert()) { //user wants to edit
            return false; //don't let the editor go away
        }
        }
        return super.stopCellEditing();
    }

    /**
     * Lets the user know that the text they entered is
     * bad. Returns true if the user elects to revert to
     * the last good value. Otherwise, returns false,
     * indicating that the user wants to continue editing.
     */
    protected boolean userSaysRevert() {
        Toolkit.getDefaultToolkit().beep();
        ftf.selectAll();
        Object[] options = {"Edit",
                            "Revert"};
        int answer = JOptionPane.showOptionDialog(
            SwingUtilities.getWindowAncestor(ftf),
            "The value must be an integer between "
            + " and "
            + ".\n"
            + "You can either continue editing "
            + "or revert to the last valid value.",
            "Invalid Text Entered",
            JOptionPane.YES_NO_OPTION,
            JOptionPane.ERROR_MESSAGE,
            null,
            options,
            options[1]);

        if (answer == 1) { //Revert!
            ftf.setValue(ftf.getValue());
        return true;
        }
    return false;
    }
}

The problem is checking the entered text. Is there anything that is
missing? Thanks in advance.

BP
http://www.ProblemSolvingSkill.net