Dépôt officiel du code source de l'ERP OpenConcerto

package org.jedit;

/*

 * JEditTextArea.java - jEdit's text component Copyright (C) 1999 Slava Pestov

 *

 * 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.

 */

import java.awt.AWTEvent;

import java.awt.Component;

import java.awt.Container;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.FontMetrics;

import java.awt.Insets;

import java.awt.LayoutManager;

import java.awt.datatransfer.Clipboard;

import java.awt.datatransfer.DataFlavor;

import java.awt.datatransfer.StringSelection;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.AdjustmentEvent;

import java.awt.event.AdjustmentListener;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.awt.event.InputEvent;

import java.awt.event.KeyEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.awt.event.MouseMotionListener;

import java.util.Enumeration;

import java.util.Vector;

import javax.swing.Action;

import javax.swing.JPopupMenu;

import javax.swing.JScrollBar;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

import javax.swing.event.CaretEvent;

import javax.swing.event.CaretListener;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.event.EventListenerList;

import javax.swing.text.BadLocationException;

import javax.swing.text.Element;

import javax.swing.text.JTextComponent;

import javax.swing.text.Segment;

import javax.swing.text.TextAction;

import javax.swing.text.Utilities;

import javax.swing.undo.AbstractUndoableEdit;

import javax.swing.undo.CannotRedoException;

import javax.swing.undo.CannotUndoException;

import javax.swing.undo.UndoableEdit;

/**

 * jEdit's text area component. It is more suited for editing program source code than JEditorPane,

 * because it drops the unnecessary features (images, variable-width lines, and so on) and adds a

 * whole bunch of useful goodies such as:

 * <ul>

 * <li>More flexible key binding scheme

 * <li>Supports macro recorders

 * <li>Rectangular selection

 * <li>Bracket highlighting

 * <li>Syntax highlighting

 * <li>Command repetition

 * <li>Block caret can be enabled

 * </ul>

 * It is also faster and doesn't have as many problems. It can be used in other applications; the

 * only other part of jEdit it depends on is the syntax package.

 * <p>

 *

 * To use it in your app, treat it like any other component, for example:

 *

 * <pre>

 * JEditTextArea ta = new JEditTextArea();

 * ta.setTokenMarker(new JavaTokenMarker());

 * ta.setText("public class Test {\n" + "    public static void main(String[] args) {\n" + "        System.out.println(\"Hello World\");\n" + "    }\n" + "}");

 * </pre>

 *

 * @author Slava Pestov

 * @version $Id: JEditTextArea.java,v 1.36 1999/12/13 03:40:30 sp Exp $

 */

public class JEditTextArea extends JTextComponent {

    /**

     * Adding components with this name to the text area will place them left of the horizontal

     * scroll bar. In jEdit, the status bar is added this way.

     */

    public static String LEFT_OF_SCROLLBAR = "los";

    /**

     * Creates a new JEditTextArea with the default settings.

     */

    public JEditTextArea() {

        this(new TextAreaDefaults().getDefaults());

    }

    /**

     * Creates a new JEditTextArea with the specified settings.

     *

     * @param defaults The default settings

     */

    public JEditTextArea(TextAreaDefaults defaults) {

        // Enable the necessary events

        enableEvents(AWTEvent.KEY_EVENT_MASK);

        // Initialize some misc. stuff

        this.painter = new TextAreaPainter(this, defaults);

        this.documentHandler = new DocumentHandler();

        this.listenerList = new EventListenerList();

        this.caretEvent = new MutableCaretEvent();

        this.lineSegment = new Segment();

        this.bracketLine = this.bracketPosition = -1;

        this.blink = true;

        // Initialize the GUI

        setLayout(new ScrollLayout());

        add(CENTER, this.painter);

        add(RIGHT, this.vertical = new JScrollBar(JScrollBar.VERTICAL));

        add(BOTTOM, this.horizontal = new JScrollBar(JScrollBar.HORIZONTAL));

        // Add some event listeners

        this.vertical.addAdjustmentListener(new AdjustHandler());

        this.horizontal.addAdjustmentListener(new AdjustHandler());

        this.painter.addComponentListener(new ComponentHandler());

        this.painter.addMouseListener(new MouseHandler());

        this.painter.addMouseMotionListener(new DragHandler());

        addFocusListener(new FocusHandler());

        // Load the defaults

        setInputHandler(defaults.inputHandler);

        setDocument(defaults.document);

        this.editable = defaults.editable;

        this.caretVisible = defaults.caretVisible;

        this.caretBlinks = defaults.caretBlinks;

        this.electricScroll = defaults.electricScroll;

        this.popup = defaults.popup;

        // We don't seem to get the initial focus event?

        focusedComponent = this;

    }

    /**

     * Returns if this component can be traversed by pressing the Tab key. This returns false.

     */

    public final boolean isManagingFocus() {

        return true;

    }

    /**

     * Returns the object responsible for painting this text area.

     */

    public final TextAreaPainter getPainter() {

        return this.painter;

    }

    /**

     * Returns the input handler.

     */

    public final InputHandler getInputHandler() {

        return this.inputHandler;

    }

    /**

     * Sets the input handler.

     *

     * @param inputHandler The new input handler

     */

    public void setInputHandler(InputHandler inputHandler) {

        this.inputHandler = inputHandler;

    }

    /**

     * Returns true if the caret is blinking, false otherwise.

     */

    public final boolean isCaretBlinkEnabled() {

        return this.caretBlinks;

    }

    /**

     * Toggles caret blinking.

     *

     * @param caretBlinks True if the caret should blink, false otherwise

     */

    public void setCaretBlinkEnabled(boolean caretBlinks) {

        this.caretBlinks = caretBlinks;

        if (!caretBlinks)

            this.blink = false;

        this.painter.invalidateSelectedLines();

    }

    /**

     * Returns true if the caret is visible, false otherwise.

     */

    public final boolean isCaretVisible() {

        return (!this.caretBlinks || this.blink) && this.caretVisible;

    }

    /**

     * Sets if the caret should be visible.

     *

     * @param caretVisible True if the caret should be visible, false otherwise

     */

    public void setCaretVisible(boolean caretVisible) {

        this.caretVisible = caretVisible;

        this.blink = true;

        this.painter.invalidateSelectedLines();

    }

    /**

     * Blinks the caret.

     */

    public final void blinkCaret() {

        if (this.caretBlinks) {

            this.blink = !this.blink;

            this.painter.invalidateSelectedLines();

        } else

            this.blink = true;

    }

    /**

     * Returns the number of lines from the top and button of the text area that are always visible.

     */

    public final int getElectricScroll() {

        return this.electricScroll;

    }

    /**

     * Sets the number of lines from the top and bottom of the text area that are always visible

     *

     * @param electricScroll The number of lines always visible from the top or bottom

     */

    public final void setElectricScroll(int electricScroll) {

        this.electricScroll = electricScroll;

    }

    /**

     * Updates the state of the scroll bars. This should be called if the number of lines in the

     * document changes, or when the size of the text are changes.

     */

    public void updateScrollBars() {

        if (this.vertical != null && this.visibleLines != 0) {

            this.vertical.setValues(this.firstLine, this.visibleLines, 0, getLineCount());

            this.vertical.setUnitIncrement(2);

            this.vertical.setBlockIncrement(this.visibleLines);

        }

        int width = this.painter.getWidth();

        if (this.horizontal != null && width != 0) {

            this.horizontal.setValues(-this.horizontalOffset, width, 0, width * 5);

            this.horizontal.setUnitIncrement(this.painter.getFontMetrics().charWidth('w'));

            this.horizontal.setBlockIncrement(width / 2);

        }

    }

    /**

     * Returns the line displayed at the text area's origin.

     */

    public final int getFirstLine() {

        return this.firstLine;

    }

    /**

     * Sets the line displayed at the text area's origin without updating the scroll bars.

     */

    public void setFirstLine(int firstLine) {

        if (firstLine == this.firstLine)

            return;

        this.firstLine = firstLine;

        if (firstLine != this.vertical.getValue())

            updateScrollBars();

        this.painter.repaint();

    }

    /**

     * Returns the number of lines visible in this text area.

     */

    public final int getVisibleLines() {

        return this.visibleLines;

    }

    /**

     * Recalculates the number of visible lines. This should not be called directly.

     */

    public final void recalculateVisibleLines() {

        if (this.painter == null)

            return;

        int height = this.painter.getHeight();

        int lineHeight = this.painter.getFontMetrics().getHeight();

        this.visibleLines = height / lineHeight;

        updateScrollBars();

    }

    /**

     * Returns the horizontal offset of drawn lines.

     */

    public final int getHorizontalOffset() {

        return this.horizontalOffset;

    }

    /**

     * Sets the horizontal offset of drawn lines. This can be used to implement horizontal

     * scrolling.

     *

     * @param horizontalOffset offset The new horizontal offset

     */

    public void setHorizontalOffset(int horizontalOffset) {

        if (horizontalOffset == this.horizontalOffset)

            return;

        this.horizontalOffset = horizontalOffset;

        if (horizontalOffset != this.horizontal.getValue())

            updateScrollBars();

        this.painter.repaint();

    }

    /**

     * A fast way of changing both the first line and horizontal offset.

     *

     * @param firstLine The new first line

     * @param horizontalOffset The new horizontal offset

     * @return True if any of the values were changed, false otherwise

     */

    public boolean setOrigin(int firstLine, int horizontalOffset) {

        boolean changed = false;

        if (horizontalOffset != this.horizontalOffset) {

            this.horizontalOffset = horizontalOffset;

            changed = true;

        }

        if (firstLine != this.firstLine) {

            this.firstLine = firstLine;

            changed = true;

        }

        if (changed) {

            updateScrollBars();

            this.painter.repaint();

        }

        return changed;

    }

    /**

     * Ensures that the caret is visible by scrolling the text area if necessary.

     *

     * @return True if scrolling was actually performed, false if the caret was already visible

     */

    public boolean scrollToCaret() {

        int line = getCaretLine();

        int lineStart = getLineStartOffset(line);

        int offset = Math.max(0, Math.min(getLineLength(line) - 1, getCaretPosition() - lineStart));

        return scrollTo(line, offset);

    }

    /**

     * Ensures that the specified line and offset is visible by scrolling the text area if

     * necessary.

     *

     * @param line The line to scroll to

     * @param offset The offset in the line to scroll to

     * @return True if scrolling was actually performed, false if the line and offset was already

     *         visible

     */

    public boolean scrollTo(int line, int offset) {

        // visibleLines == 0 before the component is realized

        // we can't do any proper scrolling then, so we have

        // this hack...

        if (this.visibleLines == 0) {

            setFirstLine(Math.max(0, line - this.electricScroll));

            return true;

        }

        int newFirstLine = this.firstLine;

        int newHorizontalOffset = this.horizontalOffset;

        if (line < this.firstLine + this.electricScroll) {

            newFirstLine = Math.max(0, line - this.electricScroll);

        } else if (line + this.electricScroll >= this.firstLine + this.visibleLines) {

            newFirstLine = (line - this.visibleLines) + this.electricScroll + 1;

            if (newFirstLine + this.visibleLines >= getLineCount())

                newFirstLine = getLineCount() - this.visibleLines;

            if (newFirstLine < 0)

                newFirstLine = 0;

        }

        int x = _offsetToX(line, offset);

        int width = this.painter.getFontMetrics().charWidth('w');

        if (x < 0) {

            newHorizontalOffset = Math.min(0, this.horizontalOffset - x + width + 5);

        } else if (x + width >= this.painter.getWidth()) {

            newHorizontalOffset = this.horizontalOffset + (this.painter.getWidth() - x) - width - 5;

        }

        return setOrigin(newFirstLine, newHorizontalOffset);

    }

    /**

     * Converts a line index to a y co-ordinate.

     *

     * @param line The line

     */

    public int lineToY(int line) {

        FontMetrics fm = this.painter.getFontMetrics();

        return (line - this.firstLine) * fm.getHeight() - (fm.getLeading() + fm.getMaxDescent());

    }

    /**

     * Converts a y co-ordinate to a line index.

     *

     * @param y The y co-ordinate

     */

    public int yToLine(int y) {

        FontMetrics fm = this.painter.getFontMetrics();

        int height = fm.getHeight();

        return Math.max(0, Math.min(getLineCount() - 1, y / height + this.firstLine));

    }

    /**

     * Converts an offset in a line into an x co-ordinate. This is a slow version that can be used

     * any time.

     *

     * @param line The line

     * @param offset The offset, from the start of the line

     */

    public final int offsetToX(int line, int offset) {

        // don't use cached tokens

        this.painter.currentLineTokens = null;

        return _offsetToX(line, offset);

    }

    /**

     * Converts an offset in a line into an x co-ordinate. This is a fast version that should only

     * be used if no changes were made to the text since the last repaint.

     *

     * @param line The line

     * @param offset The offset, from the start of the line

     */

    public int _offsetToX(int line, int offset) {

        TokenMarker tokenMarker = getTokenMarker();

        /* Use painter's cached info for speed */

        FontMetrics fm = this.painter.getFontMetrics();

        getLineText(line, this.lineSegment);

        int segmentOffset = this.lineSegment.offset;

        int x = this.horizontalOffset;

        /* If syntax coloring is disabled, do simple translation */

        if (tokenMarker == null) {

            this.lineSegment.count = offset;

            return x + Utilities.getTabbedTextWidth(this.lineSegment, fm, x, this.painter, 0);

        }

        Token tokens;

        if (this.painter.currentLineIndex == line && this.painter.currentLineTokens != null)

            tokens = this.painter.currentLineTokens;

        else {

            this.painter.currentLineIndex = line;

            tokens = this.painter.currentLineTokens = tokenMarker.markTokens(this.lineSegment, line);

        }

        // Toolkit toolkit = this.painter.getToolkit();

        Font defaultFont = this.painter.getFont();

        SyntaxStyle[] styles = this.painter.getStyles();

        for (;;) {

            byte id = tokens.id;

            if (id == Token.END) {

                return x;

            }

            if (id == Token.NULL)

                fm = this.painter.getFontMetrics();

            else

                fm = styles[id].getFontMetrics(defaultFont);

            int length = tokens.length;

            if (offset + segmentOffset < this.lineSegment.offset + length) {

                this.lineSegment.count = offset - (this.lineSegment.offset - segmentOffset);

                return x + Utilities.getTabbedTextWidth(this.lineSegment, fm, x, this.painter, 0);

            }

            this.lineSegment.count = length;

            x += Utilities.getTabbedTextWidth(this.lineSegment, fm, x, this.painter, 0);

            this.lineSegment.offset += length;

            tokens = tokens.next;

        }

    }

    /**

     * Converts an x co-ordinate to an offset within a line.

     *

     * @param line The line

     * @param x The x co-ordinate

     */

    public int xToOffset(int line, int x) {

        TokenMarker tokenMarker = getTokenMarker();

        /* Use painter's cached info for speed */

        FontMetrics fm = this.painter.getFontMetrics();

        getLineText(line, this.lineSegment);

        char[] segmentArray = this.lineSegment.array;

        int segmentOffset = this.lineSegment.offset;

        int segmentCount = this.lineSegment.count;

        int width = this.horizontalOffset;

        if (tokenMarker == null) {

            for (int i = 0; i < segmentCount; i++) {

                char c = segmentArray[i + segmentOffset];

                int charWidth;

                if (c == '\t')

                    charWidth = (int) this.painter.nextTabStop(width, i) - width;

                else

                    charWidth = fm.charWidth(c);

                if (this.painter.isBlockCaretEnabled()) {

                    if (x - charWidth <= width)

                        return i;

                } else {

                    if (x - charWidth / 2 <= width)

                        return i;

                }

                width += charWidth;

            }

            return segmentCount;

        }

        Token tokens;

        if (this.painter.currentLineIndex == line && this.painter.currentLineTokens != null)

            tokens = this.painter.currentLineTokens;

        else {

            this.painter.currentLineIndex = line;

            tokens = this.painter.currentLineTokens = tokenMarker.markTokens(this.lineSegment, line);

        }

        int offset = 0;

        // Toolkit toolkit = this.painter.getToolkit();

        Font defaultFont = this.painter.getFont();

        SyntaxStyle[] styles = this.painter.getStyles();

        for (;;) {

            byte id = tokens.id;

            if (id == Token.END)

                return offset;

            if (id == Token.NULL)

                fm = this.painter.getFontMetrics();

            else

                fm = styles[id].getFontMetrics(defaultFont);

            int length = tokens.length;

            for (int i = 0; i < length; i++) {

                char c = segmentArray[segmentOffset + offset + i];

                int charWidth;

                if (c == '\t')

                    charWidth = (int) this.painter.nextTabStop(width, offset + i) - width;

                else

                    charWidth = fm.charWidth(c);

                if (this.painter.isBlockCaretEnabled()) {

                    if (x - charWidth <= width)

                        return offset + i;

                } else {

                    if (x - charWidth / 2 <= width)

                        return offset + i;

                }

                width += charWidth;

            }

            offset += length;

            tokens = tokens.next;

        }

    }

    /**

     * Converts a point to an offset, from the start of the text.

     *

     * @param x The x co-ordinate of the point

     * @param y The y co-ordinate of the point

     */

    public int xyToOffset(int x, int y) {

        int line = yToLine(y);

        int start = getLineStartOffset(line);

        return start + xToOffset(line, x);

    }

    /**

     * Returns the document this text area is editing.

     */

    public final SyntaxDocument getDocument() {

        return this.document;

    }

    /**

     * Sets the document this text area is editing.

     *

     * @param document The document

     */

    public void setDocument(SyntaxDocument document) {

        if (this.document == document)

            return;

        if (this.document != null)

            this.document.removeDocumentListener(this.documentHandler);

        this.document = document;

        document.addDocumentListener(this.documentHandler);

        select(0, 0);

        updateScrollBars();

        this.painter.repaint();

    }

    /**

     * Returns the document's token marker. Equivalent to calling

     * <code>getDocument().getTokenMarker()</code>.

     */

    public final TokenMarker getTokenMarker() {

        return this.document.getTokenMarker();

    }

    /**

     * Sets the document's token marker. Equivalent to caling

     * <code>getDocument().setTokenMarker()</code>.

     *

     * @param tokenMarker The token marker

     */

    public final void setTokenMarker(TokenMarker tokenMarker) {

        this.document.setTokenMarker(tokenMarker);

    }

    /**

     * Returns the length of the document. Equivalent to calling

     * <code>getDocument().getLength()</code>.

     */

    public final int getDocumentLength() {

        return this.document.getLength();

    }

    /**

     * Returns the number of lines in the document.

     */

    public final int getLineCount() {

        return this.document.getDefaultRootElement().getElementCount();

    }

    /**

     * Returns the line containing the specified offset.

     *

     * @param offset The offset

     */

    public final int getLineOfOffset(int offset) {

        return this.document.getDefaultRootElement().getElementIndex(offset);

    }

    /**

     * Returns the start offset of the specified line.

     *

     * @param line The line

     * @return The start offset of the specified line, or -1 if the line is invalid

     */

    public int getLineStartOffset(int line) {

        Element lineElement = this.document.getDefaultRootElement().getElement(line);

        if (lineElement == null)

            return -1;

        return lineElement.getStartOffset();

    }

    /**

     * Returns the end offset of the specified line.

     *

     * @param line The line

     * @return The end offset of the specified line, or -1 if the line is invalid.

     */

    public int getLineEndOffset(int line) {

        Element lineElement = this.document.getDefaultRootElement().getElement(line);

        if (lineElement == null)

            return -1;

        return lineElement.getEndOffset();

    }

    /**

     * Returns the length of the specified line.

     *

     * @param line The line

     */

    public int getLineLength(int line) {

        Element lineElement = this.document.getDefaultRootElement().getElement(line);

        if (lineElement == null)

            return -1;

        return lineElement.getEndOffset() - lineElement.getStartOffset() - 1;

    }

    /**

     * Returns the entire text of this text area.

     */

    public String getText() {

        try {

            return this.document.getText(0, this.document.getLength());

        } catch (BadLocationException bl) {

            bl.printStackTrace();

            return null;

        }

    }

    /**

     * Sets the entire text of this text area.

     */

    public void setText(String text) {

        try {

            this.document.beginCompoundEdit();

            this.document.remove(0, this.document.getLength());

            this.document.insertString(0, text, null);

        } catch (BadLocationException bl) {

            bl.printStackTrace();

        } finally {

            this.document.endCompoundEdit();

        }

    }

    /**

     * Returns the specified substring of the document.

     *

     * @param start The start offset

     * @param len The length of the substring

     * @return The substring, or null if the offsets are invalid

     */

    public final String getText(int start, int len) {

        try {

            return this.document.getText(start, len);

        } catch (BadLocationException bl) {

            bl.printStackTrace();

            return null;

        }

    }

    /**

     * Copies the specified substring of the document into a segment. If the offsets are invalid,

     * the segment will contain a null string.

     *

     * @param start The start offset

     * @param len The length of the substring

     * @param segment The segment

     */

    public final void getText(int start, int len, Segment segment) {

        try {

            this.document.getText(start, len, segment);

        } catch (BadLocationException bl) {

            bl.printStackTrace();

            segment.offset = segment.count = 0;

        }

    }

    /**

     * Returns the text on the specified line.

     *

     * @param lineIndex The line

     * @return The text, or null if the line is invalid

     */

    public final String getLineText(int lineIndex) {

        int start = getLineStartOffset(lineIndex);

        return getText(start, getLineEndOffset(lineIndex) - start - 1);

    }

    /**

     * Copies the text on the specified line into a segment. If the line is invalid, the segment

     * will contain a null string.

     *

     * @param lineIndex The line

     */

    public final void getLineText(int lineIndex, Segment segment) {

        int start = getLineStartOffset(lineIndex);

        getText(start, getLineEndOffset(lineIndex) - start - 1, segment);

    }

    /**

     * Returns the selection start offset.

     */

    public final int getSelectionStart() {

        return this.selectionStart;

    }

    /**

     * Returns the offset where the selection starts on the specified line.

     */

    public int getSelectionStart(int line) {

        if (line == this.selectionStartLine)

            return this.selectionStart;

        else if (this.rectSelect) {

            Element map = this.document.getDefaultRootElement();

            int start = this.selectionStart - map.getElement(this.selectionStartLine).getStartOffset();

            Element lineElement = map.getElement(line);

            int lineStart = lineElement.getStartOffset();

            int lineEnd = lineElement.getEndOffset() - 1;

            return Math.min(lineEnd, lineStart + start);

        } else

            return getLineStartOffset(line);

    }

    /**

     * Returns the selection start line.

     */

    public final int getSelectionStartLine() {

        return this.selectionStartLine;

    }

    /**

     * Sets the selection start. The new selection will be the new selection start and the old

     * selection end.

     *

     * @param selectionStart The selection start

     * @see #select(int,int)

     */

    public final void setSelectionStart(int selectionStart) {

        select(selectionStart, this.selectionEnd);

    }

    /**

     * Returns the selection end offset.

     */

    public final int getSelectionEnd() {

        return this.selectionEnd;

    }

    /**

     * Returns the offset where the selection ends on the specified line.

     */

    public int getSelectionEnd(int line) {

        if (line == this.selectionEndLine)

            return this.selectionEnd;

        else if (this.rectSelect) {

            Element map = this.document.getDefaultRootElement();

            int end = this.selectionEnd - map.getElement(this.selectionEndLine).getStartOffset();

            Element lineElement = map.getElement(line);

            int lineStart = lineElement.getStartOffset();

            int lineEnd = lineElement.getEndOffset() - 1;

            return Math.min(lineEnd, lineStart + end);

        } else

            return getLineEndOffset(line) - 1;

    }

    /**

     * Returns the selection end line.

     */

    public final int getSelectionEndLine() {

        return this.selectionEndLine;

    }

    /**

     * Sets the selection end. The new selection will be the old selection start and the bew

     * selection end.

     *

     * @param selectionEnd The selection end

     * @see #select(int,int)

     */

    public final void setSelectionEnd(int selectionEnd) {

        select(this.selectionStart, selectionEnd);

    }

    /**

     * Returns the caret position. This will either be the selection start or the selection end,

     * depending on which direction the selection was made in.

     */

    public final int getCaretPosition() {

        return (this.biasLeft ? this.selectionStart : this.selectionEnd);

    }

    /**

     * Returns the caret line.

     */

    public final int getCaretLine() {

        return (this.biasLeft ? this.selectionStartLine : this.selectionEndLine);

    }

    /**

     * Returns the mark position. This will be the opposite selection bound to the caret position.

     *

     * @see #getCaretPosition()

     */

    public final int getMarkPosition() {

        return (this.biasLeft ? this.selectionEnd : this.selectionStart);

    }

    /**

     * Returns the mark line.

     */

    public final int getMarkLine() {

        return (this.biasLeft ? this.selectionEndLine : this.selectionStartLine);

    }

    /**

     * Sets the caret position. The new selection will consist of the caret position only (hence no

     * text will be selected)

     *

     * @param caret The caret position

     * @see #select(int,int)

     */

    public final void setCaretPosition(int caret) {

        select(caret, caret);

    }

    /**

     * Selects all text in the document.

     */

    public final void selectAll() {

        select(0, getDocumentLength());

    }

    /**

     * Moves the mark to the caret position.

     */

    public final void selectNone() {

        select(getCaretPosition(), getCaretPosition());

    }

    /**

     * Selects from the start offset to the end offset. This is the general selection method used by

     * all other selecting methods. The caret position will be start if start < end, and end if

     * end > start.

     *

     * @param start The start offset

     * @param end The end offset

     */

    public void select(int start, int end) {

        // System.err.println("JEditTextArea:select:" + start + " ," + end);

        int newStart, newEnd;

        boolean newBias;

        if (start <= end) {

            newStart = start;

            newEnd = end;

            newBias = false;

        } else {

            newStart = end;

            newEnd = start;

            newBias = true;

        }

        if (newStart < 0 || newEnd > getDocumentLength()) {

            throw new IllegalArgumentException("Bounds out of" + " range: " + newStart + "," + newEnd);

        }

        // If the new position is the same as the old, we don't

        // do all this crap, however we still do the stuff at

        // the end (clearing magic position, scrolling)

        if (newStart != selectionStart || newEnd != selectionEnd || newBias != biasLeft) {

            int newStartLine = getLineOfOffset(newStart);

            int newEndLine = getLineOfOffset(newEnd);

            if (painter.isBracketHighlightEnabled()) {

                if (bracketLine != -1)

                    painter.invalidateLine(bracketLine);

                updateBracketHighlight(end);

                if (bracketLine != -1)

                    painter.invalidateLine(bracketLine);

            }

            painter.invalidateLineRange(selectionStartLine, selectionEndLine);

            painter.invalidateLineRange(newStartLine, newEndLine);

            document.addUndoableEdit(new CaretUndo(selectionStart, selectionEnd));

            selectionStart = newStart;

            selectionEnd = newEnd;

            selectionStartLine = newStartLine;

            selectionEndLine = newEndLine;

            biasLeft = newBias;

            fireCaretEvent();

        }

        // When the user is typing, etc, we don't want the caret

        // to blink

        blink = true;

        caretTimer.restart();

        // Disable rectangle select if selection start = selection end

        if (selectionStart == selectionEnd)

            rectSelect = false;

        // Clear the `magic' caret position used by up/down

        magicCaret = -1;

        scrollToCaret();

    }

    /**