public NumericPlainDocument() 
{
        setFormat(null);
}

constructor

 public NumericPlainDocument(DecimalFormat format) 
{
        setFormat(format);
}

constructor

 public NumericPlainDocument(AbstractDocument.Content content,
    DecimalFormat format) 
{
        super(content);
        setFormat(format);
        try {
            format.parseObject(content.getString(0, content.length()), parsePos);
        } catch (Exception e) {
            throw new IllegalArgumentException("Initial content not a valid number");
        }
        if (parsePos.getIndex() != content.length() - 1) {
            throw new IllegalArgumentException(
            "Initial content not a valid number");
        }
}

constructor

Parameters:

content -

format -

 public  void addInsertErrorListener(NumericPlainDocument.InsertErrorListener l) 
{
        if (errorListener == null) {
            errorListener = l;
            return;
        }
        throw new IllegalArgumentException("InsertErrorListener already registered");
}

addInsertErrorListener

 public Double getDoubleValue() throws ParseException 
{
        Number result = getNumberValue();
        if ((result instanceof Long) == false &&
        (result instanceof Double) == false) {
            throw new ParseException("Not a valid double", 0);
        }
        if (result instanceof Long) {
            result = new Double(result.doubleValue());
        }
        return (Double)result;
}

getDoubleValue

 public DecimalFormat getFormat() 
{
        return format;
}

getFormat

 public Long getLongValue() throws ParseException 
{
        Number result = getNumberValue();
        if ((result instanceof Long) == false) {
            throw new ParseException("Not a valid long", 0);
        }
        return (Long)result;
}

getLongValue

 public Number getNumberValue() throws ParseException 
{
        try {
            String content = getText(0, getLength());
            parsePos.setIndex(0);
            Number result = format.parse(content, parsePos);
            if (parsePos.getIndex() != getLength()) {
                throw new ParseException(
                "Not a valid number: " + content, 0);
            }
            return result;
        } catch (BadLocationException e) {
            throw new ParseException("Not a valid number", 0);
        }
}

getNumberValue

 public  void insertString(int offset,
    String str,
    AttributeSet a) throws BadLocationException 
{
        if (str == null || str.length() == 0) {
            return;
        }
        Content content = getContent();
        int length = content.length();
        int originalLength = length;
        parsePos.setIndex(0);
        // Create the result of inserting the new data,
        // but ignore the trailing newline
        String targetString = content.getString(0, offset) + str +
        content.getString(offset, length - offset - 1);
        // Parse the input string and check for errors
        do {
            boolean gotPositive = targetString.startsWith(positivePrefix);
            boolean gotNegative = targetString.startsWith(negativePrefix);
            length = targetString.length();
            // If we have a valid prefix, the parse fails if the
            // suffix is not present and the error is reported
            // at index 0. So, we need to add the appropriate
            // suffix if it is not present at this point.
            if (gotPositive == true || gotNegative == true) {
                String suffix;
                int suffixLength;
                int prefixLength;
                if (gotPositive == true && gotNegative == true) {
                    // This happens if one is the leading part of
                    // the other - e.g. if one is "(" and the other "(("
                    if (positivePrefixLen  > negativePrefixLen) {
                        gotNegative = false;
                    } else {
                        gotPositive = false;
                    }
                }
                if (gotPositive == true) {
                    suffix = positiveSuffix;
                    suffixLength = positiveSuffixLen;
                    prefixLength = positivePrefixLen;
                } else {
                    // Must have the negative prefix
                    suffix = negativeSuffix;
                    suffixLength = negativeSuffixLen;
                    prefixLength = negativePrefixLen;
                }
                // If the string consists of the prefix alone,
                // do nothing, or the result won't parse.
                if (length == prefixLength) {
                    break;
                }
                // We can't just add the suffix, because part of it
                // may already be there. For example, suppose the
                // negative prefix is "(" and the negative suffix is
                // "$)". If the user has typed "(345$", then it is not
                // correct to add "$)". Instead, only the missing part
                // should be added, in this case ")".
                if (targetString.endsWith(suffix) == false) {
                    int i;
                    for (i = suffixLength - 1; i  > 0 ; i--) {
                        if (targetString.regionMatches(length - i,
                        suffix, 0, i)) {
                            targetString += suffix.substring(i);
                            break;
                        }
                    }
                    if (i == 0) {
                        // None of the suffix was present
                        targetString += suffix;
                    }
                    length = targetString.length();
                }
            }
            format.parse(targetString, parsePos);
            int endIndex = parsePos.getIndex();
            if (endIndex == length) {
                break;		// Number is acceptable
            }
            // Parse ended early
            // Since incomplete numbers don't always parse, try
            // to work out what went wrong.
            // First check for an incomplete positive prefix
            if (positivePrefixLen  > 0 &&
            endIndex <  positivePrefixLen &&
            length < = positivePrefixLen &&
            targetString.regionMatches(0, positivePrefix, 0, length)) {
                break;		// Accept for now
            }
            // Next check for an incomplete negative prefix
            if (negativePrefixLen  > 0 &&
            endIndex <  negativePrefixLen &&
            length < = negativePrefixLen &&
            targetString.regionMatches(0, negativePrefix, 0, length)) {
                break;		// Accept for now
            }
            // Allow a number that ends with the group
            // or decimal separator, if these are in use
            char lastChar = targetString.charAt(originalLength - 1);
            int decimalIndex = targetString.indexOf(decimalSeparator);
            if (format.isGroupingUsed() &&
            lastChar == groupingSeparator &&
            decimalIndex == -1) {
                // Allow a "," but only in integer part
                break;
            }
            if(format.isParseIntegerOnly() == false &&
            lastChar == decimalSeparator &&
            decimalIndex == originalLength - 1) {
                // Allow a ".", but only one
                break;
            }
            // No more corrections to make: must be an error
            if (errorListener != null) {
                errorListener.insertFailed(this, offset, str, a);
            }
            return;
        } while (true == false);
        // Finally, add to the model
        super.insertString(offset, str, a);
}

insertString

 public  void removeInsertErrorListener(NumericPlainDocument.InsertErrorListener l) 
{
        if (errorListener == l) {
            errorListener = null;
        }
}

removeInsertErrorListener

 public  void setFormat(DecimalFormat fmt) 
{
        this.format = fmt != null ? fmt :
            (DecimalFormat)defaultFormat.clone();
            decimalSeparator =
            format.getDecimalFormatSymbols().getDecimalSeparator();
            groupingSeparator =
            format.getDecimalFormatSymbols().getGroupingSeparator();
            positivePrefix = format.getPositivePrefix();
            positivePrefixLen = positivePrefix.length();
            negativePrefix = format.getNegativePrefix();
            negativePrefixLen = negativePrefix.length();
            positiveSuffix = format.getPositiveSuffix();
            positiveSuffixLen = positiveSuffix.length();
            negativeSuffix = format.getNegativeSuffix();
            negativeSuffixLen = negativeSuffix.length();
}

setFormat