< prev index next >

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

Print this page

        

@@ -85,13 +85,13 @@
      * Used when writing out a string.
      */
     private char[] tempChars;
 
     /**
-     * This is used in <code>writeLineSeparator</code> instead of
+     * This is used in {@code writeLineSeparator} instead of
      * tempChars. If tempChars were used it would mean write couldn't invoke
-     * <code>writeLineSeparator</code> as it might have been passed
+     * {@code writeLineSeparator} as it might have been passed
      * tempChars.
      */
     private char[] newlineChars;
 
     /**

@@ -267,14 +267,14 @@
      * Returns the text associated with the element.
      * The assumption here is that the element is a
      * leaf element.  Throws a BadLocationException
      * when encountered.
      *
-     * @param     elem an <code>Element</code>
+     * @param     elem an {@code Element}
      * @exception BadLocationException if pos represents an invalid
      *            location within the document
-     * @return    the text as a <code>String</code>
+     * @return    the text as a {@code String}
      */
     protected String getText(Element elem) throws BadLocationException {
         return doc.getText(elem.getStartOffset(),
                            elem.getEndOffset() - elem.getStartOffset());
     }

@@ -343,12 +343,12 @@
         return currLength;
     }
 
     /**
      * Returns true if the current line should be considered empty. This
-     * is true when <code>getCurrentLineLength</code> == 0 ||
-     * <code>indent</code> has been invoked on an empty line.
+     * is true when {@code getCurrentLineLength} == 0 ||
+     * {@code indent} has been invoked on an empty line.
      * @return true if the current line should be considered empty
      * @since 1.3
      */
     protected boolean isLineEmpty() {
         return isLineEmpty;

@@ -415,12 +415,12 @@
         return lineSeparator;
     }
 
     /**
      * Increments the indent level. If indenting would cause
-     * <code>getIndentSpace()</code> *<code>getIndentLevel()</code> to be &gt;
-     * than <code>getLineLength()</code> this will not cause an indent.
+     * {@code getIndentSpace()} *{@code getIndentLevel()} to be &gt;
+     * than {@code getLineLength()} this will not cause an indent.
      */
     protected void incrIndent() {
         // Only increment to a certain point.
         if (offsetIndent > 0) {
             offsetIndent++;

@@ -445,12 +445,12 @@
         }
     }
 
     /**
      * Returns the current indentation level. That is, the number of times
-     * <code>incrIndent</code> has been invoked minus the number of times
-     * <code>decrIndent</code> has been invoked.
+     * {@code incrIndent} has been invoked minus the number of times
+     * {@code decrIndent} has been invoked.
      * @return the current indentation level
      * @since 1.3
      */
     protected int getIndentLevel() {
         return indentLevel;

@@ -480,11 +480,11 @@
         }
     }
 
     /**
      * Writes out a character. This is implemented to invoke
-     * the <code>write</code> method that takes a char[].
+     * the {@code write} method that takes a char[].
      *
      * @param     ch a char.
      * @exception IOException on any I/O error
      */
     protected void write(char ch) throws IOException {

@@ -495,11 +495,11 @@
         write(tempChars, 0, 1);
     }
 
     /**
      * Writes out a string. This is implemented to invoke the
-     * <code>write</code> method that takes a char[].
+     * {@code write} method that takes a char[].
      *
      * @param     content a String.
      * @exception IOException on any I/O error
      */
     protected void write(String content) throws IOException {

@@ -513,12 +513,12 @@
         content.getChars(0, size, tempChars, 0);
         write(tempChars, 0, size);
     }
 
     /**
-     * Writes the line separator. This invokes <code>output</code> directly
-     * as well as setting the <code>lineLength</code> to 0.
+     * Writes the line separator. This invokes {@code output} directly
+     * as well as setting the {@code lineLength} to 0.
      * @throws IOException on any I/O error
      * @since 1.3
      */
     protected void writeLineSeparator() throws IOException {
         String newline = getLineSeparator();

@@ -530,19 +530,19 @@
         output(newlineChars, 0, length);
         setCurrentLineLength(0);
     }
 
     /**
-     * All write methods call into this one. If <code>getCanWrapLines()</code>
-     * returns false, this will call <code>output</code> with each sequence
-     * of <code>chars</code> that doesn't contain a NEWLINE, followed
-     * by a call to <code>writeLineSeparator</code>. On the other hand,
-     * if <code>getCanWrapLines()</code> returns true, this will split the
-     * string, as necessary, so <code>getLineLength</code> is honored.
+     * All write methods call into this one. If {@code getCanWrapLines()}
+     * returns false, this will call {@code output} with each sequence
+     * of {@code chars} that doesn't contain a NEWLINE, followed
+     * by a call to {@code writeLineSeparator}. On the other hand,
+     * if {@code getCanWrapLines()} returns true, this will split the
+     * string, as necessary, so {@code getLineLength} is honored.
      * The only exception is if the current string contains no whitespace,
      * and won't fit in which case the line length will exceed
-     * <code>getLineLength</code>.
+     * {@code getLineLength}.
      *
      * @param chars characters to output
      * @param startIndex starting index
      * @param length length of output
      * @throws IOException on any I/O error

@@ -682,17 +682,17 @@
         }
     }
 
     /**
      * The last stop in writing out content. All the write methods eventually
-     * make it to this method, which invokes <code>write</code> on the
+     * make it to this method, which invokes {@code write} on the
      * Writer.
      * <p>This method also updates the line length based on
-     * <code>length</code>. If this is invoked to output a newline, the
+     * {@code length}. If this is invoked to output a newline, the
      * current line length will need to be reset as will no longer be
      * valid. If it is up to the caller to do this. Use
-     * <code>writeLineSeparator</code> to write out a newline, which will
+     * {@code writeLineSeparator} to write out a newline, which will
      * property update the current line length.
      *
      * @param content characters to output
      * @param start starting index
      * @param length length of output
< prev index next >