TextAreaPainter.java

Go to the documentation of this file.

/*
 * TextAreaPainter.java - Paints the text area
 * Copyright (C) 1999 Slava Pestov
 * Copyright (C) 2000-2015 The Gridarta Developers.
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */

package net.sf.gridarta.textedit.textarea;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.font.FontRenderContext;
import java.awt.font.TextLayout;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import javax.swing.JComponent;
import javax.swing.ToolTipManager;
import javax.swing.text.Segment;
import javax.swing.text.TabExpander;
import javax.swing.text.Utilities;
import net.sf.gridarta.textedit.textarea.tokenmarker.TokenMarker;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class TextAreaPainter extends JComponent implements TabExpander {

    private static final Category LOG = Logger.getLogger(TextAreaPainter.class);

    private static final long serialVersionUID = 1L;

    private final FontRenderContext fontRenderContext = new FontRenderContext(null, false, false);

    private final JEditTextArea textArea;

    @NotNull
    private final TextAreaSelection selection;

    @NotNull
    private final TextAreaCaret caret;

    @NotNull
    private final TextAreaBrackets brackets;

    @NotNull
    private final TextAreaConfig config;

    private final boolean blockCaret;

    private SyntaxStyles styles;

    private final int cols;

    private final int rows;

    private final Color caretColor;

    private final Color selectionColor;

    private final Color lineHighlightColor;

    private final boolean lineHighlight;

    private final Color bracketHighlightColor;

    private final boolean bracketHighlight;

    private final boolean paintInvalid;

    @NotNull
    private final Color eolMarkerColor;

    private final boolean eolMarkers;

    private int currentLineIndex = -1;

    @Nullable
    private List<Token> currentLineTokens;

    @NotNull
    private final Segment currentLine = new Segment();

    private int tabSize;

    @Nullable
    private FontMetrics fontMetrics;

    @Nullable
    private Font defaultFont;

    private int defaultLineHeight;

    private int defaultCharWidth;

    private int visibleLines;

    private int firstLine;

    private int horizontalOffset;

    @NotNull
    private final Segment lineSegment = new Segment();

    public TextAreaPainter(@NotNull final JEditTextArea textArea, @NotNull final TextAreaSelection selection, @NotNull final TextAreaCaret caret, @NotNull final TextAreaDefaults defaults, @NotNull final TextAreaBrackets brackets, @NotNull final TextAreaConfig config, final boolean paintInvalid) {
        this.textArea = textArea;
        this.selection = selection;
        this.caret = caret;
        this.brackets = brackets;
        this.config = config;

        setAutoscrolls(true);
        setDoubleBuffered(true);
        setOpaque(true);

        ToolTipManager.sharedInstance().registerComponent(this);

        setCursor(Cursor.getPredefinedCursor(Cursor.TEXT_CURSOR));

        final Font font = new Font("Monospaced", Font.PLAIN, 14);
        super.setFont(font);
        fontMetrics = getFontMetrics(font);
        setForeground(Color.black);
        setBackground(Color.white);

        blockCaret = defaults.getBlockCaret();
        styles = defaults.getStyles();
        cols = defaults.getCols();
        rows = defaults.getRows();
        caretColor = defaults.getCaretColor();
        selectionColor = defaults.getSelectionColor();
        lineHighlightColor = defaults.getLineHighlightColor();
        lineHighlight = defaults.getLineHighlight();
        bracketHighlightColor = defaults.getBracketHighlightColor();
        bracketHighlight = defaults.getBracketHighlight();
        this.paintInvalid = paintInvalid;
        eolMarkerColor = defaults.getEolMarkerColor();
        eolMarkers = defaults.getEolMarkers();
    }

    private void updateLineInfo() {
        final Font font = getFont();
        if (defaultFont != null && defaultFont.equals(font)) {
            return;
        }

        defaultCharWidth = (int) Math.round((double) new TextLayout("WgGhdJj", font, fontRenderContext).getAdvance() / 7.0);
        defaultLineHeight = Math.round(font.getLineMetrics("WgGhdJj", fontRenderContext).getHeight());
        defaultFont = font;
    }

    public int getDefaultLineHeight() {
        updateLineInfo();
        return defaultLineHeight;
    }

    public int getDefaultCharWidth() {
        updateLineInfo();
        return defaultCharWidth;
    }

    @NotNull
    public SyntaxStyles getStyles() {
        return styles;
    }

    public void setStyles(@NotNull final SyntaxStyles styles) {
        this.styles = styles;
        repaint();
    }

    public boolean isBracketHighlightEnabled() {
        return bracketHighlight;
    }

    public boolean isBlockCaretEnabled() {
        return blockCaret;
    }

    @Nullable
    public FontMetrics getFontMetrics() {
        return fontMetrics;
    }

    @Override
    public final void setFont(@NotNull final Font font) {
        super.setFont(font);
        fontMetrics = getFontMetrics(font);
        recalculateVisibleLines();
    }

    @Override
    public void paint(@NotNull final Graphics g) {
        tabSize = fontMetrics.charWidth(' ') * 4; // I want 4-space wide tabs

        final Rectangle clipRectangle = g.getClipBounds();

        g.setColor(getBackground());
        g.fillRect(clipRectangle.x, clipRectangle.y, clipRectangle.width, clipRectangle.height);

        // We don't use yToLine() here because that method doesn't
        // return lines past the end of the document
        final int height = fontMetrics.getHeight();
        final int firstInvalid = firstLine + clipRectangle.y / height;
        // Because the clipRectangle's height is usually an even multiple
        // of the font height, we subtract 1 from it, otherwise one
        // too many lines will always be painted.
        final int lastInvalid = firstLine + (clipRectangle.y + clipRectangle.height - 1) / height;

        try {
            final TokenMarker tokenMarker = selection.getDocument().getTokenMarker();

            for (int line = firstInvalid; line <= lastInvalid; line++) {
                paintLine(g, tokenMarker, line, horizontalOffset);
            }

            if (tokenMarker != null && tokenMarker.isNextLineRequested()) {
                final int h = clipRectangle.y + clipRectangle.height;
                repaint(0, h, getWidth(), getHeight() - h);
            }
        } catch (final Exception e) {
            LOG.error("Error repainting line range {" + firstInvalid + ", " + lastInvalid + "}", e);
        }
    }

    public void invalidateLine(final int line) {
        repaint(0, lineToY(line) + fontMetrics.getMaxDescent() + fontMetrics.getLeading(), getWidth(), fontMetrics.getHeight());
    }

    public void invalidateLineRange(final int firstLine, final int lastLine) {
        repaint(0, lineToY(firstLine) + fontMetrics.getMaxDescent() + fontMetrics.getLeading(), getWidth(), (lastLine - firstLine + 1) * fontMetrics.getHeight());
    }

    public void invalidateSelectedLines() {
        invalidateLineRange(selection.getSelectionStartLine(), selection.getSelectionEndLine());
    }

    @Override
    public float nextTabStop(final float x, final int tabOffset) {
        final int nTabs = ((int) x - horizontalOffset) / tabSize;
        return (float) ((nTabs + 1) * tabSize + horizontalOffset);
    }

    @NotNull
    @Override
    public Dimension getPreferredSize() {
        final Dimension dim = super.getPreferredSize();
        return dim != null ? dim : newDimension(cols, rows);
    }

    @NotNull
    @Override
    public Dimension getMinimumSize() {
        final Dimension dim = super.getMinimumSize();
        return dim != null ? dim : newDimension(1, 1);
    }

    @NotNull
    private Dimension newDimension(final int columns, final int rows) {
        return new Dimension(columns * fontMetrics.charWidth('w'), rows * fontMetrics.getHeight());
    }

    private void paintLine(@NotNull final Graphics gfx, @Nullable final TokenMarker tokenMarker, final int line, final int x) {
        final Font font = getFont();
        final Color foreground = getForeground();

        currentLineIndex = line;
        final int y = lineToY(line);

        if (line < 0 || line >= selection.getLineCount()) {
            if (paintInvalid) {
                paintHighlight(gfx, line, y);
                styles.getStyle(Token.INVALID).setGraphicsFlags(gfx, font);
                gfx.drawString("~", 0, y + fontMetrics.getHeight());
            }
        } else if (tokenMarker == null) {
            paintPlainLine(gfx, line, font, foreground, x, y);
        } else {
            paintSyntaxLine(gfx, tokenMarker, line, font, foreground, x, y);
        }
    }

    private void paintPlainLine(@NotNull final Graphics gfx, final int line, @NotNull final Font defaultFont, @NotNull final Color defaultColor, final int x, final int y) {
        paintHighlight(gfx, line, y);
        selection.getLineText(line, currentLine);

        gfx.setFont(defaultFont);
        gfx.setColor(defaultColor);

        final int yy = y + fontMetrics.getHeight();
        final int xx = Utilities.drawTabbedText(currentLine, x, yy, gfx, this, 0);

        if (eolMarkers) {
            gfx.setColor(eolMarkerColor);
            gfx.drawString(".", xx, yy);
        }
    }

    private void paintSyntaxLine(@NotNull final Graphics gfx, @NotNull final TokenMarker tokenMarker, final int line, @NotNull final Font defaultFont, @NotNull final Color defaultColor, final int x, final int y) {
        selection.getLineText(currentLineIndex, currentLine);
        currentLineTokens = tokenMarker.markTokens(currentLine, currentLineIndex);

        paintHighlight(gfx, line, y);

        gfx.setFont(defaultFont);
        gfx.setColor(defaultColor);
        final int yy = y + fontMetrics.getHeight();
        final int xx = SyntaxUtilities.paintSyntaxLine(currentLine, currentLineTokens, styles, this, gfx, x, yy);

        if (eolMarkers) {
            // draw End-Of-Line markers, if enabled
            gfx.setColor(eolMarkerColor);
            gfx.drawString(".", xx, yy);
        }
    }

    private void paintHighlight(@NotNull final Graphics gfx, final int line, final int y) {
        if (line >= selection.getSelectionStartLine() && line <= selection.getSelectionEndLine()) {
            paintLineHighlight(gfx, line, y);
        }

        if (bracketHighlight && line == brackets.getBracketLine()) {
            paintBracketHighlight(gfx, line, y);
        }

        if (line == selection.getCaretLine()) {
            paintCaret(gfx, line, y); // CARET gets drawn at this point (if currently visible)
        }
    }

    private void paintLineHighlight(@NotNull final Graphics gfx, final int line, final int y) {
        final int height = fontMetrics.getHeight();
        final int yy = y + fontMetrics.getLeading() + fontMetrics.getMaxDescent();

        final int selectionStart = selection.getSelectionStart();
        final int selectionEnd = selection.getSelectionEnd();

        if (selectionStart == selectionEnd) {
            if (lineHighlight) {
                gfx.setColor(lineHighlightColor);
                gfx.fillRect(0, yy, getWidth(), height);
            }
        } else {
            gfx.setColor(selectionColor);

            final int selectionStartLine = selection.getSelectionStartLine();
            final int selectionEndLine = selection.getSelectionEndLine();
            final int lineStart = selection.getLineStartOffset(line);

            final int x1;
            final int x2;
            if (selection.isSelectionRectangular()) {
                final int lineLen = selection.getLineLength(line);
                x1 = offsetToX2(line, Math.min(lineLen, selectionStart - selection.getLineStartOffset(selectionStartLine)));
                final int x3 = offsetToX2(line, Math.min(lineLen, selectionEnd - selection.getLineStartOffset(selectionEndLine)));
                x2 = x3 + (x1 == x3 ? 1 : 0);
            } else if (selectionStartLine == selectionEndLine) {
                x1 = offsetToX2(line, selectionStart - lineStart);
                x2 = offsetToX2(line, selectionEnd - lineStart);
            } else if (line == selectionStartLine) {
                x1 = offsetToX2(line, selectionStart - lineStart);
                x2 = getWidth();
            } else if (line == selectionEndLine) {
                x1 = 0;
                x2 = offsetToX2(line, selectionEnd - lineStart);
            } else {
                x1 = 0;
                x2 = getWidth();
            }

            gfx.fillRect(Math.min(x1, x2), yy, Math.abs(x1 - x2), height);
        }

    }

    private void paintBracketHighlight(@NotNull final Graphics gfx, final int line, final int y) {
        final int position = brackets.getBracketPosition();
        if (position == -1) {
            return;
        }

        final int yy = y + fontMetrics.getLeading() + fontMetrics.getMaxDescent();
        final int xx = offsetToX2(line, position);
        gfx.setColor(bracketHighlightColor);
        // Hack!!! Since there is no fast way to get the character
        // from the bracket matching routine, we use ( since all
        // brackets probably have the same width anyway
        gfx.drawRect(xx, yy, fontMetrics.charWidth('(') - 1, fontMetrics.getHeight() - 1);
    }

    private void paintCaret(@NotNull final Graphics gfx, final int line, final int y) {
        if (caret.isCaretVisible()) {
            final int offset = selection.getCaretPosition() - selection.getLineStartOffset(line);
            final int caretX = offsetToX2(line, offset);
            final int caretWidth = blockCaret || config.isOverwrite() ? fontMetrics.charWidth('w') : 1;
            final int yy = y + fontMetrics.getLeading() + fontMetrics.getMaxDescent();
            final int height = fontMetrics.getHeight();

            gfx.setColor(caretColor);

            if (config.isOverwrite()) {
                gfx.fillRect(caretX, yy + height - 1, caretWidth, 1);
            } else {
                if (caretWidth <= 1) {
                    // This special case is very important: If 'caretWidth = 1' below rectangle would
                    // have zero width. With JDK 1.4.1, such a rectangle with zero width does not get drawn,
                    // which leads to incredible problems. (Damn this was hard to figure out!)
                    gfx.drawLine(caretX, yy, caretX, yy + height - 1);
                } else {
                    gfx.drawRect(caretX, yy, caretWidth - 1, height - 1);
                }
            }
        }
    }

    public int getCurrentLineIndex() {
        return currentLineIndex;
    }

    public void setCurrentLineIndex(final int lineIndex) {
        currentLineIndex = lineIndex;
    }

    @Nullable
    public List<Token> getCurrentLineTokens() {
        return currentLineTokens == null ? null : Collections.unmodifiableList(currentLineTokens);
    }

    public void setCurrentLineTokens(@Nullable final List<Token> tokens) {
        currentLineTokens = tokens == null ? null : new LinkedList<>(tokens);
    }

    public void recalculateVisibleLines() {
        final int height = getHeight();

        // get line height
        final int lineHeight;
        if (fontMetrics == null) {
            lineHeight = getDefaultLineHeight(); // default height might be wrong, take it only when needed
        } else {
            lineHeight = fontMetrics.getHeight();
        }

        visibleLines = height / lineHeight;
        textArea.updateScrollBars();
    }

    public int getVisibleLines() {
        return visibleLines;
    }

    public int getFirstLine() {
        return firstLine;
    }

    public boolean setFirstLine(final int firstLine) {
        if (firstLine == this.firstLine) {
            return false;
        }

        this.firstLine = firstLine;
        return true;
    }

    public int lineToY(final int line) {
        return (line - firstLine) * fontMetrics.getHeight() - (fontMetrics.getLeading() + fontMetrics.getMaxDescent());
    }

    public int getHorizontalOffset() {
        return horizontalOffset;
    }

    public boolean setHorizontalOffset(final int horizontalOffset) {
        if (this.horizontalOffset == horizontalOffset) {
            return false;
        }

        this.horizontalOffset = horizontalOffset;
        return true;
    }

    public int offsetToX2(final int line, final int offset) {
        final TokenMarker tokenMarker = selection.getTokenMarker();

        /* Use painter's cached info for speed */
        FontMetrics fm = fontMetrics;

        selection.getLineText(line, lineSegment);

        final int segmentOffset = lineSegment.offset;
        int x = horizontalOffset;

        /* If syntax coloring is disabled, do simple translation */
        if (tokenMarker == null) {
            lineSegment.count = offset;
            return x + Utilities.getTabbedTextWidth(lineSegment, fm, x, this, 0);
        } else {
            /* If syntax coloring is enabled, we have to do this because
             * tokens can vary in width */
            final List<Token> tokens;
            if (currentLineIndex == line && getCurrentLineTokens() != null) {
                tokens = getCurrentLineTokens();
            } else {
                currentLineIndex = line;
                tokens = tokenMarker.markTokens(lineSegment, line);
                setCurrentLineTokens(tokens);
            }

            final Font defaultFont = getFont();
            for (final Token token : tokens) {
                final byte id = token.getId();
                if (id == Token.NULL) {
                    fm = fontMetrics;
                } else {
                    fm = styles.getStyle(id).getFontMetrics(defaultFont, getGraphics());
                }

                final int length = token.getLength();

                if (offset + segmentOffset < lineSegment.offset + length) {
                    lineSegment.count = offset - (lineSegment.offset - segmentOffset);
                    return x + Utilities.getTabbedTextWidth(lineSegment, fm, x, this, 0);
                }
                lineSegment.count = length;
                x += Utilities.getTabbedTextWidth(lineSegment, fm, x, this, 0);
                lineSegment.offset += length;
            }
            return x;
        }
    }

    public int offsetToX(final int line, final int offset) {
        // don't use cached tokens
        setCurrentLineTokens(null);
        return offsetToX2(line, offset);
    }

    public int yToLine(final int y) {
        final FontMetrics fm = fontMetrics;
        final int height = fm.getHeight();
        return Math.max(0, Math.min(selection.getLineCount() - 1, y / height + firstLine));
    }

    public int xToOffset(final int line, final int x) {
        final TokenMarker tokenMarker = selection.getTokenMarker();

        /* Use painter's cached info for speed */
        FontMetrics fm = fontMetrics;

        selection.getLineText(line, lineSegment);

        final char[] segmentArray = lineSegment.array;
        final int segmentOffset = lineSegment.offset;
        final int segmentCount = lineSegment.count;

        int width = horizontalOffset;

        if (tokenMarker == null) {
            for (int i = 0; i < segmentCount; i++) {
                final char c = segmentArray[i + segmentOffset];
                final int charWidth;
                if (c == '\t') {
                    charWidth = (int) nextTabStop((float) width, i) - width;
                } else {
                    charWidth = fm.charWidth(c);
                }

                if (blockCaret) {
                    if (x - charWidth <= width) {
                        return i;
                    }
                } else {
                    if (x - charWidth / 2 <= width) {
                        return i;
                    }
                }

                width += charWidth;
            }

            return segmentCount;
        } else {
            final List<Token> tokens;
            if (currentLineIndex == line && getCurrentLineTokens() != null) {
                tokens = getCurrentLineTokens();
            } else {
                currentLineIndex = line;
                tokens = tokenMarker.markTokens(lineSegment, line);
                setCurrentLineTokens(tokens);
            }

            int offset = 0;
            final Font defaultFont = getFont();
            for (final Token token : tokens) {
                final byte id = token.getId();
                if (id == Token.NULL) {
                    fm = fontMetrics;
                } else {
                    fm = styles.getStyle(id).getFontMetrics(defaultFont, getGraphics());
                }

                final int length = token.getLength();

                for (int i = 0; i < length; i++) {
                    final char c = segmentArray[segmentOffset + offset + i];
                    final int charWidth;
                    if (c == '\t') {
                        charWidth = (int) nextTabStop((float) width, offset + i) - width;
                    } else {
                        charWidth = fm.charWidth(c);
                    }

                    if (blockCaret) {
                        if (x - charWidth <= width) {
                            return offset + i;
                        }
                    } else {
                        if (x - charWidth / 2 <= width) {
                            return offset + i;
                        }
                    }

                    width += charWidth;
                }

                offset += length;
            }
            return offset;
        }
    }

    public int xyToOffset(final int x, final int y) {
        final int line = yToLine(y);
        final int start = selection.getLineStartOffset(line);
        return start + xToOffset(line, x);
    }

}