Line Number in JTextPane

Question

Hi Experts;
How do I add a caret listener on this code so that it will just add a number
when the user goes to the next line.
import java.awt.*;
import javax.swing.*;
public class LineNumber extends JComponent
     private final static Color DEFAULT_BACKGROUND = new Color(213, 213, 234);
     private final static Color DEFAULT_FOREGROUND = Color.white;
     private final static Font DEFAULT_FONT = new Font("arial", Font.PLAIN, 11);
     // LineNumber height (abends when I use MAX_VALUE)
     private final static int HEIGHT = Integer.MAX_VALUE - 1000000;
     // Set right/left margin
     private final static int MARGIN = 5;
     // Line height of this LineNumber component
     private int lineHeight;
     // Line height of this LineNumber component
     private int fontLineHeight;
     // With of the LineNumber component
     private int currentRowWidth;
     // Metrics of this LineNumber component
     private FontMetrics fontMetrics;
      * Convenience constructor for Text Components
     public LineNumber(JComponent component)
          if (component == null)
               setBackground( DEFAULT_BACKGROUND );
               setForeground( DEFAULT_FOREGROUND );
               setFont( DEFAULT_FONT );
          else
               setBackground( DEFAULT_BACKGROUND );
               setForeground( DEFAULT_FOREGROUND );
               setFont( component.getFont() );
          setPreferredSize( 99 );
     public void setPreferredSize(int row)
          int width = fontMetrics.stringWidth( String.valueOf(row) );
          if (currentRowWidth < width)
               currentRowWidth = width;
               setPreferredSize( new Dimension(2 * MARGIN + width, HEIGHT) );
     public void setFont(Font font)
          super.setFont(font);
          fontMetrics = getFontMetrics( getFont() );
          fontLineHeight = fontMetrics.getHeight();
      * The line height defaults to the line height of the font for this
      * component. The line height can be overridden by setting it to a
      * positive non-zero value.
     public int getLineHeight()
          if (lineHeight == 0)
               return fontLineHeight;
          else
               return lineHeight;
     public void setLineHeight(int lineHeight)
          if (lineHeight > 0)
               this.lineHeight = lineHeight;
     public int getStartOffset()
          return 4;
     public void paintComponent(Graphics g)
           int lineHeight = getLineHeight();
           int startOffset = getStartOffset();
           Rectangle drawHere = g.getClipBounds();
           g.setColor( getBackground() );
           g.fillRect(drawHere.x, drawHere.y, drawHere.width, drawHere.height);
           g.setColor( getForeground() );
           int startLineNumber = (drawHere.y / lineHeight) + 1;
           int endLineNumber = startLineNumber + (drawHere.height / lineHeight);
           int start = (drawHere.y / lineHeight) * lineHeight + lineHeight - startOffset;
           for (int i = startLineNumber; i <= endLineNumber; i++)
           String lineNumber = String.valueOf(i);
           int width = fontMetrics.stringWidth( lineNumber );
           g.drawString(lineNumber, MARGIN + currentRowWidth - width, start);
           start += lineHeight;
           setPreferredSize( endLineNumber );
} Thanks for your time . . .
The_Developer

Answer 1

Here's what I use. It behaves correctly WRT wrapped lines, and should work equally well with a JTextArea or a JTextPane.
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.SizeSequence;
import javax.swing.UIManager;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.Element;
import javax.swing.text.JTextComponent;
* LineNumberView is a simple line-number gutter that works correctly
* even when lines are wrapped in the associated text component.  This
* is meant to be used as the RowHeaderView in a JScrollPane that
* contains the associated text component.  Example usage:
*<pre>
*   JTextArea ta = new JTextArea();
*   ta.setLineWrap(true);
*   ta.setWrapStyleWord(true);
*   JScrollPane sp = new JScrollPane(ta);
*   sp.setRowHeaderView(new LineNumberView(ta));
*</pre>
* @author Alan Moore
public class LineNumberView extends JComponent
  // This is for the border to the right of the line numbers.
  // There's probably a UIDefaults value that could be used for this.
  private static final Color BORDER_COLOR = Color.GRAY;
  private static final int WIDTH_TEMPLATE = 99999;
  private static final int MARGIN = 5;
  private FontMetrics viewFontMetrics;
  private int maxNumberWidth;
  private int componentWidth;
  private int textTopInset;
  private int textFontAscent;
  private int textFontHeight;
  private JTextComponent text;
  private SizeSequence sizes;
  private int startLine = 0;
  private boolean structureChanged = true;
   * Construct a LineNumberView and attach it to the given text component.
   * The LineNumberView will listen for certain kinds of events from the
   * text component and update itself accordingly.
   * @param startLine the line that changed, if there's only one
   * @param structureChanged if <tt>true</tt>, ignore the line number and
   *     update all the line heights.
  public LineNumberView(JTextComponent text)
    if (text == null)
      throw new IllegalArgumentException("Text component cannot be null");
    this.text = text;
    updateCachedMetrics();
    UpdateHandler handler = new UpdateHandler();
    text.getDocument().addDocumentListener(handler);
    text.addPropertyChangeListener(handler);
    text.addComponentListener(handler);
    setBorder(BorderFactory.createMatteBorder(0, 0, 0, 1, BORDER_COLOR));
   * Schedule a repaint because one or more line heights may have changed.
   * @param startLine the line that changed, if there's only one
   * @param structureChanged if <tt>true</tt>, ignore the line number and
   *     update all the line heights.
  private void viewChanged(int startLine, boolean structureChanged)
    this.startLine = startLine;
    this.structureChanged = structureChanged;
    revalidate();
    repaint();
  /** Update the line heights as needed. */
  private void updateSizes()
    if (startLine < 0)
      return;
    if (structureChanged)
      int count = getAdjustedLineCount();
      sizes = new SizeSequence(count);
      for (int i = 0; i < count; i++)
        sizes.setSize(i, getLineHeight(i));
      structureChanged = false;
    else
      sizes.setSize(startLine, getLineHeight(startLine));
    startLine = -1;
  /* Copied from javax.swing.text.PlainDocument */
  private int getAdjustedLineCount()
    // There is an implicit break being modeled at the end of the
    // document to deal with boundary conditions at the end.  This
    // is not desired in the line count, so we detect it and remove
    // its effect if throwing off the count.
    Element map = text.getDocument().getDefaultRootElement();
    int n = map.getElementCount();
    Element lastLine = map.getElement(n - 1);
    if ((lastLine.getEndOffset() - lastLine.getStartOffset()) > 1)
      return n;
    return n - 1;
   * Get the height of a line from the JTextComponent.
   * @param index the line number
   * @param the height, in pixels
  private int getLineHeight(int index)
    int lastPos = sizes.getPosition(index) + textTopInset;
    int height = textFontHeight;
    try
      Element map = text.getDocument().getDefaultRootElement();
      int lastChar = map.getElement(index).getEndOffset() - 1;
      Rectangle r = text.modelToView(lastChar);
      height = (r.y - lastPos) + r.height;
    catch (BadLocationException ex)
      ex.printStackTrace();
    return height;
   * Cache some values that are used a lot in painting or size
   * calculations. Also ensures that the line-number font is not
   * larger than the text component's font (by point-size, anyway).
  private void updateCachedMetrics()
    Font textFont = text.getFont();
    FontMetrics fm = getFontMetrics(textFont);
    textFontHeight = fm.getHeight();
    textFontAscent = fm.getAscent();
    textTopInset = text.getInsets().top;
    Font viewFont = getFont();
    boolean changed = false;
    if (viewFont == null)
      viewFont = UIManager.getFont("Label.font");
      changed = true;
    if (viewFont.getSize() > textFont.getSize())
      viewFont = viewFont.deriveFont(textFont.getSize2D());
      changed = true;
    viewFontMetrics = getFontMetrics(viewFont);
    maxNumberWidth = viewFontMetrics.stringWidth(String.valueOf(WIDTH_TEMPLATE));
    componentWidth = 2 * MARGIN + maxNumberWidth;
    if (changed)
      super.setFont(viewFont);
  public Dimension getPreferredSize()
    return new Dimension(componentWidth, text.getHeight());
  public void setFont(Font font)
    super.setFont(font);
    updateCachedMetrics();
  public void paintComponent(Graphics g)
    updateSizes();
    Rectangle clip = g.getClipBounds();
    g.setColor(getBackground());
    g.fillRect(clip.x, clip.y, clip.width, clip.height);
    g.setColor(getForeground());
    int base = clip.y - textTopInset;
    int first = sizes.getIndex(base);
    int last = sizes.getIndex(base + clip.height);
    String text = "";
    for (int i = first; i <= last; i++)
      text = String.valueOf(i+1);
      int x = MARGIN + maxNumberWidth - viewFontMetrics.stringWidth(text);
      int y = sizes.getPosition(i) + textFontAscent + textTopInset;
      g.drawString(text, x, y);
  class UpdateHandler extends ComponentAdapter
      implements PropertyChangeListener, DocumentListener
     * The text component was resized. 'Nuff said.
    public void componentResized(ComponentEvent evt)
      viewChanged(0, true);
     * A bound property was changed on the text component. Properties
     * like the font, border, and tab size affect the layout of the
     * whole document, so we invalidate all the line heights here.
    public void propertyChange(PropertyChangeEvent evt)
      Object oldValue = evt.getOldValue();
      Object newValue = evt.getNewValue();
      String propertyName = evt.getPropertyName();
      if ("document".equals(propertyName))
        if (oldValue != null && oldValue instanceof Document)
          ((Document)oldValue).removeDocumentListener(this);
        if (newValue != null && newValue instanceof Document)
          ((Document)newValue).addDocumentListener(this);
      updateCachedMetrics();
      viewChanged(0, true);
     * Text was inserted into the document.
    public void insertUpdate(DocumentEvent evt)
      update(evt);
     * Text was removed from the document.
    public void removeUpdate(DocumentEvent evt)
      update(evt);
     * Text attributes were changed.  In a source-code editor based on
     * StyledDocument, attribute changes should be applied automatically
     * in response to inserts and removals.  Since we're already
     * listening for those, this method should be redundant, but YMMV.
    public void changedUpdate(DocumentEvent evt)
//      update(evt);
     * If the edit was confined to a single line, invalidate that
     * line's height.  Otherwise, invalidate them all.
    private void update(DocumentEvent evt)
      Element map = text.getDocument().getDefaultRootElement();
      int line = map.getElementIndex(evt.getOffset());
      DocumentEvent.ElementChange ec = evt.getChange(map);
      viewChanged(line, ec != null);
}