< prev index next >

src/java.desktop/share/classes/javax/swing/text/MaskFormatter.java

Print this page

        

@@ -29,42 +29,42 @@
 import java.text.*;
 import java.util.*;
 import javax.swing.*;
 
 /**
- * <code>MaskFormatter</code> is used to format and edit strings. The behavior
- * of a <code>MaskFormatter</code> is controlled by way of a String mask
+ * {@code MaskFormatter} is used to format and edit strings. The behavior
+ * of a {@code MaskFormatter} is controlled by way of a String mask
  * that specifies the valid characters that can be contained at a particular
- * location in the <code>Document</code> model. The following characters can
+ * location in the {@code Document} model. The following characters can
  * be specified:
  *
  * <table border=1 summary="Valid characters and their descriptions">
  * <tr>
  *    <th>Character&nbsp;</th>
  *    <th><p style="text-align:left">Description</p></th>
  * </tr>
  * <tr>
  *    <td>#</td>
- *    <td>Any valid number, uses <code>Character.isDigit</code>.</td>
+ *    <td>Any valid number, uses {@code Character.isDigit}.</td>
  * </tr>
  * <tr>
  *    <td>'</td>
  *    <td>Escape character, used to escape any of the
  *       special formatting characters.</td>
  * </tr>
  * <tr>
- *    <td>U</td><td>Any character (<code>Character.isLetter</code>). All
+ *    <td>U</td><td>Any character ({@code Character.isLetter}). All
  *        lowercase letters are mapped to upper case.</td>
  * </tr>
- * <tr><td>L</td><td>Any character (<code>Character.isLetter</code>). All
+ * <tr><td>L</td><td>Any character ({@code Character.isLetter}). All
  *        upper case letters are mapped to lower case.</td>
  * </tr>
- * <tr><td>A</td><td>Any character or number (<code>Character.isLetter</code>
- *       or <code>Character.isDigit</code>)</td>
+ * <tr><td>A</td><td>Any character or number ({@code Character.isLetter}
+ *       or {@code Character.isDigit})</td>
  * </tr>
  * <tr><td>?</td><td>Any character
- *        (<code>Character.isLetter</code>).</td>
+ *        ({@code Character.isLetter}).</td>
  * </tr>
  * <tr><td>*</td><td>Anything.</td></tr>
  * <tr><td>H</td><td>Any hex character (0-9, a-f or A-F).</td></tr>
  * </table>
  *

@@ -72,13 +72,13 @@
  * Typically characters correspond to one char, but in certain languages this
  * is not the case. The mask is on a per character basis, and will thus
  * adjust to fit as many chars as are needed.
  * <p>
  * You can further restrict the characters that can be input by the
- * <code>setInvalidCharacters</code> and <code>setValidCharacters</code>
- * methods. <code>setInvalidCharacters</code> allows you to specify
- * which characters are not legal. <code>setValidCharacters</code> allows
+ * {@code setInvalidCharacters} and {@code setValidCharacters}
+ * methods. {@code setInvalidCharacters} allows you to specify
+ * which characters are not legal. {@code setValidCharacters} allows
  * you to specify which characters are valid. For example, the following
  * code block is equivalent to a mask of '0xHHH' with no invalid/valid
  * characters:
  * <pre>
  * MaskFormatter formatter = new MaskFormatter("0x***");

@@ -94,17 +94,17 @@
  *   formatter.setPlaceholderCharacter('_');
  *   formatter.getDisplayValue(tf, "123");
  * </pre>
  * <p>
  * Would result in the string '123-____'. If
- * <code>setPlaceholder("555-1212")</code> was invoked '123-1212' would
+ * {@code setPlaceholder("555-1212")} was invoked '123-1212' would
  * result. The placeholder String is only used on the initial format,
  * on subsequent formats only the placeholder character will be used.
  * <p>
- * If a <code>MaskFormatter</code> is configured to only allow valid characters
- * (<code>setAllowsInvalid(false)</code>) literal characters will be skipped as
- * necessary when editing. Consider a <code>MaskFormatter</code> with
+ * If a {@code MaskFormatter} is configured to only allow valid characters
+ * ({@code setAllowsInvalid(false)}) literal characters will be skipped as
+ * necessary when editing. Consider a {@code MaskFormatter} with
  * the mask "###-####" and current value "555-1212". Using the right
  * arrow key to navigate through the field will result in (| indicates the
  * position of the caret):
  * <pre>
  *   |555-1212

@@ -114,39 +114,39 @@
  *   555-1|212
  * </pre>
  * The '-' is a literal (non-editable) character, and is skipped.
  * <p>
  * Similar behavior will result when editing. Consider inserting the string
- * '123-45' and '12345' into the <code>MaskFormatter</code> in the
+ * '123-45' and '12345' into the {@code MaskFormatter} in the
  * previous example. Both inserts will result in the same String,
- * '123-45__'. When <code>MaskFormatter</code>
+ * '123-45__'. When {@code MaskFormatter}
  * is processing the insert at character position 3 (the '-'), two things can
  * happen:
  * <ol>
  *   <li>If the inserted character is '-', it is accepted.
  *   <li>If the inserted character matches the mask for the next non-literal
  *       character, it is accepted at the new location.
  *   <li>Anything else results in an invalid edit
  * </ol>
  * <p>
- * By default <code>MaskFormatter</code> will not allow invalid edits, you can
- * change this with the <code>setAllowsInvalid</code> method, and will
- * commit edits on valid edits (use the <code>setCommitsOnValidEdit</code> to
+ * By default {@code MaskFormatter} will not allow invalid edits, you can
+ * change this with the {@code setAllowsInvalid} method, and will
+ * commit edits on valid edits (use the {@code setCommitsOnValidEdit} to
  * change this).
  * <p>
- * By default, <code>MaskFormatter</code> is in overwrite mode. That is as
+ * By default, {@code MaskFormatter} is in overwrite mode. That is as
  * characters are typed a new character is not inserted, rather the character
  * at the current location is replaced with the newly typed character. You
- * can change this behavior by way of the method <code>setOverwriteMode</code>.
+ * can change this behavior by way of the method {@code setOverwriteMode}.
  * <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&trade;
- * 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}.
  *
  * @since 1.4
  */
 @SuppressWarnings("serial") // Same-version serialization only

@@ -194,24 +194,24 @@
         maskChars = EmptyMaskChars;
         placeholder = ' ';
     }
 
     /**
-     * Creates a <code>MaskFormatter</code> with the specified mask.
-     * A <code>ParseException</code>
-     * will be thrown if <code>mask</code> is an invalid mask.
+     * Creates a {@code MaskFormatter} with the specified mask.
+     * A {@code ParseException}
+     * will be thrown if {@code mask} is an invalid mask.
      * @param mask the mask
      * @throws ParseException if mask does not contain valid mask characters
      */
     public MaskFormatter(String mask) throws ParseException {
         this();
         setMask(mask);
     }
 
     /**
      * Sets the mask dictating the legal characters.
-     * This will throw a <code>ParseException</code> if <code>mask</code> is
+     * This will throw a {@code ParseException} if {@code mask} is
      * not valid.
      * @param mask the mask
      *
      * @throws ParseException if mask does not contain valid mask characters
      */

@@ -230,12 +230,12 @@
     }
 
     /**
      * Allows for further restricting of the characters that can be input.
      * Only characters specified in the mask, not in the
-     * <code>invalidCharacters</code>, and in
-     * <code>validCharacters</code> will be allowed to be input. Passing
+     * {@code invalidCharacters}, and in
+     * {@code validCharacters} will be allowed to be input. Passing
      * in null (the default) implies the valid characters are only bound
      * by the mask and the invalid characters.
      *
      * @param validCharacters If non-null, specifies legal characters.
      */

@@ -253,12 +253,12 @@
     }
 
     /**
      * Allows for further restricting of the characters that can be input.
      * Only characters specified in the mask, not in the
-     * <code>invalidCharacters</code>, and in
-     * <code>validCharacters</code> will be allowed to be input. Passing
+     * {@code invalidCharacters}, and in
+     * {@code validCharacters} will be allowed to be input. Passing
      * in null (the default) implies the valid characters are only bound
      * by the mask and the valid characters.
      *
      * @param invalidCharacters If non-null, specifies illegal characters.
      */

@@ -325,28 +325,28 @@
 
     /**
      * If true, the returned value and set value will also contain the literal
      * characters in mask.
      * <p>
-     * For example, if the mask is <code>'(###) ###-####'</code>, the
-     * current value is <code>'(415) 555-1212'</code>, and
-     * <code>valueContainsLiteralCharacters</code> is
-     * true <code>stringToValue</code> will return
-     * <code>'(415) 555-1212'</code>. On the other hand, if
-     * <code>valueContainsLiteralCharacters</code> is false,
-     * <code>stringToValue</code> will return <code>'4155551212'</code>.
+     * For example, if the mask is {@code '(###) ###-####'}, the
+     * current value is {@code '(415) 555-1212'}, and
+     * {@code valueContainsLiteralCharacters} is
+     * true {@code stringToValue} will return
+     * {@code '(415) 555-1212'}. On the other hand, if
+     * {@code valueContainsLiteralCharacters} is false,
+     * {@code stringToValue} will return {@code '4155551212'}.
      *
      * @param containsLiteralChars Used to indicate if literal characters in
      *        mask should be returned in stringToValue
      */
     public void setValueContainsLiteralCharacters(
                         boolean containsLiteralChars) {
         this.containsLiteralChars = containsLiteralChars;
     }
 
     /**
-     * Returns true if <code>stringToValue</code> should return literal
+     * Returns true if {@code stringToValue} should return literal
      * characters in the mask.
      *
      * @return True if literal characters in mask should be returned in
      *         stringToValue
      */

@@ -354,15 +354,15 @@
         return containsLiteralChars;
     }
 
     /**
      * Parses the text, returning the appropriate Object representation of
-     * the String <code>value</code>. This strips the literal characters as
-     * necessary and invokes supers <code>stringToValue</code>, so that if
-     * you have specified a value class (<code>setValueClass</code>) an
+     * the String {@code value}. This strips the literal characters as
+     * necessary and invokes supers {@code stringToValue}, so that if
+     * you have specified a value class ({@code setValueClass}) an
      * instance of it will be created. This will throw a
-     * <code>ParseException</code> if the value does not match the current
+     * {@code ParseException} if the value does not match the current
      * mask.  Refer to {@link #setValueContainsLiteralCharacters} for details
      * on how literals are treated.
      *
      * @throws ParseException if there is an error in the conversion
      * @param value String to convert

@@ -372,11 +372,11 @@
     public Object stringToValue(String value) throws ParseException {
         return stringToValue(value, true);
     }
 
     /**
-     * Returns a String representation of the Object <code>value</code>
+     * Returns a String representation of the Object {@code value}
      * based on the mask.  Refer to
      * {@link #setValueContainsLiteralCharacters} for details
      * on how literals are treated.
      *
      * @throws ParseException if there is an error in the conversion

@@ -393,33 +393,33 @@
         append(result, sValue, valueCounter, placeholder, maskChars);
         return result.toString();
     }
 
     /**
-     * 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.

@@ -438,13 +438,13 @@
             }
         }
     }
 
     /**
-     * Actual <code>stringToValue</code> implementation.
-     * If <code>completeMatch</code> is true, the value must exactly match
-     * the mask, on the other hand if <code>completeMatch</code> is false
+     * Actual {@code stringToValue} implementation.
+     * If {@code completeMatch} is true, the value must exactly match
+     * the mask, on the other hand if {@code completeMatch} is false
      * the string must match the mask or the placeholder string.
      */
     private Object stringToValue(String value, boolean completeMatch) throws
                          ParseException {
         int errorOffset;

@@ -480,12 +480,12 @@
         }
         return -1;
     }
 
     /**
-     * Invokes <code>append</code> on the mask characters in
-     * <code>mask</code>.
+     * Invokes {@code append} on the mask characters in
+     * {@code mask}.
      */
     private void append(StringBuilder result, String value, int[] index,
                         String placeholder, MaskCharacter[] mask)
                           throws ParseException {
         for (int counter = 0, maxCounter = mask.length;

@@ -667,23 +667,23 @@
     }
 
     /**
      * Returns true if the MaskFormatter allows invalid, or
      * the offset is less than the max length and the character at
-     * <code>offset</code> is a literal.
+     * {@code offset} is a literal.
      */
     boolean isNavigatable(int offset) {
         if (!getAllowsInvalid()) {
             return (offset < getMaxLength() && !isLiteral(offset));
         }
         return true;
     }
 
     /*
-     * Returns true if the operation described by <code>rh</code> will
-     * result in a legal edit.  This may set the <code>value</code>
-     * field of <code>rh</code>.
+     * Returns true if the operation described by {@code rh} will
+     * result in a legal edit.  This may set the {@code value}
+     * field of {@code rh}.
      * <p>
      * This is overriden to return true for a partial match.
      */
     boolean isValidEdit(ReplaceHolder rh) {
         if (!getAllowsInvalid()) {

@@ -830,14 +830,14 @@
         public boolean isLiteral() {
             return false;
         }
 
         /**
-         * Returns true if <code>aChar</code> is a valid reprensentation of
+         * Returns true if {@code aChar} is a valid reprensentation of
          * the receiver. The default implementation returns true if the
-         * receiver represents a literal character and <code>getChar</code>
-         * == aChar. Otherwise, this will return true is <code>aChar</code>
+         * receiver represents a literal character and {@code getChar}
+         * == aChar. Otherwise, this will return true is {@code aChar}
          * is contained in the valid characters and not contained
          * in the invalid characters.
          */
         public boolean isValidCharacter(char aChar) {
             if (isLiteral()) {

@@ -857,22 +857,22 @@
             }
             return true;
         }
 
         /**
-         * Returns the character to insert for <code>aChar</code>. The
-         * default implementation returns <code>aChar</code>. Subclasses
+         * Returns the character to insert for {@code aChar}. The
+         * default implementation returns {@code aChar}. Subclasses
          * that wish to do some sort of mapping, perhaps lower case to upper
          * case should override this and do the necessary mapping.
          */
         public char getChar(char aChar) {
             return aChar;
         }
 
         /**
-         * Appends the necessary character in <code>formatting</code> at
-         * <code>index</code> to <code>buff</code>.
+         * Appends the necessary character in {@code formatting} at
+         * {@code index} to {@code buff}.
          */
         public void append(StringBuilder buff, String formatting, int[] index,
                            String placeholder)
                           throws ParseException {
             boolean inString = index[0] < formatting.length();

@@ -928,11 +928,11 @@
         }
     }
 
 
     /**
-     * Represents a number, uses <code>Character.isDigit</code>.
+     * Represents a number, uses {@code Character.isDigit}.
      */
     private class DigitMaskCharacter extends MaskCharacter {
         public boolean isValidCharacter(char aChar) {
             return (Character.isDigit(aChar) &&
                     super.isValidCharacter(aChar));

@@ -940,11 +940,11 @@
     }
 
 
     /**
      * Represents a character, lower case letters are mapped to upper case
-     * using <code>Character.toUpperCase</code>.
+     * using {@code Character.toUpperCase}.
      */
     private class UpperCaseCharacter extends MaskCharacter {
         public boolean isValidCharacter(char aChar) {
             return (Character.isLetter(aChar) &&
                      super.isValidCharacter(aChar));

@@ -956,11 +956,11 @@
     }
 
 
     /**
      * Represents a character, upper case letters are mapped to lower case
-     * using <code>Character.toLowerCase</code>.
+     * using {@code Character.toLowerCase}.
      */
     private class LowerCaseCharacter extends MaskCharacter {
         public boolean isValidCharacter(char aChar) {
             return (Character.isLetter(aChar) &&
                      super.isValidCharacter(aChar));

@@ -972,22 +972,22 @@
     }
 
 
     /**
      * Represents either a character or digit, uses
-     * <code>Character.isLetterOrDigit</code>.
+     * {@code Character.isLetterOrDigit}.
      */
     private class AlphaNumericCharacter extends MaskCharacter {
         public boolean isValidCharacter(char aChar) {
             return (Character.isLetterOrDigit(aChar) &&
                      super.isValidCharacter(aChar));
         }
     }
 
 
     /**
-     * Represents a letter, uses <code>Character.isLetter</code>.
+     * Represents a letter, uses {@code Character.isLetter}.
      */
     private class CharCharacter extends MaskCharacter {
         public boolean isValidCharacter(char aChar) {
             return (Character.isLetter(aChar) &&
                      super.isValidCharacter(aChar));
< prev index next >