Buffer.java

Go to the documentation of this file.

/*
 * This file is part of JXClient, the Fullscreen Java Crossfire Client.
 *
 * JXClient is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * JXClient is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with JXClient; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Copyright (C) 2005-2008 Yann Chachkoff
 * Copyright (C) 2006-2017,2019-2023 Andreas Kirschbaum
 * Copyright (C) 2010-2012,2014-2018,2020-2023 Nicolas Weeger
 */
 
package com.realtime.crossfire.jxclient.gui.log;
 
import com.realtime.crossfire.jxclient.util.EventListenerList2;
import java.awt.Color;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CopyOnWriteArrayList;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class Buffer {
 
    @NotNull
    private final EventListenerList2<BufferListener> listeners = new EventListenerList2<>();
 
    private final int maxLines;
 
    private int renderWidth;
 
    @NotNull
    private final List<Line> lines = new CopyOnWriteArrayList<>();
 
    private int totalHeight;
 
    @NotNull
    private final Object sync = new Object();
 
    private int lastCount;
 
    private int lastType = -1;
 
    private int lastSubtype = -1;
 
    @Nullable
    private Color lastColor;
 
    @NotNull
    private String lastText = "";
 
    private boolean showSentCommands;
 
    private boolean showTimestamps;
 
    protected Buffer(final int maxLines, final int renderWidth) {
        if (maxLines < 2) {
            throw new IllegalArgumentException("maxLines="+maxLines);
        }
 
        this.maxLines = maxLines;
        this.renderWidth = renderWidth;
    }
 
    public void setRenderWidth(final int renderWidth) {
        synchronized (sync) {
            if (this.renderWidth == renderWidth) {
                return;
            }
 
            this.renderWidth = renderWidth;
            layoutLines();
        }
    }
 
    public void setShowSentCommands(final boolean showSentCommands) {
        synchronized (sync) {
            if (this.showSentCommands == showSentCommands) {
                return;
            }
 
            this.showSentCommands = showSentCommands;
            layoutLines();
        }
    }
 
    public void setShowTimestamps(final boolean showTimestamps) {
        synchronized (sync) {
            if (this.showTimestamps == showTimestamps) {
                return;
            }
 
            this.showTimestamps = showTimestamps;
            layoutLines();
        }
    }
 
    public void clear() {
        final List<Line> removedLines;
        synchronized (sync) {
            removedLines = new ArrayList<>(lines);
            totalHeight = 0;
            lines.clear();
        }
        if (!removedLines.isEmpty()) {
            for (BufferListener listener : listeners) {
                listener.linesRemoved(removedLines);
            }
        }
        lastCount = 0;
        lastText = "";
        lastType = -1;
        lastSubtype = -1;
        lastColor = null;
    }
 
    public void addLine(@NotNull final Line line) {
        synchronized (sync) {
            final int position = lines.isEmpty() ? 0 : lines.get(lines.size()-1).getEndPosition();
            totalHeight += line.calculateHeight(position, renderWidth, showSentCommands, showTimestamps);
            lines.add(line);
        }
 
        for (BufferListener listener : listeners) {
            listener.lineAdded();
        }
    }
 
    public void replaceLine(@NotNull final Line line) {
        synchronized (sync) {
            final int position = lines.size() < 2 ? 0 : lines.get(lines.size()-2).getEndPosition();
            totalHeight += line.calculateHeight(position, renderWidth, showSentCommands, showTimestamps);
            final int lastIndex = lines.size()-1;
            totalHeight -= lines.get(lastIndex).getHeight();
            lines.set(lastIndex, line);
        }
 
        for (BufferListener listener : listeners) {
            listener.lineReplaced();
        }
    }
 
    public void prune() {
        final List<Line> removedLines;
        synchronized (sync) {
            if (lines.size() <= maxLines) {
                return;
            }
 
            removedLines = new ArrayList<>(lines.size()-maxLines);
            int positionsRemoved = 0;
            while (lines.size() > maxLines) {
                final Line line = lines.remove(0);
                removedLines.add(line);
                totalHeight -= line.getHeight();
                positionsRemoved -= line.getEndPosition()-line.getStartPosition();
            }
            for (final Line line : lines) {
                line.updatePosition(positionsRemoved);
            }
        }
        if (!removedLines.isEmpty()) {
            for (BufferListener listener : listeners) {
                listener.linesRemoved(removedLines);
            }
        }
    }
 
    @NotNull
    public Line getLine(final int line) {
        synchronized (sync) {
            return lines.get(line);
        }
    }
 
    public int getTotalHeight() {
        synchronized (sync) {
            return Math.max(totalHeight, 1);
        }
    }
 
    @NotNull
    public Iterable<Line> lines(final int line) {
        assert Thread.holdsLock(sync);
        try {
            return Collections.unmodifiableList(lines).subList(line, lines.size());
        } catch (final IndexOutOfBoundsException ignored) {
            return Collections.emptyList();
        }
    }
 
    public int size() {
        synchronized (sync) {
            return lines.size();
        }
    }
 
    public void addBufferListener(@NotNull final BufferListener listener) {
        listeners.add(listener);
    }
 
    public void removeBufferListener(@NotNull final BufferListener listener) {
        listeners.remove(listener);
    }
 
    @NotNull
    public Object getSyncObject() {
        return sync;
    }
 
    public boolean mergeLines(@NotNull final String text, final int type, final int subtype, @Nullable final Color color) {
        if (!text.isEmpty() && lastCount > 0 && text.equals(lastText) && lastType == type && lastSubtype == subtype && Objects.equals(lastColor, color)) {
            lastCount++;
            return true;
        }
 
        lastCount = 1;
        lastText = text;
        lastType = type;
        lastSubtype = subtype;
        lastColor = color;
        return false;
 
    }
 
    public int getLastCount() {
        return lastCount;
    }
 
    private void layoutLines() {
        synchronized (sync) {
            totalHeight = 0;
            int position = 0;
            for (Line line : lines) {
                totalHeight += line.calculateHeight(position, renderWidth, showSentCommands, showTimestamps);
                position = line.getEndPosition();
            }
        }
    }
 
    public void addTextSegment(@NotNull final Line line, @NotNull final String text, final boolean bold, final boolean italic, final boolean underline, @NotNull final FontID fontID, @NotNull final Color color, @NotNull final Color selectionColor) {
        line.addTextSegment(newTextSegment(text, bold, italic, underline, fontID, color, selectionColor));
    }
 
    @NotNull
    protected abstract TextSegment newTextSegment(@NotNull final String text, final boolean bold, final boolean italic, final boolean underline, @NotNull final FontID fontID, @NotNull final Color color, @NotNull final Color selectionColor);
 
    public int coordinateToPosition(final int x, final int y) {
        int yLine = 0;
        for (final Line line : lines) {
            for (final TextSegment segment : line.segments()) {
                if (y <= yLine+segment.getY()) {
                    if (y <= yLine+segment.getY()-segment.getHeight()) {
                        return segment.getPosition();
                    }
                    if (x <= segment.getX()+segment.getWidth()) {
                        final int length = segment.getText().length();
                        for (int i = 0; i < length; i++) {
                            final int width = getSegmentWidth(segment, i+1);
                            if (x < segment.getX()+width) {
                                return segment.getPosition()+i;
                            }
                        }
                        return segment.getPosition()+length;
                    }
                }
            }
 
            yLine += line.getHeight();
        }
        return lines.isEmpty() ? 0 : lines.get(lines.size()-1).getEndPosition();
    }
 
    protected abstract int getSegmentWidth(@NotNull final TextSegment segment, final int characters);
 
    @NotNull
    public String getText(final int beginSelection, final int endSelection) {
        if (beginSelection >= endSelection) {
            return "";
        }
 
        final boolean showSentCommands;
        synchronized (sync) {
            showSentCommands = this.showSentCommands;
        }
        int i = 0;
        while (i < lines.size()) {
            final Line line = lines.get(i);
            if (line.isVisible(showSentCommands) && beginSelection < line.getEndPosition()) {
                break;
            }
            i++;
        }
        final StringBuilder sb = new StringBuilder();
        while (i < lines.size()) {
            final Line line = lines.get(i);
            if (line.getStartPosition() >= endSelection) {
                break;
            }
            if (line.isVisible(showSentCommands)) {
                if (!sb.isEmpty()) {
                    sb.append("\n");
                }
                line.appendSelection(sb, beginSelection, endSelection);
            }
            i++;
        }
        return sb.toString();
    }
 
}