< prev index next >

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

Print this page

        

@@ -29,79 +29,79 @@
 import java.util.*;
 import sun.reflect.misc.ReflectUtil;
 import sun.swing.SwingUtilities2;
 
 /**
- * <code>NumberFormatter</code> subclasses <code>InternationalFormatter</code>
+ * {@code NumberFormatter} subclasses {@code InternationalFormatter}
  * adding special behavior for numbers. Among the specializations are
- * (these are only used if the <code>NumberFormatter</code> does not display
- * invalid numbers, for example, <code>setAllowsInvalid(false)</code>):
+ * (these are only used if the {@code NumberFormatter} does not display
+ * invalid numbers, for example, {@code setAllowsInvalid(false)}):
  * <ul>
  *   <li>Pressing +/- (- is determined from the
- *       <code>DecimalFormatSymbols</code> associated with the
- *       <code>DecimalFormat</code>) in any field but the exponent
+ *       {@code DecimalFormatSymbols} associated with the
+ *       {@code DecimalFormat}) in any field but the exponent
  *       field will attempt to change the sign of the number to
  *       positive/negative.
  *   <li>Pressing +/- (- is determined from the
- *       <code>DecimalFormatSymbols</code> associated with the
- *       <code>DecimalFormat</code>) in the exponent field will
+ *       {@code DecimalFormatSymbols} associated with the
+ *       {@code DecimalFormat}) in the exponent field will
  *       attempt to change the sign of the exponent to positive/negative.
  * </ul>
  * <p>
  * If you are displaying scientific numbers, you may wish to turn on
- * overwrite mode, <code>setOverwriteMode(true)</code>. For example:
+ * overwrite mode, {@code setOverwriteMode(true)}. For example:
  * <pre>
  * DecimalFormat decimalFormat = new DecimalFormat("0.000E0");
  * NumberFormatter textFormatter = new NumberFormatter(decimalFormat);
  * textFormatter.setOverwriteMode(true);
  * textFormatter.setAllowsInvalid(false);
  * </pre>
  * <p>
  * If you are going to allow the user to enter decimal
  * values, you should either force the DecimalFormat to contain at least
- * one decimal (<code>#.0###</code>), or allow the value to be invalid
- * <code>setAllowsInvalid(true)</code>. Otherwise users may not be able to
+ * one decimal ({@code #.0###}), or allow the value to be invalid
+ * {@code setAllowsInvalid(true)}. Otherwise users may not be able to
  * input decimal values.
  * <p>
- * <code>NumberFormatter</code> provides slightly different behavior to
- * <code>stringToValue</code> than that of its superclass. If you have
+ * {@code NumberFormatter} provides slightly different behavior to
+ * {@code stringToValue} than that of its superclass. If you have
  * specified a Class for values, {@link #setValueClass}, that is one of
- * of <code>Integer</code>, <code>Long</code>, <code>Float</code>,
- * <code>Double</code>, <code>Byte</code> or <code>Short</code> and
- * the Format's <code>parseObject</code> returns an instance of
- * <code>Number</code>, the corresponding instance of the value class
+ * of {@code Integer}, {@code Long}, {@code Float},
+ * {@code Double}, {@code Byte} or {@code Short} and
+ * the Format's {@code parseObject} returns an instance of
+ * {@code Number}, the corresponding instance of the value class
  * will be created using the constructor appropriate for the primitive
  * type the value class represents. For example:
- * <code>setValueClass(Integer.class)</code> will cause the resulting
+ * {@code setValueClass(Integer.class)} will cause the resulting
  * value to be created via
- * <code>new Integer(((Number)formatter.parseObject(string)).intValue())</code>.
+ * {@code new Integer(((Number)formatter.parseObject(string)).intValue())}.
  * This is typically useful if you
- * wish to set a min/max value as the various <code>Number</code>
+ * wish to set a min/max value as the various {@code Number}
  * implementations are generally not comparable to each other. This is also
- * useful if for some reason you need a specific <code>Number</code>
+ * useful if for some reason you need a specific {@code Number}
  * implementation for your values.
  * <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
 public class NumberFormatter extends InternationalFormatter {
     /** The special characters from the Format instance. */
     private String specialChars;
 
     /**
-     * Creates a <code>NumberFormatter</code> with the a default
-     * <code>NumberFormat</code> instance obtained from
-     * <code>NumberFormat.getNumberInstance()</code>.
+     * Creates a {@code NumberFormatter} with the a default
+     * {@code NumberFormat} instance obtained from
+     * {@code NumberFormat.getNumberInstance()}.
      */
     public NumberFormatter() {
         this(NumberFormat.getNumberInstance());
     }
 

@@ -122,11 +122,11 @@
      * Sets the format that dictates the legal values that can be edited
      * and displayed.
      * <p>
      * If you have used the nullary constructor the value of this property
      * will be determined for the current locale by way of the
-     * <code>NumberFormat.getNumberInstance()</code> method.
+     * {@code NumberFormat.getNumberInstance()} method.
      *
      * @param format NumberFormat instance used to dictate legal values
      */
     public void setFormat(Format format) {
         super.setFormat(format);

@@ -152,11 +152,11 @@
             specialChars = "";
         }
     }
 
     /**
-     * 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;

@@ -166,14 +166,14 @@
         return convertValueToValueClass(value, getValueClass());
     }
 
     /**
      * Converts the passed in value to the passed in class. This only
-     * works if <code>valueClass</code> is one of <code>Integer</code>,
-     * <code>Long</code>, <code>Float</code>, <code>Double</code>,
-     * <code>Byte</code> or <code>Short</code> and <code>value</code>
-     * is an instanceof <code>Number</code>.
+     * works if {@code valueClass} is one of {@code Integer},
+     * {@code Long}, {@code Float}, {@code Double},
+     * {@code Byte} or {@code Short} and {@code value}
+     * is an instanceof {@code Number}.
      */
     private Object convertValueToValueClass(Object value,
                                             Class<?> valueClass) {
         if (valueClass != null && (value instanceof Number)) {
             Number numberValue = (Number)value;

@@ -241,13 +241,13 @@
         }
         return null;
     }
 
     /**
-     * Subclassed to return false if <code>text</code> contains in an invalid
+     * Subclassed to return false if {@code text} contains in an invalid
      * character to insert, that is, it is not a digit
-     * (<code>Character.isDigit()</code>) and
+     * ({@code Character.isDigit()}) and
      * not one of the characters defined by the DecimalFormatSymbols.
      */
     boolean isLegalInsertText(String text) {
         if (getAllowsInvalid()) {
             return true;

@@ -312,12 +312,12 @@
         }
         return true;
     }
 
     /**
-     * Returns the first <code>NumberFormat.Field</code> starting
-     * <code>index</code> incrementing by <code>direction</code>.
+     * Returns the first {@code NumberFormat.Field} starting
+     * {@code index} incrementing by {@code direction}.
      */
     private NumberFormat.Field getFieldFrom(int index, int direction) {
         if (isValidMask()) {
             int max = getFormattedTextField().getDocument().getLength();
             AttributedCharacterIterator iterator = getIterator();

@@ -357,11 +357,11 @@
         super.replace(fb, offset, length, string, attr);
     }
 
     /**
      * Will change the sign of the integer or exponent field if
-     * <code>aChar</code> is the positive or minus sign. Returns
+     * {@code aChar} is the positive or minus sign. Returns
      * true if a sign change was attempted.
      */
     private boolean toggleSignIfNecessary(DocumentFilter.FilterBypass fb,
                                               int offset, char aChar) throws
                               BadLocationException {
< prev index next >