TextAreaSelection.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 The Gridarta Developers.
 *
 * This program 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.
 *
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

package net.sf.gridarta.textedit.textarea;

import javax.swing.text.BadLocationException;
import javax.swing.text.Element;
import javax.swing.text.Segment;
import net.sf.gridarta.textedit.textarea.tokenmarker.TokenMarker;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class TextAreaSelection {

    @NotNull
    private final SyntaxDocument document;

    private int selectionStart;

    private int selectionStartLine;

    private int selectionEnd;

    private int selectionEndLine;

    private boolean biasLeft;

    private boolean rectangleSelect;

    public TextAreaSelection(@NotNull final SyntaxDocument document) {
        this.document = document;
    }

    public int getSelectionStart() {
        return selectionStart;
    }

    public int getSelectionStartLine() {
        return selectionStartLine;
    }

    public int getSelectionEnd() {
        return selectionEnd;
    }

    public int getSelectionEndLine() {
        return selectionEndLine;
    }

    public boolean getBiasLeft() {
        return biasLeft;
    }

    public int getCaretPosition() {
        return biasLeft ? selectionStart : selectionEnd;
    }

    public int getCaretLine() {
        return biasLeft ? selectionStartLine : selectionEndLine;
    }

    public int getMarkPosition() {
        return biasLeft ? selectionEnd : selectionStart;
    }

    public void setSelection(final int newStart, final int newEnd, final int newStartLine, final int newEndLine, final boolean newBias) {
        selectionStart = newStart;
        selectionEnd = newEnd;
        selectionStartLine = newStartLine;
        selectionEndLine = newEndLine;
        biasLeft = newBias;
    }

    @Nullable
    public String getSelectedText() {
        if (selectionStart == selectionEnd) {
            return null;
        }

        if (rectangleSelect) {
            // Return each row of the selection on a new line

            final Element map = document.getDefaultRootElement();

            int start = selectionStart - map.getElement(selectionStartLine).getStartOffset();
            int end = selectionEnd - map.getElement(selectionEndLine).getStartOffset();

            // Certain rectangles satisfy this condition...
            if (end < start) {
                final int tmp = end;
                end = start;
                start = tmp;
            }

            final StringBuilder buf = new StringBuilder();
            final Segment seg = new Segment();

            for (int i = selectionStartLine; i <= selectionEndLine; i++) {
                final Element lineElement = map.getElement(i);
                int lineStart = lineElement.getStartOffset();
                final int lineEnd = lineElement.getEndOffset() - 1;

                lineStart = Math.min(lineStart + start, lineEnd);
                final int lineLen = Math.min(end - start, lineEnd - lineStart);

                getText(lineStart, lineLen, seg);
                buf.append(seg.array, seg.offset, seg.count);

                if (i != selectionEndLine) {
                    buf.append('\n');
                }
            }

            return buf.toString();
        } else {
            return getText(selectionStart, selectionEnd - selectionStart);
        }
    }

    public void disableSelectionIfEmpty() {
        // Disable rectangle select if selection start = selection end
        if (selectionStart == selectionEnd) {
            rectangleSelect = false;
        }
    }

    @Nullable
    public String getText(final int start, final int len) {
        try {
            return document.getText(start, len);
        } catch (final BadLocationException bl) {
            bl.printStackTrace();
            return null;
        }
    }

    public void getText(final int start, final int len, @NotNull final Segment segment) {
        try {
            document.getText(start, len, segment);
        } catch (final BadLocationException bl) {
            bl.printStackTrace();
            segment.offset = 0;
            segment.count = 0;
        }
    }

    public void setSelectedText(@NotNull final String selectedText) {
        SyntaxDocument.beginCompoundEdit();

        try {
            if (rectangleSelect) {
                final Element map = document.getDefaultRootElement();

                int start = selectionStart - map.getElement(selectionStartLine).getStartOffset();
                int end = selectionEnd - map.getElement(selectionEndLine).getStartOffset();

                // Certain rectangles satisfy this condition...
                if (end < start) {
                    final int tmp = end;
                    end = start;
                    start = tmp;
                }

                int lastNewline = 0;
                int currNewline = 0;

                for (int i = selectionStartLine; i <= selectionEndLine; i++) {
                    final Element lineElement = map.getElement(i);
                    final int lineStart = lineElement.getStartOffset();
                    final int lineEnd = lineElement.getEndOffset() - 1;
                    final int rectangleStart = Math.min(lineEnd, lineStart + start);

                    document.remove(rectangleStart, Math.min(lineEnd - rectangleStart, end - start));

                    if (selectedText == null) {
                        continue;
                    }

                    currNewline = selectedText.indexOf('\n', lastNewline);
                    if (currNewline == -1) {
                        currNewline = selectedText.length();
                    }

                    document.insertString(rectangleStart, selectedText.substring(lastNewline, currNewline), null);

                    lastNewline = Math.min(selectedText.length(), currNewline + 1);
                }

                if (selectedText != null && currNewline != selectedText.length()) {
                    final int offset = map.getElement(selectionEndLine).getEndOffset() - 1;
                    document.insertString(offset, "\n", null);
                    document.insertString(offset + 1, selectedText.substring(currNewline + 1), null);
                }
            } else {
                document.remove(selectionStart, selectionEnd - selectionStart);
                if (selectedText != null) {
                    document.insertString(selectionStart, selectedText, null);
                }
            }
        } catch (final BadLocationException bl) {
            bl.printStackTrace();
            throw new InternalError("Cannot replace selection");
        } finally {
            // No matter what happens... stops us from leaving document
            // in a bad state
            SyntaxDocument.endCompoundEdit();
        }
    }

    public boolean isSelectionRectangular() {
        return rectangleSelect;
    }

    public void setSelectionRectangular(final boolean rectangleSelect) {
        this.rectangleSelect = rectangleSelect;
    }

    @NotNull
    public SyntaxDocument getDocument() {
        return document;
    }

    @Nullable
    public TokenMarker getTokenMarker() {
        return document.getTokenMarker();
    }

    public int getDocumentLength() {
        return document.getLength();
    }

    public int getLineCount() {
        return document.getDefaultRootElement().getElementCount();
    }

    public int getLineOfOffset(final int offset) {
        return document.getDefaultRootElement().getElementIndex(offset);
    }

    public int getLineStartOffset(final int line) {
        final Element lineElement = document.getDefaultRootElement().getElement(line);
        if (lineElement == null) {
            return -1;
        } else {
            return lineElement.getStartOffset();
        }
    }

    public int getLineEndOffset(final int line) {
        final Element lineElement = document.getDefaultRootElement().getElement(line);
        if (lineElement == null) {
            return -1;
        } else {
            return lineElement.getEndOffset();
        }
    }

    public int getLineLength(final int line) {
        final Element lineElement = document.getDefaultRootElement().getElement(line);
        if (lineElement == null) {
            return -1;
        } else {
            return lineElement.getEndOffset() - lineElement.getStartOffset() - 1;
        }
    }

    @NotNull
    public String getText() {
        try {
            return document.getText(0, document.getLength());
        } catch (final BadLocationException bl) {
            bl.printStackTrace();
            return "";
        }
    }

    public void setText(@NotNull final String text) {
        try {
            SyntaxDocument.beginCompoundEdit();
            document.remove(0, document.getLength());
            document.insertString(0, text, null);
        } catch (final BadLocationException bl) {
            bl.printStackTrace();
        } finally {
            SyntaxDocument.endCompoundEdit();
        }
    }

    @NotNull
    public CharSequence getLineText(final int lineIndex) {
        final int start = getLineStartOffset(lineIndex);
        return getText(start, getLineEndOffset(lineIndex) - start - 1);
    }

    public void getLineText(final int lineIndex, @NotNull final Segment segment) {
        final int start = getLineStartOffset(lineIndex);
        getText(start, getLineEndOffset(lineIndex) - start - 1, segment);
    }

}