TextAreaPainter.java

Go to the documentation of this file.

/*
 * TextAreaPainter.java - Paints the text area
 * Copyright (C) 1999 Slava Pestov
 * Copyright (C) 2000-2023 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 {
 
    @NotNull
    private static final Category LOG = Logger.getLogger(TextAreaPainter.class);
 
    private static final long serialVersionUID = 1L;
 
    private final FontRenderContext fontRenderContext = new FontRenderContext(null, false, false);
 
    @NotNull
    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;
 
    @NotNull
    private SyntaxStyles styles;
 
    private final int cols;
 
    private final int rows;
 
    @NotNull
    private final Color caretColor;
 
    @NotNull
    private final Color selectionColor;
 
    @NotNull
    private final Color lineHighlightColor;
 
    private final boolean lineHighlight;
 
    @NotNull
    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(new TextLayout("WgGhdJj", font, fontRenderContext).getAdvance() / 7.0);
        defaultLineHeight = Math.round(font.getLineMetrics("WgGhdJj", fontRenderContext).getHeight());
        defaultFont = font;
    }
 
    private 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 (nTabs + 1) * tabSize + horizontalOffset;
    }
 
    @NotNull
    @Override
    public Dimension getPreferredSize() {
        final Dimension dim = super.getPreferredSize();
        return dim == null ? newDimension(cols, rows) : dim;
    }
 
    @NotNull
    @Override
    public Dimension getMinimumSize() {
        final Dimension dim = super.getMinimumSize();
        return dim == null ? newDimension(1, 1) : dim;
    }
 
    @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) {
        currentLineIndex = line;
        final int y = lineToY(line);
 
        final Font font = getFont();
        final Color foreground = getForeground();
        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
    private List<Token> getCurrentLineTokens() {
        return currentLineTokens == null ? null : Collections.unmodifiableList(currentLineTokens);
    }
 
    private 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);
        }
        /* 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();
            fm = id == Token.NULL ? fontMetrics : 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(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;
        }
        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();
            fm = id == Token.NULL ? fontMetrics : 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(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);
    }
 
}