How can i limit the user to enter only A to Z and space in JFormattedText

Question

dear
i want to use JFormatedTextField in two manners
1.Limit the no of charecters.means in a text field only 20 charecters r allowed.
2.and also check the enterd charecter must be a to z and space not other chareters r allowed.
3.same for numbers means 0 to 9 and decimal.
how can i do by using the JFormated TextFilef.

Answer 1

Probably lacks in some cases but what the hell.
* Filename:           JSMaskedTextField.java
* Creation date:      22-mei-2004
* Author:                Kevin Pors
package jsupport.swingext;
import java.awt.event.KeyEvent;
import java.util.Arrays;
import javax.swing.JTextField;
* A masked textfield is a textfield which allows only a specific mask of
* characters to be typed. If characters typed do not occur in the mask
* provided, the typed character will not be 'written' at all. The default mask
* for this <code>JSMaskedTextField</code> is <code>MASK_ALPHA_NUMERIC</code>
* @author Kevin Pors
* @version 1.32
public class JSMaskedTextField extends JTextField {
    /** Masking for alphabetical lowercase characters only. */
    public static final String MASK_ALPHA_LCASE = "abcdefghijklmnopqrstuvwxyz ";
    /** Masking for alpha-numeric characters (lcase/ucase) only. */
    public static final String MASK_ALPHA_NUMERIC = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ";
    /** Masking for alphabetical uppercase characters only. */
    public static final String MASK_ALPHA_UCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ ";
    /** Masking for numbers only. */
    public static final String MASK_NUMERIC = "0123456789";
    /** Masking for hexadecimals. */
    public static final String MASK_HEXADECIMAL = "0123456789ABCDEF";
     * An array of keyevent constants defining which keys are always to be
     * allowed, no matter what.
    private final int[] ALWAYS_ALLOWED = new int[] { KeyEvent.VK_BACK_SPACE,
            KeyEvent.VK_DELETE, KeyEvent.VK_UP, KeyEvent.VK_DOWN,
            KeyEvent.VK_LEFT, KeyEvent.VK_RIGHT, KeyEvent.VK_SHIFT,
            KeyEvent.VK_HOME, KeyEvent.VK_END};
    /** Boolean specifying whether casing should be ignored. */
    private boolean ignoringCase = true;
    /** Specifying whether the maskin is enabled */
    private boolean isMaskingEnabled = true;
    /** The mask for the textfield. */
    private String mask = MASK_ALPHA_NUMERIC;
     * Creates a default number field.
    public JSMaskedTextField() {
        super(null, null, 0);
        Arrays.sort(ALWAYS_ALLOWED);
     * Creates a number field, with a specified number of columns.
     * @param columns The columnnumber.
    public JSMaskedTextField(int columns) {
        super(null, null, columns);
        Arrays.sort(ALWAYS_ALLOWED);
     * Creates a JSMaskedTextField with a masking.
     * @param mask The masking to be used.
    public JSMaskedTextField(String mask) {
        super(null, null, 0);
        Arrays.sort(ALWAYS_ALLOWED);
        setMask(mask);
     * Gets the masking for this masked textfield.
     * @return Returns the mask.
    public String getMask() {
        return this.mask;
     * Gets whether this JSMaskedTextField should be ignoring casing.
     * @return Returns if the component should be ignoring casing.
    public boolean isIgnoringCase() {
        return this.ignoringCase;
     * Checks whether masking is enabled. Default should be true.
     * @return Returns true if masking is enabled, false if not.
    public boolean isMaskingEnabled() {
        return this.isMaskingEnabled;
     * Sets whether it should be ignoring casing when checking for alpha-chars.
     * @param ignoringCase The ignoringCase to set.
    public void setIgnoringCase(boolean ignoringCase) {
        this.ignoringCase = ignoringCase;
     * Sets the masking for this textfield. The masking will determine which
     * characters can be typed. If the characters in de <code>mask</code> do
     * not occur in the typed character, it won't be typed.
     * @param mask The mask to set.
    public void setMask(String mask) {
        this.mask = mask;
     * Sets the masking enabled. If <code>false</code> this component will
     * behave just like a normal textfield.
     * @param isMaskingEnabled true if masking should be enabled.
    public void setMaskingEnabled(boolean isMaskingEnabled) {
        this.isMaskingEnabled = isMaskingEnabled;
     * Sets text of this textfield. If the blah blah.
     * @see javax.swing.text.JTextComponent#setText(java.lang.String)
    public void setText(String text) {
        for (int i = 0; i < text.length(); i++) {
            if (getMask().indexOf(text.charAt(i)) < 0) { // does not occur
                return;
        super.setText(text);
     * @see javax.swing.JComponent#processKeyEvent(java.awt.event.KeyEvent)
    protected void processKeyEvent(KeyEvent e) {
        if (!isMaskingEnabled()) {
            return;
        char typed = e.getKeyChar();
        int code = e.getKeyCode();
        for (int i = 0; i < ALWAYS_ALLOWED.length; i++) {
            if (ALWAYS_ALLOWED[i] == code) {
                super.processKeyEvent(e);
                return;
        if (typed == KeyEvent.VK_BACK_SPACE) {
            super.processKeyEvent(e);
        if (isIgnoringCase()) {
            String tString = new String(typed + "");
            String ucase = tString.toUpperCase();
            String lcase = tString.toLowerCase();
            if (getMask().indexOf(ucase) < 0 || getMask().indexOf(lcase) < 0) {
                e.consume();
            } else {
                super.processKeyEvent(e);
                return;
        } else { // not ignoring casing
            if (getMask().indexOf(typed) < 0) {
                e.consume();
            } else {
                super.processKeyEvent(e);
}