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-2011 Andreas Kirschbaum.
 */

package com.realtime.crossfire.jxclient.gui.log;

import com.realtime.crossfire.jxclient.util.EventListenerList2;
import java.awt.Color;
import java.awt.font.FontRenderContext;
import java.awt.geom.RectangularShape;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class Buffer {

    public static final int MAX_LINES = 250;

    public static final int MIN_LINE_HEIGHT = 8;

    @NotNull
    private final EventListenerList2<BufferListener> listeners = new EventListenerList2<>();

    @NotNull
    private final Fonts fonts;

    @NotNull
    private final FontRenderContext context;

    private int renderWidth;

    @NotNull
    private final List<Line> lines = new CopyOnWriteArrayList<>();

    private int totalHeight;

    @NotNull
    private final Object sync = new Object();

    private int lastCount;

    @Nullable
    private Color lastColor;

    @NotNull
    private String lastText = "";

    public Buffer(@NotNull final Fonts fonts, @NotNull final FontRenderContext context, final int renderWidth) {
        this.fonts = fonts;
        this.context = context;
        this.renderWidth = renderWidth;
    }

    public void setRenderWidth(final int renderWidth) {
        if (this.renderWidth == renderWidth) {
            return;
        }

        this.renderWidth = renderWidth;

        synchronized (sync) {
            totalHeight = 0;
            for (final Line line : lines) {
                final int height = calculateHeight(line);
                line.setHeight(height);
                totalHeight += height;
            }
        }
    }

    public void clear() {
        final List<Line> removedLines;
        synchronized (sync) {
            removedLines = new ArrayList<>(lines);
            totalHeight = 0;
            lines.clear();
        }
        for (final BufferListener listener : listeners) {
            listener.linesRemoved(removedLines);
        }
        lastCount = 0;
        lastText = "";
        lastColor = null;
    }

    public void addLine(@NotNull final Line line) {
        final int height = calculateHeight(line);
        line.setHeight(height);
        synchronized (sync) {
            totalHeight += height;
            lines.add(line);
        }

        for (final BufferListener listener : listeners) {
            listener.lineAdded();
        }
    }

    public void replaceLine(@NotNull final Line line) {
        final int height = calculateHeight(line);
        line.setHeight(height);
        synchronized (sync) {
            totalHeight += height;
            final int lastIndex = lines.size()-1;
            totalHeight -= lines.get(lastIndex).getHeight();
            lines.set(lastIndex, line);
        }

        for (final BufferListener listener : listeners) {
            listener.lineReplaced();
        }
    }

    public void prune() {
        final List<Line> removedLines;
        synchronized (sync) {
            if (lines.size() <= MAX_LINES) {
                return;
            }

            removedLines = new ArrayList<>(lines.size()-MAX_LINES);
            while (lines.size() > MAX_LINES) {
                final Line line = lines.remove(0);
                removedLines.add(line);
                totalHeight -= line.getHeight();
            }
        }
        for (final 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 Iterator<Line> iterator() {
        assert Thread.holdsLock(sync);
        return Collections.unmodifiableList(lines).iterator();
    }

    @NotNull
    public Iterator<Line> listIterator(final int line) {
        assert Thread.holdsLock(sync);
        return Collections.unmodifiableList(lines).listIterator(line);
    }

    public int size() {
        synchronized (sync) {
            return lines.size();
        }
    }

    private int calculateHeight(@NotNull final Line line) {
        int height = 0;
        int x = 0;
        int minY = 0;
        int maxY = 0;
        int beginIndex = 0;
        int i = 0;
        for (final Segment segment : line) {
            final RectangularShape rectangle = segment.getSize(fonts, context);
            final int width = (int)Math.round(rectangle.getWidth());
            if (x != 0 && x+width > renderWidth) {
                line.updateAttributes(beginIndex, i, height-minY, fonts, context);

                height += maxY-minY;
                x = 0;
                minY = 0;
                maxY = 0;
                beginIndex = i;
            }

            segment.setX(x);
            segment.setY(height);
            segment.setWidth(width);

            x += width;
            minY = (int)Math.min(minY, Math.round(rectangle.getY()));
            maxY = (int)Math.max(maxY, Math.round(rectangle.getY()+rectangle.getHeight()));

            i++;
        }

        line.updateAttributes(beginIndex, i, height-minY, fonts, context);
        height += maxY-minY;

        return Math.max(MIN_LINE_HEIGHT, height);
    }

    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, @Nullable final Color color) {
        if (lastCount > 0 && text.equals(lastText) && (lastColor == null ? color == null : lastColor.equals(color))) {
            lastCount++;
            return true;
        }

        lastCount = 1;
        lastText = text;
        lastColor = color;
        return false;

    }

    public int getLastCount() {
        return lastCount;
    }

}