TokenMarker.java

Go to the documentation of this file.

/*
 * TokenMarker.java - Generic token marker
 * Copyright (C) 1998, 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.tokenmarker;
 
import java.util.LinkedList;
import java.util.List;
import javax.swing.text.Segment;
import net.sf.gridarta.textedit.textarea.Token;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class TokenMarker {
 
    @NotNull
    private final List<Token> tokens = new LinkedList<>();
 
    @NotNull
    private LineInfo @Nullable [] lineInfo;
 
    private int length;
 
    private int lastLine;
 
    private boolean nextLineRequested;
 
    @NotNull
    public List<Token> markTokens(@NotNull final Segment line, final int lineIndex) {
        if (lineIndex >= length) {
            throw new IllegalArgumentException("Tokenizing invalid line: " + lineIndex);
        }
 
        tokens.clear();
 
        final LineInfo info = lineInfo[lineIndex];
        final LineInfo prev = lineIndex == 0 ? null : lineInfo[lineIndex - 1];
 
        final byte oldToken = info.getToken();
        final byte token = markTokensImpl(prev == null ? Token.NULL : prev.getToken(), line);
 
        info.setToken(token);
 
        /*
         * This is a foul hack. It stops nextLineRequested
         * from being cleared if the same line is marked twice.
         *
         * Why is this necessary? It's all JEditTextArea's fault.
         * When something is inserted into the text, firing a
         * document event, the insertUpdate() method shifts the
         * caret (if necessary) by the amount inserted.
         *
         * All caret movement is handled by the select() method,
         * which eventually pipes the new position to scrollTo()
         * and calls repaint().
         *
         * Note that at this point in time, the new line hasn't
         * yet been painted; the caret is moved first.
         *
         * scrollTo() calls offsetToX(), which tokenizes the line
         * unless it is being called on the last line painted
         * (in which case it uses the text area's painter cached
         * token list). What scrollTo() does next is irrelevant.
         *
         * After scrollTo() has done it's job, repaint() is
         * called, and eventually we end up in paintLine(), whose
         * job is to paint the changed line. It, too, calls
         * markTokens().
         *
         * The problem was that if the line started a multi.line
         * token, the first markTokens() (done in offsetToX())
         * would set nextLineRequested (because the line end
         * token had changed) but the second would clear it
         * (because the line was the same that time) and therefore
         * paintLine() would never know that it needed to repaint
         * subsequent lines.
         *
         * This bug took me ages to track down, that's why I wrote
         * all the relevant info down so that others wouldn't
         * duplicate it.
         */
        if (!(lastLine == lineIndex && nextLineRequested)) {
            nextLineRequested = oldToken != token;
        }
 
        lastLine = lineIndex;
 
        return tokens;
    }
 
    protected abstract byte markTokensImpl(byte token, @NotNull Segment line);
 
    public void insertLines(final int index, final int lines) {
        if (lines <= 0) {
            return;
        }
        length += lines;
        ensureCapacity(length);
        final int len = index + lines;
        System.arraycopy(lineInfo, index, lineInfo, len, lineInfo.length - len);
 
        for (int i = index + lines - 1; i >= index; i--) {
            lineInfo[i] = new LineInfo();
        }
    }
 
    public void deleteLines(final int index, final int lines) {
        if (lines <= 0) {
            return;
        }
        length -= lines;
        final int len = index + lines;
        System.arraycopy(lineInfo, len, lineInfo, index, lineInfo.length - len);
    }
 
    public boolean isNextLineRequested() {
        return nextLineRequested;
    }
 
    protected TokenMarker() {
        lastLine = -1;
    }
 
    private void ensureCapacity(final int index) {
        if (lineInfo == null) {
            lineInfo = new LineInfo[index + 1];
        } else if (lineInfo.length <= index) {
            final LineInfo[] lineInfoN = new LineInfo[(index + 1) * 2];
            System.arraycopy(lineInfo, 0, lineInfoN, 0, lineInfo.length);
            lineInfo = lineInfoN;
        }
    }
 
    protected void addToken(final int length, final byte id) {
        if (id >= Token.INTERNAL_FIRST && id <= Token.INTERNAL_LAST) {
            throw new InternalError("Invalid id: " + id);
        }
 
        if (length == 0) {
            return;
        }
 
        tokens.add(new Token(length, id));
    }
 
}