< prev index next >
src/java.desktop/share/classes/javax/swing/text/InternationalFormatter.java
Print this page
@@ -30,74 +30,74 @@
import java.text.AttributedCharacterIterator.Attribute;
import java.util.*;
import javax.swing.*;
/**
- * <code>InternationalFormatter</code> extends <code>DefaultFormatter</code>,
- * using an instance of <code>java.text.Format</code> to handle the
+ * {@code InternationalFormatter} extends {@code DefaultFormatter},
+ * using an instance of {@code java.text.Format} to handle the
* conversion to a String, and the conversion from a String.
* <p>
- * If <code>getAllowsInvalid()</code> is false, this will ask the
- * <code>Format</code> to format the current text on every edit.
+ * If {@code getAllowsInvalid()} is false, this will ask the
+ * {@code Format} to format the current text on every edit.
* <p>
* You can specify a minimum and maximum value by way of the
- * <code>setMinimum</code> and <code>setMaximum</code> methods. In order
- * for this to work the values returned from <code>stringToValue</code> must be
- * comparable to the min/max values by way of the <code>Comparable</code>
+ * {@code setMinimum} and {@code setMaximum} methods. In order
+ * for this to work the values returned from {@code stringToValue} must be
+ * comparable to the min/max values by way of the {@code Comparable}
* interface.
* <p>
- * Be careful how you configure the <code>Format</code> and the
- * <code>InternationalFormatter</code>, as it is possible to create a
+ * Be careful how you configure the {@code Format} and the
+ * {@code InternationalFormatter}, as it is possible to create a
* situation where certain values can not be input. Consider the date
- * format 'M/d/yy', an <code>InternationalFormatter</code> that is always
- * valid (<code>setAllowsInvalid(false)</code>), is in overwrite mode
- * (<code>setOverwriteMode(true)</code>) and the date 7/1/99. In this
+ * format 'M/d/yy', an {@code InternationalFormatter} that is always
+ * valid ({@code setAllowsInvalid(false)}), is in overwrite mode
+ * ({@code setOverwriteMode(true)}) and the date 7/1/99. In this
* case the user will not be able to enter a two digit month or day of
* month. To avoid this, the format should be 'MM/dd/yy'.
* <p>
- * If <code>InternationalFormatter</code> is configured to only allow valid
- * values (<code>setAllowsInvalid(false)</code>), every valid edit will result
- * in the text of the <code>JFormattedTextField</code> being completely reset
- * from the <code>Format</code>.
+ * If {@code InternationalFormatter} is configured to only allow valid
+ * values ({@code setAllowsInvalid(false)}), every valid edit will result
+ * in the text of the {@code JFormattedTextField} being completely reset
+ * from the {@code Format}.
* The cursor position will also be adjusted as literal characters are
* added/removed from the resulting String.
* <p>
- * <code>InternationalFormatter</code>'s behavior of
- * <code>stringToValue</code> is slightly different than that of
- * <code>DefaultTextFormatter</code>, it does the following:
+ * {@code InternationalFormatter}'s behavior of
+ * {@code stringToValue} is slightly different than that of
+ * {@code DefaultTextFormatter}, it does the following:
* <ol>
- * <li><code>parseObject</code> is invoked on the <code>Format</code>
- * specified by <code>setFormat</code>
- * <li>If a Class has been set for the values (<code>setValueClass</code>),
+ * <li>{@code parseObject} is invoked on the {@code Format}
+ * specified by {@code setFormat}
+ * <li>If a Class has been set for the values ({@code setValueClass}),
* supers implementation is invoked to convert the value returned
- * from <code>parseObject</code> to the appropriate class.
- * <li>If a <code>ParseException</code> has not been thrown, and the value
- * is outside the min/max a <code>ParseException</code> is thrown.
+ * from {@code parseObject} to the appropriate class.
+ * <li>If a {@code ParseException} has not been thrown, and the value
+ * is outside the min/max a {@code ParseException} is thrown.
* <li>The value is returned.
* </ol>
- * <code>InternationalFormatter</code> implements <code>stringToValue</code>
+ * {@code InternationalFormatter} implements {@code stringToValue}
* in this manner so that you can specify an alternate Class than
- * <code>Format</code> may return.
+ * {@code Format} may return.
* <p>
* <strong>Warning:</strong>
* Serialized objects of this class will not be compatible with
* future Swing releases. The current serialization support is
* appropriate for short term storage or RMI between applications running
* the same version of Swing. As of 1.4, support for long term storage
* of all JavaBeans™
- * has been added to the <code>java.beans</code> package.
+ * has been added to the {@code java.beans} package.
* Please see {@link java.beans.XMLEncoder}.
*
* @see java.text.Format
* @see java.lang.Comparable
*
* @since 1.4
*/
@SuppressWarnings("serial") // Same-version serialization only
public class InternationalFormatter extends DefaultFormatter {
/**
- * Used by <code>getFields</code>.
+ * Used by {@code getFields}.
*/
private static final Format.Field[] EMPTY_FIELD_ARRAY =new Format.Field[0];
/**
* Object used to handle the conversion.
@@ -111,31 +111,31 @@
* Can be used to impose a minimum value.
*/
private Comparable<?> min;
/**
- * <code>InternationalFormatter</code>'s behavior is dicatated by a
- * <code>AttributedCharacterIterator</code> that is obtained from
- * the <code>Format</code>. On every edit, assuming
- * allows invalid is false, the <code>Format</code> instance is invoked
- * with <code>formatToCharacterIterator</code>. A <code>BitSet</code> is
+ * {@code InternationalFormatter}'s behavior is dicatated by a
+ * {@code AttributedCharacterIterator} that is obtained from
+ * the {@code Format}. On every edit, assuming
+ * allows invalid is false, the {@code Format} instance is invoked
+ * with {@code formatToCharacterIterator}. A {@code BitSet} is
* also kept upto date with the non-literal characters, that is
- * for every index in the <code>AttributedCharacterIterator</code> an
+ * for every index in the {@code AttributedCharacterIterator} an
* entry in the bit set is updated based on the return value from
- * <code>isLiteral(Map)</code>. <code>isLiteral(int)</code> then uses
+ * {@code isLiteral(Map)}. {@code isLiteral(int)} then uses
* this cached information.
* <p>
* If allowsInvalid is false, every edit results in resetting the complete
* text of the JTextComponent.
* <p>
* InternationalFormatterFilter can also provide two actions suitable for
* incrementing and decrementing. To enable this a subclass must
- * override <code>getSupportsIncrement</code> to return true, and
- * override <code>adjustValue</code> to handle the changing of the
+ * override {@code getSupportsIncrement} to return true, and
+ * override {@code adjustValue} to handle the changing of the
* value. If you want to support changing the value outside of
* the valid FieldPositions, you will need to override
- * <code>canIncrement</code>.
+ * {@code canIncrement}.
*/
/**
* A bit is set for every index identified in the
* AttributedCharacterIterator that is not considered decoration.
* This should only be used if validMask is true.
@@ -161,20 +161,20 @@
*/
private transient boolean ignoreDocumentMutate;
/**
- * Creates an <code>InternationalFormatter</code> with no
- * <code>Format</code> specified.
+ * Creates an {@code InternationalFormatter} with no
+ * {@code Format} specified.
*/
public InternationalFormatter() {
setOverwriteMode(false);
}
/**
- * Creates an <code>InternationalFormatter</code> with the specified
- * <code>Format</code> instance.
+ * Creates an {@code InternationalFormatter} with the specified
+ * {@code Format} instance.
*
* @param format Format instance used for converting from/to Strings
*/
public InternationalFormatter(Format format) {
this();
@@ -183,11 +183,11 @@
/**
* Sets the format that dictates the legal values that can be edited
* and displayed.
*
- * @param format <code>Format</code> instance used for converting
+ * @param format {@code Format} instance used for converting
* from/to Strings
*/
public void setFormat(Format format) {
this.format = format;
}
@@ -201,14 +201,14 @@
public Format getFormat() {
return format;
}
/**
- * Sets the minimum permissible value. If the <code>valueClass</code> has
- * not been specified, and <code>minimum</code> is non null, the
- * <code>valueClass</code> will be set to that of the class of
- * <code>minimum</code>.
+ * Sets the minimum permissible value. If the {@code valueClass} has
+ * not been specified, and {@code minimum} is non null, the
+ * {@code valueClass} will be set to that of the class of
+ * {@code minimum}.
*
* @param minimum Minimum legal value that can be input
* @see #setValueClass
*/
public void setMinimum(Comparable<?> minimum) {
@@ -226,14 +226,14 @@
public Comparable<?> getMinimum() {
return min;
}
/**
- * Sets the maximum permissible value. If the <code>valueClass</code> has
- * not been specified, and <code>max</code> is non null, the
- * <code>valueClass</code> will be set to that of the class of
- * <code>max</code>.
+ * Sets the maximum permissible value. If the {@code valueClass} has
+ * not been specified, and {@code max} is non null, the
+ * {@code valueClass} will be set to that of the class of
+ * {@code max}.
*
* @param max Maximum legal value that can be input
* @see #setValueClass
*/
public void setMaximum(Comparable<?> max) {
@@ -251,33 +251,33 @@
public Comparable<?> getMaximum() {
return max;
}
/**
- * Installs the <code>DefaultFormatter</code> onto a particular
- * <code>JFormattedTextField</code>.
- * This will invoke <code>valueToString</code> to convert the
- * current value from the <code>JFormattedTextField</code> to
- * a String. This will then install the <code>Action</code>s from
- * <code>getActions</code>, the <code>DocumentFilter</code>
- * returned from <code>getDocumentFilter</code> and the
- * <code>NavigationFilter</code> returned from
- * <code>getNavigationFilter</code> onto the
- * <code>JFormattedTextField</code>.
+ * Installs the {@code DefaultFormatter} onto a particular
+ * {@code JFormattedTextField}.
+ * This will invoke {@code valueToString} to convert the
+ * current value from the {@code JFormattedTextField} to
+ * a String. This will then install the {@code Action}s from
+ * {@code getActions}, the {@code DocumentFilter}
+ * returned from {@code getDocumentFilter} and the
+ * {@code NavigationFilter} returned from
+ * {@code getNavigationFilter} onto the
+ * {@code JFormattedTextField}.
* <p>
* Subclasses will typically only need to override this if they
* wish to install additional listeners on the
- * <code>JFormattedTextField</code>.
+ * {@code JFormattedTextField}.
* <p>
- * If there is a <code>ParseException</code> in converting the
+ * If there is a {@code ParseException} in converting the
* current value to a String, this will set the text to an empty
- * String, and mark the <code>JFormattedTextField</code> as being
+ * String, and mark the {@code JFormattedTextField} as being
* in an invalid state.
* <p>
* While this is a public method, this is typically only useful
- * for subclassers of <code>JFormattedTextField</code>.
- * <code>JFormattedTextField</code> will invoke this method at
+ * for subclassers of {@code JFormattedTextField}.
+ * {@code JFormattedTextField} will invoke this method at
* the appropriate times when the value changes, or its internal
* state changes.
*
* @param ftf JFormattedTextField to format for, may be null indicating
* uninstall from current JFormattedTextField.
@@ -288,12 +288,12 @@
// invoked again as the mask should now be valid.
positionCursorAtInitialLocation();
}
/**
- * Returns a String representation of the Object <code>value</code>.
- * This invokes <code>format</code> on the current <code>Format</code>.
+ * Returns a String representation of the Object {@code value}.
+ * This invokes {@code format} on the current {@code Format}.
*
* @throws ParseException if there is an error in the conversion
* @param value Value to convert
* @return String representation of value
*/
@@ -308,15 +308,15 @@
}
return f.format(value);
}
/**
- * Returns the <code>Object</code> representation of the
- * <code>String</code> <code>text</code>.
+ * Returns the {@code Object} representation of the
+ * {@code String text}.
*
- * @param text <code>String</code> to convert
- * @return <code>Object</code> representation of text
+ * @param text {@code String} to convert
+ * @return {@code Object} representation of text
* @throws ParseException if there is an error in the conversion
*/
public Object stringToValue(String text) throws ParseException {
Object value = stringToValue(text, getFormat());
@@ -336,12 +336,12 @@
}
return value;
}
/**
- * Returns the <code>Format.Field</code> constants associated with
- * the text at <code>offset</code>. If <code>offset</code> is not
+ * Returns the {@code Format.Field} constants associated with
+ * the text at {@code offset}. If {@code offset} is not
* a valid location into the current text, this will return an
* empty array.
*
* @param offset offset into text to be examined
* @return Format.Field constants associated with the text at the
@@ -379,11 +379,11 @@
formatter.string = null;
return formatter;
}
/**
- * If <code>getSupportsIncrement</code> returns true, this returns
+ * If {@code getSupportsIncrement} returns true, this returns
* two Actions suitable for incrementing/decrementing the value.
*/
protected Action[] getActions() {
if (getSupportsIncrement()) {
return new Action[] { new IncrementAction("increment", 1),
@@ -391,22 +391,22 @@
}
return null;
}
/**
- * Invokes <code>parseObject</code> on <code>f</code>, returning
+ * Invokes {@code parseObject} on {@code f}, returning
* its value.
*/
Object stringToValue(String text, Format f) throws ParseException {
if (f == null) {
return text;
}
return f.parseObject(text);
}
/**
- * Returns true if <code>value</code> is between the min/max.
+ * Returns true if {@code value} is between the min/max.
*
* @param wantsCCE If false, and a ClassCastException is thrown in
* comparing the values, the exception is consumed and
* false is returned.
*/
@@ -439,11 +439,11 @@
}
return true;
}
/**
- * Returns a Set of the attribute identifiers at <code>index</code>.
+ * Returns a Set of the attribute identifiers at {@code index}.
*/
Map<Attribute, Object> getAttributes(int index) {
if (isValidMask()) {
AttributedCharacterIterator iterator = getIterator();
@@ -456,11 +456,11 @@
}
/**
* Returns the start of the first run that contains the attribute
- * <code>id</code>. This will return <code>-1</code> if the attribute
+ * {@code id}. This will return {@code -1} if the attribute
* can not be found.
*/
int getAttributeStart(AttributedCharacterIterator.Attribute id) {
if (isValidMask()) {
AttributedCharacterIterator iterator = getIterator();
@@ -475,11 +475,11 @@
}
return -1;
}
/**
- * Returns the <code>AttributedCharacterIterator</code> used to
+ * Returns the {@code AttributedCharacterIterator} used to
* format the last value.
*/
AttributedCharacterIterator getIterator() {
return iterator;
}
@@ -502,13 +502,13 @@
}
}
/**
* Updates the AttributedCharacterIterator by invoking
- * <code>formatToCharacterIterator</code> on the <code>Format</code>.
+ * {@code formatToCharacterIterator} on the {@code Format}.
* If this is successful,
- * <code>updateMask(AttributedCharacterIterator)</code>
+ * {@code updateMask(AttributedCharacterIterator)}
* is then invoked to update the internal bitmask.
*/
void updateMask() {
if (getFormat() != null) {
Document doc = getFormattedTextField().getDocument();
@@ -535,11 +535,11 @@
}
}
}
/**
- * Returns the number of literal characters before <code>index</code>.
+ * Returns the number of literal characters before {@code index}.
*/
int getLiteralCountTo(int index) {
int lCount = 0;
for (int counter = 0; counter < index; counter++) {
@@ -571,11 +571,11 @@
return (char)0;
}
/**
* Returns true if the character at offset is navigable too. This
- * is implemented in terms of <code>isLiteral</code>, subclasses
+ * is implemented in terms of {@code isLiteral}, subclasses
* may wish to provide different behavior.
*/
boolean isNavigatable(int offset) {
return !isLiteral(offset);
}
@@ -684,11 +684,11 @@
/**
* When in !allowsInvalid mode the text is reset on every edit, thus
* supers implementation will position the cursor at the wrong position.
* As such, this invokes supers implementation and then invokes
- * <code>repositionCursor</code> to correctly reset the cursor.
+ * {@code repositionCursor} to correctly reset the cursor.
*/
boolean replace(ReplaceHolder rh) throws BadLocationException {
int start = -1;
int direction = 1;
int literalCount = -1;
@@ -726,14 +726,14 @@
}
return false;
}
/**
- * Repositions the cursor. <code>startLiteralCount</code> gives
+ * Repositions the cursor. {@code startLiteralCount} gives
* the number of literals to the start of the deleted range, end
* gives the ending location to adjust from, direction gives
- * the direction relative to <code>end</code> to position the
+ * the direction relative to {@code end} to position the
* cursor from.
*/
private void repositionCursor(int startLiteralCount, int end,
int direction) {
int endLiteralCount = getLiteralCountTo(end);
@@ -749,11 +749,11 @@
repositionCursor(end, 1 /*direction*/);
}
/**
* Returns the character from the mask that has been buffered
- * at <code>index</code>.
+ * at {@code index}.
*/
char getBufferedChar(int index) {
if (isValidMask()) {
if (string != null && index < string.length()) {
return string.charAt(index);
@@ -768,19 +768,19 @@
boolean isValidMask() {
return validMask;
}
/**
- * Returns true if <code>attributes</code> is null or empty.
+ * Returns true if {@code attributes} is null or empty.
*/
boolean isLiteral(Map<?, ?> attributes) {
return ((attributes == null) || attributes.size() == 0);
}
/**
- * Updates the interal bitset from <code>iterator</code>. This will
- * set <code>validMask</code> to true if <code>iterator</code> is
+ * Updates the interal bitset from {@code iterator}. This will
+ * set {@code validMask} to true if {@code iterator} is
* non-null.
*/
private void updateMask(AttributedCharacterIterator iterator) {
if (iterator != null) {
validMask = true;
@@ -817,20 +817,20 @@
}
}
}
/**
- * Returns true if <code>field</code> is non-null.
+ * Returns true if {@code field} is non-null.
* Subclasses that wish to allow incrementing to happen outside of
* the known fields will need to override this.
*/
boolean canIncrement(Object field, int cursorPosition) {
return (field != null);
}
/**
- * Selects the fields identified by <code>attributes</code>.
+ * Selects the fields identified by {@code attributes}.
*/
void selectField(Object f, int count) {
AttributedCharacterIterator iterator = getIterator();
if (iterator != null &&
@@ -863,13 +863,13 @@
Object getAdjustField(int start, Map<?, ?> attributes) {
return null;
}
/**
- * Returns the number of occurrences of <code>f</code> before
- * the location <code>start</code> in the current
- * <code>AttributedCharacterIterator</code>.
+ * Returns the number of occurrences of {@code f} before
+ * the location {@code start} in the current
+ * {@code AttributedCharacterIterator}.
*/
private int getFieldTypeCountTo(Object f, int start) {
AttributedCharacterIterator iterator = getIterator();
int count = 0;
@@ -895,14 +895,14 @@
return count;
}
/**
* Subclasses supporting incrementing must override this to handle
- * the actual incrementing. <code>value</code> is the current value,
- * <code>attributes</code> gives the field the cursor is in (may be
- * null depending upon <code>canIncrement</code>) and
- * <code>direction</code> is the amount to increment by.
+ * the actual incrementing. {@code value} is the current value,
+ * {@code attributes} gives the field the cursor is in (may be
+ * null depending upon {@code canIncrement}) and
+ * {@code direction} is the amount to increment by.
*/
Object adjustValue(Object value, Map<?, ?> attributes, Object field,
int direction) throws
BadLocationException, ParseException {
return null;
@@ -911,19 +911,19 @@
/**
* Returns false, indicating InternationalFormatter does not allow
* incrementing of the value. Subclasses that wish to support
* incrementing/decrementing the value should override this and
* return true. Subclasses should also override
- * <code>adjustValue</code>.
+ * {@code adjustValue}.
*/
boolean getSupportsIncrement() {
return false;
}
/**
* Resets the value of the JFormattedTextField to be
- * <code>value</code>.
+ * {@code value}.
*/
void resetValue(Object value) throws BadLocationException, ParseException {
Document doc = getFormattedTextField().getDocument();
String string = valueToString(value);
@@ -947,11 +947,11 @@
updateMaskIfNecessary();
}
/**
- * Overriden to return an instance of <code>ExtendedReplaceHolder</code>.
+ * Overriden to return an instance of {@code ExtendedReplaceHolder}.
*/
ReplaceHolder getReplaceHolder(DocumentFilter.FilterBypass fb, int offset,
int length, String text,
AttributeSet attrs) {
if (replaceHolder == null) {
@@ -994,11 +994,11 @@
}
/**
* IncrementAction is used to increment the value by a certain amount.
- * It calls into <code>adjustValue</code> to handle the actual
+ * It calls into {@code adjustValue} to handle the actual
* incrementing of the value.
*/
private class IncrementAction extends AbstractAction {
private int direction;
< prev index next >