configurablecaret.java~1~

具有不同语法高亮的编辑器实例

/*
 * 12/21/2004
 *
 * ConfigurableCaret.java - The caret used by RTextArea.
 * Copyright (C) 2004 Robert Futrell
 * [e-mail]
 * www.website.com
 *
 * 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 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package org.fife.ui.rtextarea;

import java.awt.*;
import java.awt.event.*;
import java.awt.datatransfer.*;
import java.beans.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.plaf.*;
import javax.swing.text.*;
import java.util.EventListener; 


/**
 * The caret used by <code>RTextArea</code>.  This caret has all of the
 * properties that <code>javax.swing.text.DefaultCaret</code> does, as
 * well as adding the following nicities:
 *
 * <ul>
 *   <li>This caret can paint itself several different ways:
 *      <ol>
 *         <li>As a vertical line (like <code>DefaultCaret</code>)</li>
 *         <li>As an underline</li>
 *         <li>As a "block caret"</li>
 *         <li>As a rectangle around the current character</li>
 *      </ol></li>
 *   <li>On Microsoft Windows and other operating systems that do not
 *       support system selection (i.e., selecting text, then pasting
 *       via the middle mouse button), clicking the middle mouse button
 *       will cause a regular paste operation to occur.  On systems
 *       that support system selection (i.e., all UNIX variants),
 *       the middle mouse button will behave normally.</li>
 *   <li>The caret moves to the undo/redo location when an undo or
 *       redo occurs (<code>DefaultCaret</code> doesn't do this
 *       in J2SE1.4.x but does in 1.5+).</li>
 * </ul>
 *
 * @author Robert Futrell
 * @version 0.5
 */
public class ConfigurableCaret extends Rectangle
		implements Caret, FocusListener, MouseListener, MouseMotionListener {

	/**
	 * 
	 */
	private static final long serialVersionUID = -5964038283301633119L;

	/**
	 * The minimum value of a caret style.
	 */
	public static final int MIN_STYLE				= 0;

	/**
	 * The vertical line style.
	 */
	public static final int VERTICAL_LINE_STYLE		= 0;

	/**
	 * The horizontal line style.
	 */
	public static final int UNDERLINE_STYLE			= 1;

	/**
	 * The block style.
	 */
	public static final int BLOCK_STYLE			= 2;

	/**
	 * The block border style.
	 */
	public static final int BLOCK_BORDER_STYLE		= 3;

	/**
	 * The maximum value of a caret style.
	 */
	public static final int MAX_STYLE				= BLOCK_BORDER_STYLE;


	/**
	 * The event listener list.
	 */
	protected EventListenerList listenerList = new EventListenerList();

	/**
	 * The change event for the model.
	 * Only one ChangeEvent is needed per model instance since the
	 * event's only (read-only) state is the source property.  The source
	 * of events generated here is always "this".
	 */
	protected transient ChangeEvent changeEvent = null;

	// package-private to avoid inner classes private member
	// access bug
	RTextArea component;

	boolean visible;
	boolean active;
	int dot;
	int mark;
	List selectionTagList;
	boolean selectionVisible;
	Timer flasher;
	Point magicCaretPosition;
	Object selectionTag;
	transient Handler handler = new Handler();
	private transient NavigationFilter.FilterBypass filterBypass;
	static private transient Action selectWord = null;
	static private transient Action selectLine = null;

	/**
	 * This is used to indicate if the caret currently owns the selection.
	 * This is always false if the system does not support the system
	 * clipboard.
	 */
	private boolean ownsSelection;

	/**
	 * If this is true, the location of the dot is updated regardless of
	 * the current location. This is set in the DocumentListener
	 * such that even if the model location of dot hasn't changed (perhaps do
	 * to a forward delete) the visual location is updated.
	 */
	private boolean forceCaretPositionChange;

	/**
	 * Whether or not mouseReleased should adjust the caret and focus.
	 * This flag is set by mousePressed if it wanted to adjust the caret
	 * and focus but couldn't because of a possible DnD operation.
	 */
	private transient boolean shouldHandleRelease;

	/**
	 * holds last MouseEvent which caused the word selection
	 */
	private transient MouseEvent selectedWordEvent = null;

	/**
	 * Used for fastest-possible retrieval of the character at the
	 * caret's position in the document.
	 */
	private Segment seg;

	/**
	 * Whether the caret is a vertical line, a horizontal line, or a block.
	 */
	private int style;

	/**
	 * The selection painter.  By default this paints selections with the
	 * text area's selection color.
	 */
	private Highlighter.HighlightPainter selectionPainter;


/*****************************************************************************/


	/**
	 * Creates the caret using <code>VERTICAL_LINE_STYLE</code>.
	 */
	public ConfigurableCaret() {
		this(VERTICAL_LINE_STYLE);
	}


/*****************************************************************************/


	/**
	 * Constructs a new <code>ConfigurableCaret</code>.
	 *
	 * @param style The style to use when painting the caret.  If this isn't
	 *              one of <code>VERTICAL_LINE_STYLE</code>,
	 *              <code>UNDERLINE_STYLE</code>, or <code>BLOCK_STYLE</code>,
	 *              then <code>VERTICAL_LINE_STYLE</code> is used.
	 */
	public ConfigurableCaret(int style) {
		super();
		seg = new Segment();
		setStyle(style);
		selectionPainter = new ChangableHighlightPainter();
	}


/*****************************************************************************/


	/**
	 * Adds a listener to track whenever the caret position has
	 * been changed.
	 *
	 * @param l the listener
	 * @see Caret#addChangeListener
	 */
	public void addChangeListener(ChangeListener l) {
		listenerList.add(ChangeListener.class, l);
	}


/*****************************************************************************/


	/**
	 * Adjusts the caret location based on the MouseEvent.
	 */
	private void adjustCaret(MouseEvent e) {
		if ((e.getModifiers()&ActionEvent.SHIFT_MASK)!=0 && getDot()!=-1)
			moveCaret(e);
		else
			positionCaret(e);
	}


/*****************************************************************************/


	void adjustCaretAndFocus(MouseEvent e) {
		adjustCaret(e);
		adjustFocus(false);
	}


/*****************************************************************************/


	/**
	 * Adjusts the focus, if necessary.
	 *
	 * @param inWindow if true indicates requestFocusInWindow should be used
	 */
	private void adjustFocus(boolean inWindow) {
		if ((component != null) && component.isEnabled() &&
				component.isRequestFocusEnabled()) {
			if (inWindow)
				component.requestFocusInWindow();
			else 
				component.requestFocus();
		}
	}


/*****************************************************************************/


	/**
	 * Scrolls the associated view (if necessary) to make
	 * the caret visible.  Since how this should be done
	 * is somewhat of a policy, this method can be 
	 * reimplemented to change the behavior.  By default
	 * the scrollRectToVisible method is called on the
	 * associated component.
	 *
	 * @param nloc the new position to scroll to
	 */
	protected void adjustVisibility(Rectangle nloc) {
		if(component == null)
			return;
		if (SwingUtilities.isEventDispatchThread())
			component.scrollRectToVisible(nloc);
		else
			SwingUtilities.invokeLater(new SafeScroller(nloc));
	}


/*****************************************************************************/


	/**
	 * Sets the caret position (dot) to a new location.  This
	 * causes the old and new location to be repainted.  It
	 * also makes sure that the caret is within the visible 
	 * region of the view, if the view is scrollable.
	 */
	void changeCaretPosition(int dot) {

		// repaint the old position and set the new value of
		// the dot.
		repaint();

		// Make sure the caret is visible if this window has the focus.
		if (flasher != null && flasher.isRunning()) {
			visible = true;
			flasher.restart();
		}

		// notify listeners at the caret moved
		this.dot = dot;
		fireStateChanged();

		updateSystemSelection();

		setMagicCaretPosition(null);

		// We try to repaint the caret later, since things
		// may be unstable at the time this is called 
		// (i.e. we don't want to depend upon notification
		// order or the fact that this might happen on
		// an unsafe thread).
		Runnable callRepaintNewCaret = new Runnable() {
			public void run() {
				repaintNewCaret();
			}
		};
		SwingUtilities.invokeLater(callRepaintNewCaret);

	}


/*****************************************************************************/


	/**
	 * Damages the area surrounding the caret to cause it to be repainted in
	 * a new location.  If <code>paint()</code> is reimplemented, this method
	 * should also be reimplemented.  This method should update the caret
	 * bounds (x, y, width, and height).
	 *
	 * @param r  the current location of the caret
	 * @see #paint
	 */
	protected synchronized void damage(Rectangle r) {
		if (r != null) {
			x = r.x - 1;
			y = r.y;
			width = r.width + 4;
			height = r.height;
			repaint();
		}
	}


/*****************************************************************************/


	/**
	 * Called when the UI is being removed from the
	 * interface of a JTextComponent.  This is used to
	 * unregister any listeners that were attached.
	 *
	 * @param c The text component.  If this is not an
	 *          <code>RTextArea</code>, an <code>Exception</code>
	 *          will be thrown.
	 * @see Caret#deinstall
	 */
	public void deinstall(JTextComponent c) {
		if (!(c instanceof RTextArea))
			throw new IllegalArgumentException(
					"c must be instance of RTextArea");
		c.removeMouseListener(this);
		c.removeMouseMotionListener(this);
		c.removeFocusListener(this);
		c.removePropertyChangeListener(handler);
		Document doc = c.getDocument();
		if (doc != null)
			doc.removeDocumentListener(handler);
		synchronized(this) {
			component = null;
		}
		if (flasher != null)
			flasher.stop();
	}


/*****************************************************************************/


	/**
	 * This is invoked after the document changes to verify the current
	 * dot/mark is valid. We do this in case the <code>NavigationFilter</code>
	 * changed where to position the dot, that resulted in the current location
	 * being bogus.
	 */
	private void ensureValidPosition() {
		int length = component.getDocument().getLength();
		if (dot > length || mark > length) {
			// Current location is bogus and filter likely vetoed the
			// change, force the reset without giving the filter a
			// chance at changing it.
			handleSetDot(length);
		}
	}


/*****************************************************************************/


	/**
	 * Compares this object to the specified object.
	 * The superclass behavior of comparing rectangles
	 * is not desired, so this is changed to the Object
	 * behavior.
	 *
	 * @param     obj   the object to compare this font with
	 * @return    <code>true</code> if the objects are equal; 
	 *            <code>false</code> otherwise
	 */
	public boolean equals(Object obj) {
		return (this == obj);
	}


/*****************************************************************************/


	/**
	 * Notifies all listeners that have registered interest for
	 * notification on this event type.  The event instance 
	 * is lazily created using the parameters passed into 
	 * the fire method.  The listener list is processed last to first.
	 *
	 * @see EventListenerList
	 */
	protected void fireStateChanged() {
		// Guaranteed to return a non-null array
		Object[] listeners = listenerList.getListenerList();
		// Process the listeners last to first, notifying
		// those that are interested in this event
		for (int i = listeners.length-2; i>=0; i-=2) {
			if (listeners[i]==ChangeListener.class) {
				// Lazily create the event:
				if (changeEvent == null)
					changeEvent = new ChangeEvent(this);
				((ChangeListener)listeners[i+1]).stateChanged(changeEvent);
			}
		}
	}	


/*****************************************************************************/


	/**
	 * Called when the component containing the caret gains
	 * focus.  This is implemented to set the caret to visible
	 * if the component is editable.
	 *
	 * @param e the focus event
	 * @see FocusListener#focusGained
	 */
	public void focusGained(FocusEvent e) {
		if (component.isEnabled()) {
			if (component.isEditable())
				setVisible(true);