--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/javax/swing/text/JTextComponent.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,5042 @@
+/*
+ * Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+package javax.swing.text;
+
+import java.lang.reflect.Method;
+
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Enumeration;
+import java.util.Vector;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import java.util.concurrent.*;
+
+import java.io.*;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.print.*;
+import java.awt.datatransfer.*;
+import java.awt.im.InputContext;
+import java.awt.im.InputMethodRequests;
+import java.awt.font.TextHitInfo;
+import java.awt.font.TextAttribute;
+
+import java.awt.print.Printable;
+import java.awt.print.PrinterException;
+
+import javax.print.PrintService;
+import javax.print.attribute.PrintRequestAttributeSet;
+
+import java.text.*;
+import java.text.AttributedCharacterIterator.Attribute;
+
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.plaf.*;
+
+import javax.accessibility.*;
+
+import javax.print.attribute.*;
+
+import sun.awt.AppContext;
+
+
+import sun.swing.PrintingStatus;
+import sun.swing.SwingUtilities2;
+import sun.swing.text.TextComponentPrintable;
+
+/**
+ * <code>JTextComponent</code> is the base class for swing text
+ * components. It tries to be compatible with the
+ * <code>java.awt.TextComponent</code> class
+ * where it can reasonably do so. Also provided are other services
+ * for additional flexibility (beyond the pluggable UI and bean
+ * support).
+ * You can find information on how to use the functionality
+ * this class provides in
+ * <a href="http://java.sun.com/docs/books/tutorial/uiswing/components/generaltext.html">General Rules for Using Text Components</a>,
+ * a section in <em>The Java Tutorial.</em>
+ *
+ * <p>
+ * <dl>
+ * <dt><b><font size=+1>Caret Changes</font></b>
+ * <dd>
+ * The caret is a pluggable object in swing text components.
+ * Notification of changes to the caret position and the selection
+ * are sent to implementations of the <code>CaretListener</code>
+ * interface that have been registered with the text component.
+ * The UI will install a default caret unless a customized caret
+ * has been set. <br>
+ * By default the caret tracks all the document changes
+ * performed on the Event Dispatching Thread and updates it's position
+ * accordingly if an insertion occurs before or at the caret position
+ * or a removal occurs before the caret position. <code>DefaultCaret</code>
+ * tries to make itself visible which may lead to scrolling
+ * of a text component within <code>JScrollPane</code>. The default caret
+ * behavior can be changed by the {@link DefaultCaret#setUpdatePolicy} method.
+ * <br>
+ * <b>Note</b>: Non-editable text components also have a caret though
+ * it may not be painted.
+ *
+ * <p>
+ * <dt><b><font size=+1>Commands</font></b>
+ * <dd>
+ * Text components provide a number of commands that can be used
+ * to manipulate the component. This is essentially the way that
+ * the component expresses its capabilities. These are expressed
+ * in terms of the swing <code>Action</code> interface,
+ * using the <code>TextAction</code> implementation.
+ * The set of commands supported by the text component can be
+ * found with the {@link #getActions} method. These actions
+ * can be bound to key events, fired from buttons, etc.
+ *
+ * <p>
+ * <dt><b><font size=+1>Text Input</font></b>
+ * <dd>
+ * The text components support flexible and internationalized text input, using
+ * keymaps and the input method framework, while maintaining compatibility with
+ * the AWT listener model.
+ * <p>
+ * A {@link javax.swing.text.Keymap} lets an application bind key
+ * strokes to actions.
+ * In order to allow keymaps to be shared across multiple text components, they
+ * can use actions that extend <code>TextAction</code>.
+ * <code>TextAction</code> can determine which <code>JTextComponent</code>
+ * most recently has or had focus and therefore is the subject of
+ * the action (In the case that the <code>ActionEvent</code>
+ * sent to the action doesn't contain the target text component as its source).
+ * <p>
+ * The <a href="../../../../technotes/guides/imf/spec.html">input method framework</a>
+ * lets text components interact with input methods, separate software
+ * components that preprocess events to let users enter thousands of
+ * different characters using keyboards with far fewer keys.
+ * <code>JTextComponent</code> is an <em>active client</em> of
+ * the framework, so it implements the preferred user interface for interacting
+ * with input methods. As a consequence, some key events do not reach the text
+ * component because they are handled by an input method, and some text input
+ * reaches the text component as committed text within an {@link
+ * java.awt.event.InputMethodEvent} instead of as a key event.
+ * The complete text input is the combination of the characters in
+ * <code>keyTyped</code> key events and committed text in input method events.
+ * <p>
+ * The AWT listener model lets applications attach event listeners to
+ * components in order to bind events to actions. Swing encourages the
+ * use of keymaps instead of listeners, but maintains compatibility
+ * with listeners by giving the listeners a chance to steal an event
+ * by consuming it.
+ * <p>
+ * Keyboard event and input method events are handled in the following stages,
+ * with each stage capable of consuming the event:
+ *
+ * <table border=1 summary="Stages of keyboard and input method event handling">
+ * <tr>
+ * <th id="stage"><p align="left">Stage</p></th>
+ * <th id="ke"><p align="left">KeyEvent</p></th>
+ * <th id="ime"><p align="left">InputMethodEvent</p></th></tr>
+ * <tr><td headers="stage">1. </td>
+ * <td headers="ke">input methods </td>
+ * <td headers="ime">(generated here)</td></tr>
+ * <tr><td headers="stage">2. </td>
+ * <td headers="ke">focus manager </td>
+ * <td headers="ime"></td>
+ * </tr>
+ * <tr>
+ * <td headers="stage">3. </td>
+ * <td headers="ke">registered key listeners</td>
+ * <td headers="ime">registered input method listeners</tr>
+ * <tr>
+ * <td headers="stage">4. </td>
+ * <td headers="ke"></td>
+ * <td headers="ime">input method handling in JTextComponent</tr>
+ * <tr>
+ * <td headers="stage">5. </td><td headers="ke ime" colspan=2>keymap handling using the current keymap</td></tr>
+ * <tr><td headers="stage">6. </td><td headers="ke">keyboard handling in JComponent (e.g. accelerators, component navigation, etc.)</td>
+ * <td headers="ime"></td></tr>
+ * </table>
+ *
+ * <p>
+ * To maintain compatibility with applications that listen to key
+ * events but are not aware of input method events, the input
+ * method handling in stage 4 provides a compatibility mode for
+ * components that do not process input method events. For these
+ * components, the committed text is converted to keyTyped key events
+ * and processed in the key event pipeline starting at stage 3
+ * instead of in the input method event pipeline.
+ * <p>
+ * By default the component will create a keymap (named <b>DEFAULT_KEYMAP</b>)
+ * that is shared by all JTextComponent instances as the default keymap.
+ * Typically a look-and-feel implementation will install a different keymap
+ * that resolves to the default keymap for those bindings not found in the
+ * different keymap. The minimal bindings include:
+ * <ul>
+ * <li>inserting content into the editor for the
+ * printable keys.
+ * <li>removing content with the backspace and del
+ * keys.
+ * <li>caret movement forward and backward
+ * </ul>
+ *
+ * <p>
+ * <dt><b><font size=+1>Model/View Split</font></b>
+ * <dd>
+ * The text components have a model-view split. A text component pulls
+ * together the objects used to represent the model, view, and controller.
+ * The text document model may be shared by other views which act as observers
+ * of the model (e.g. a document may be shared by multiple components).
+ *
+ * <p align=center><img src="doc-files/editor.gif" alt="Diagram showing interaction between Controller, Document, events, and ViewFactory"
+ * HEIGHT=358 WIDTH=587></p>
+ *
+ * <p>
+ * The model is defined by the {@link Document} interface.
+ * This is intended to provide a flexible text storage mechanism
+ * that tracks change during edits and can be extended to more sophisticated
+ * models. The model interfaces are meant to capture the capabilities of
+ * expression given by SGML, a system used to express a wide variety of
+ * content.
+ * Each modification to the document causes notification of the
+ * details of the change to be sent to all observers in the form of a
+ * {@link DocumentEvent} which allows the views to stay up to date with the model.
+ * This event is sent to observers that have implemented the
+ * {@link DocumentListener}
+ * interface and registered interest with the model being observed.
+ *
+ * <p>
+ * <dt><b><font size=+1>Location Information</font></b>
+ * <dd>
+ * The capability of determining the location of text in
+ * the view is provided. There are two methods, {@link #modelToView}
+ * and {@link #viewToModel} for determining this information.
+ *
+ * <p>
+ * <dt><b><font size=+1>Undo/Redo support</font></b>
+ * <dd>
+ * Support for an edit history mechanism is provided to allow
+ * undo/redo operations. The text component does not itself
+ * provide the history buffer by default, but does provide
+ * the <code>UndoableEdit</code> records that can be used in conjunction
+ * with a history buffer to provide the undo/redo support.
+ * The support is provided by the Document model, which allows
+ * one to attach UndoableEditListener implementations.
+ *
+ * <p>
+ * <dt><b><font size=+1>Thread Safety</font></b>
+ * <dd>
+ * The swing text components provide some support of thread
+ * safe operations. Because of the high level of configurability
+ * of the text components, it is possible to circumvent the
+ * protection provided. The protection primarily comes from
+ * the model, so the documentation of <code>AbstractDocument</code>
+ * describes the assumptions of the protection provided.
+ * The methods that are safe to call asynchronously are marked
+ * with comments.
+ *
+ * <p>
+ * <dt><b><font size=+1>Newlines</font></b>
+ * <dd>
+ * For a discussion on how newlines are handled, see
+ * <a href="DefaultEditorKit.html">DefaultEditorKit</a>.
+ *
+ * <p>
+ * <dt><b><font size=+1>Printing support</font></b>
+ * <dd>
+ * Several {@link #print print} methods are provided for basic
+ * document printing. If more advanced printing is needed, use the
+ * {@link #getPrintable} method.
+ * </dl>
+ *
+ * <p>
+ * <strong>Warning:</strong>
+ * Serialized objects of this class will not be compatible with
+ * future Swing releases. The current serialization support is
+ * appropriate for short term storage or RMI between applications running
+ * the same version of Swing. As of 1.4, support for long term storage
+ * of all JavaBeans<sup><font size="-2">TM</font></sup>
+ * has been added to the <code>java.beans</code> package.
+ * Please see {@link java.beans.XMLEncoder}.
+ *
+ * @beaninfo
+ * attribute: isContainer false
+ *
+ * @author Timothy Prinzing
+ * @author Igor Kushnirskiy (printing support)
+ * @see Document
+ * @see DocumentEvent
+ * @see DocumentListener
+ * @see Caret
+ * @see CaretEvent
+ * @see CaretListener
+ * @see TextUI
+ * @see View
+ * @see ViewFactory
+ */
+public abstract class JTextComponent extends JComponent implements Scrollable, Accessible
+{
+ /**
+ * Creates a new <code>JTextComponent</code>.
+ * Listeners for caret events are established, and the pluggable
+ * UI installed. The component is marked as editable. No layout manager
+ * is used, because layout is managed by the view subsystem of text.
+ * The document model is set to <code>null</code>.
+ */
+ public JTextComponent() {
+ super();
+ // enable InputMethodEvent for on-the-spot pre-editing
+ enableEvents(AWTEvent.KEY_EVENT_MASK | AWTEvent.INPUT_METHOD_EVENT_MASK);
+ caretEvent = new MutableCaretEvent(this);
+ addMouseListener(caretEvent);
+ addFocusListener(caretEvent);
+ setEditable(true);
+ setDragEnabled(false);
+ setLayout(null); // layout is managed by View hierarchy
+ updateUI();
+ }
+
+ /**
+ * Fetches the user-interface factory for this text-oriented editor.
+ *
+ * @return the factory
+ */
+ public TextUI getUI() { return (TextUI)ui; }
+
+ /**
+ * Sets the user-interface factory for this text-oriented editor.
+ *
+ * @param ui the factory
+ */
+ public void setUI(TextUI ui) {
+ super.setUI(ui);
+ }
+
+ /**
+ * Reloads the pluggable UI. The key used to fetch the
+ * new interface is <code>getUIClassID()</code>. The type of
+ * the UI is <code>TextUI</code>. <code>invalidate</code>
+ * is called after setting the UI.
+ */
+ public void updateUI() {
+ setUI((TextUI)UIManager.getUI(this));
+ invalidate();
+ }
+
+ /**
+ * Adds a caret listener for notification of any changes
+ * to the caret.
+ *
+ * @param listener the listener to be added
+ * @see javax.swing.event.CaretEvent
+ */
+ public void addCaretListener(CaretListener listener) {
+ listenerList.add(CaretListener.class, listener);
+ }
+
+ /**
+ * Removes a caret listener.
+ *
+ * @param listener the listener to be removed
+ * @see javax.swing.event.CaretEvent
+ */
+ public void removeCaretListener(CaretListener listener) {
+ listenerList.remove(CaretListener.class, listener);
+ }
+
+ /**
+ * Returns an array of all the caret listeners
+ * registered on this text component.
+ *
+ * @return all of this component's <code>CaretListener</code>s
+ * or an empty
+ * array if no caret listeners are currently registered
+ *
+ * @see #addCaretListener
+ * @see #removeCaretListener
+ *
+ * @since 1.4
+ */
+ public CaretListener[] getCaretListeners() {
+ return (CaretListener[])listenerList.getListeners(CaretListener.class);
+ }
+
+ /**
+ * 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 in a
+ * last-to-first manner.
+ *
+ * @param e the event
+ * @see EventListenerList
+ */
+ protected void fireCaretUpdate(CaretEvent e) {
+ // 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]==CaretListener.class) {
+ ((CaretListener)listeners[i+1]).caretUpdate(e);
+ }
+ }
+ }
+
+ /**
+ * Associates the editor with a text document.
+ * The currently registered factory is used to build a view for
+ * the document, which gets displayed by the editor after revalidation.
+ * A PropertyChange event ("document") is propagated to each listener.
+ *
+ * @param doc the document to display/edit
+ * @see #getDocument
+ * @beaninfo
+ * description: the text document model
+ * bound: true
+ * expert: true
+ */
+ public void setDocument(Document doc) {
+ Document old = model;
+
+ /*
+ * aquire a read lock on the old model to prevent notification of
+ * mutations while we disconnecting the old model.
+ */
+ try {
+ if (old instanceof AbstractDocument) {
+ ((AbstractDocument)old).readLock();
+ }
+ if (accessibleContext != null) {
+ model.removeDocumentListener(
+ ((AccessibleJTextComponent)accessibleContext));
+ }
+ if (inputMethodRequestsHandler != null) {
+ model.removeDocumentListener((DocumentListener)inputMethodRequestsHandler);
+ }
+ model = doc;
+
+ // Set the document's run direction property to match the
+ // component's ComponentOrientation property.
+ Boolean runDir = getComponentOrientation().isLeftToRight()
+ ? TextAttribute.RUN_DIRECTION_LTR
+ : TextAttribute.RUN_DIRECTION_RTL;
+ if (runDir != doc.getProperty(TextAttribute.RUN_DIRECTION)) {
+ doc.putProperty(TextAttribute.RUN_DIRECTION, runDir );
+ }
+ firePropertyChange("document", old, doc);
+ } finally {
+ if (old instanceof AbstractDocument) {
+ ((AbstractDocument)old).readUnlock();
+ }
+ }
+
+ revalidate();
+ repaint();
+ if (accessibleContext != null) {
+ model.addDocumentListener(
+ ((AccessibleJTextComponent)accessibleContext));
+ }
+ if (inputMethodRequestsHandler != null) {
+ model.addDocumentListener((DocumentListener)inputMethodRequestsHandler);
+ }
+ }
+
+ /**
+ * Fetches the model associated with the editor. This is
+ * primarily for the UI to get at the minimal amount of
+ * state required to be a text editor. Subclasses will
+ * return the actual type of the model which will typically
+ * be something that extends Document.
+ *
+ * @return the model
+ */
+ public Document getDocument() {
+ return model;
+ }
+
+ // Override of Component.setComponentOrientation
+ public void setComponentOrientation( ComponentOrientation o ) {
+ // Set the document's run direction property to match the
+ // ComponentOrientation property.
+ Document doc = getDocument();
+ if( doc != null ) {
+ Boolean runDir = o.isLeftToRight()
+ ? TextAttribute.RUN_DIRECTION_LTR
+ : TextAttribute.RUN_DIRECTION_RTL;
+ doc.putProperty( TextAttribute.RUN_DIRECTION, runDir );
+ }
+ super.setComponentOrientation( o );
+ }
+
+ /**
+ * Fetches the command list for the editor. This is
+ * the list of commands supported by the plugged-in UI
+ * augmented by the collection of commands that the
+ * editor itself supports. These are useful for binding
+ * to events, such as in a keymap.
+ *
+ * @return the command list
+ */
+ public Action[] getActions() {
+ return getUI().getEditorKit(this).getActions();
+ }
+
+ /**
+ * Sets margin space between the text component's border
+ * and its text. The text component's default <code>Border</code>
+ * object will use this value to create the proper margin.
+ * However, if a non-default border is set on the text component,
+ * it is that <code>Border</code> object's responsibility to create the
+ * appropriate margin space (else this property will effectively
+ * be ignored). This causes a redraw of the component.
+ * A PropertyChange event ("margin") is sent to all listeners.
+ *
+ * @param m the space between the border and the text
+ * @beaninfo
+ * description: desired space between the border and text area
+ * bound: true
+ */
+ public void setMargin(Insets m) {
+ Insets old = margin;
+ margin = m;
+ firePropertyChange("margin", old, m);
+ invalidate();
+ }
+
+ /**
+ * Returns the margin between the text component's border and
+ * its text.
+ *
+ * @return the margin
+ */
+ public Insets getMargin() {
+ return margin;
+ }
+
+ /**
+ * Sets the <code>NavigationFilter</code>. <code>NavigationFilter</code>
+ * is used by <code>DefaultCaret</code> and the default cursor movement
+ * actions as a way to restrict the cursor movement.
+ *
+ * @since 1.4
+ */
+ public void setNavigationFilter(NavigationFilter filter) {
+ navigationFilter = filter;
+ }
+
+ /**
+ * Returns the <code>NavigationFilter</code>. <code>NavigationFilter</code>
+ * is used by <code>DefaultCaret</code> and the default cursor movement
+ * actions as a way to restrict the cursor movement. A null return value
+ * implies the cursor movement and selection should not be restricted.
+ *
+ * @since 1.4
+ * @return the NavigationFilter
+ */
+ public NavigationFilter getNavigationFilter() {
+ return navigationFilter;
+ }
+
+ /**
+ * Fetches the caret that allows text-oriented navigation over
+ * the view.
+ *
+ * @return the caret
+ */
+ public Caret getCaret() {
+ return caret;
+ }
+
+ /**
+ * Sets the caret to be used. By default this will be set
+ * by the UI that gets installed. This can be changed to
+ * a custom caret if desired. Setting the caret results in a
+ * PropertyChange event ("caret") being fired.
+ *
+ * @param c the caret
+ * @see #getCaret
+ * @beaninfo
+ * description: the caret used to select/navigate
+ * bound: true
+ * expert: true
+ */
+ public void setCaret(Caret c) {
+ if (caret != null) {
+ caret.removeChangeListener(caretEvent);
+ caret.deinstall(this);
+ }
+ Caret old = caret;
+ caret = c;
+ if (caret != null) {
+ caret.install(this);
+ caret.addChangeListener(caretEvent);
+ }
+ firePropertyChange("caret", old, caret);
+ }
+
+ /**
+ * Fetches the object responsible for making highlights.
+ *
+ * @return the highlighter
+ */
+ public Highlighter getHighlighter() {
+ return highlighter;
+ }
+
+ /**
+ * Sets the highlighter to be used. By default this will be set
+ * by the UI that gets installed. This can be changed to
+ * a custom highlighter if desired. The highlighter can be set to
+ * <code>null</code> to disable it.
+ * A PropertyChange event ("highlighter") is fired
+ * when a new highlighter is installed.
+ *
+ * @param h the highlighter
+ * @see #getHighlighter
+ * @beaninfo
+ * description: object responsible for background highlights
+ * bound: true
+ * expert: true
+ */
+ public void setHighlighter(Highlighter h) {
+ if (highlighter != null) {
+ highlighter.deinstall(this);
+ }
+ Highlighter old = highlighter;
+ highlighter = h;
+ if (highlighter != null) {
+ highlighter.install(this);
+ }
+ firePropertyChange("highlighter", old, h);
+ }
+
+ /**
+ * Sets the keymap to use for binding events to
+ * actions. Setting to <code>null</code> effectively disables
+ * keyboard input.
+ * A PropertyChange event ("keymap") is fired when a new keymap
+ * is installed.
+ *
+ * @param map the keymap
+ * @see #getKeymap
+ * @beaninfo
+ * description: set of key event to action bindings to use
+ * bound: true
+ */
+ public void setKeymap(Keymap map) {
+ Keymap old = keymap;
+ keymap = map;
+ firePropertyChange("keymap", old, keymap);
+ updateInputMap(old, map);
+ }
+
+ /**
+ * Turns on or off automatic drag handling. In order to enable automatic
+ * drag handling, this property should be set to {@code true}, and the
+ * component's {@code TransferHandler} needs to be {@code non-null}.
+ * The default value of the {@code dragEnabled} property is {@code false}.
+ * <p>
+ * The job of honoring this property, and recognizing a user drag gesture,
+ * lies with the look and feel implementation, and in particular, the component's
+ * {@code TextUI}. When automatic drag handling is enabled, most look and
+ * feels (including those that subclass {@code BasicLookAndFeel}) begin a
+ * drag and drop operation whenever the user presses the mouse button over
+ * a selection and then moves the mouse a few pixels. Setting this property to
+ * {@code true} can therefore have a subtle effect on how selections behave.
+ * <p>
+ * If a look and feel is used that ignores this property, you can still
+ * begin a drag and drop operation by calling {@code exportAsDrag} on the
+ * component's {@code TransferHandler}.
+ *
+ * @param b whether or not to enable automatic drag handling
+ * @exception HeadlessException if
+ * <code>b</code> is <code>true</code> and
+ * <code>GraphicsEnvironment.isHeadless()</code>
+ * returns <code>true</code>
+ * @see java.awt.GraphicsEnvironment#isHeadless
+ * @see #getDragEnabled
+ * @see #setTransferHandler
+ * @see TransferHandler
+ * @since 1.4
+ *
+ * @beaninfo
+ * description: determines whether automatic drag handling is enabled
+ * bound: false
+ */
+ public void setDragEnabled(boolean b) {
+ if (b && GraphicsEnvironment.isHeadless()) {
+ throw new HeadlessException();
+ }
+ dragEnabled = b;
+ }
+
+ /**
+ * Returns whether or not automatic drag handling is enabled.
+ *
+ * @return the value of the {@code dragEnabled} property
+ * @see #setDragEnabled
+ * @since 1.4
+ */
+ public boolean getDragEnabled() {
+ return dragEnabled;
+ }
+
+ /**
+ * Sets the drop mode for this component. For backward compatibility,
+ * the default for this property is <code>DropMode.USE_SELECTION</code>.
+ * Usage of <code>DropMode.INSERT</code> is recommended, however,
+ * for an improved user experience. It offers similar behavior of dropping
+ * between text locations, but does so without affecting the actual text
+ * selection and caret location.
+ * <p>
+ * <code>JTextComponents</code> support the following drop modes:
+ * <ul>
+ * <li><code>DropMode.USE_SELECTION</code></li>
+ * <li><code>DropMode.INSERT</code></li>
+ * </ul>
+ * <p>
+ * The drop mode is only meaningful if this component has a
+ * <code>TransferHandler</code> that accepts drops.
+ *
+ * @param dropMode the drop mode to use
+ * @throws IllegalArgumentException if the drop mode is unsupported
+ * or <code>null</code>
+ * @see #getDropMode
+ * @see #getDropLocation
+ * @see #setTransferHandler
+ * @see javax.swing.TransferHandler
+ * @since 1.6
+ */
+ public final void setDropMode(DropMode dropMode) {
+ if (dropMode != null) {
+ switch (dropMode) {
+ case USE_SELECTION:
+ case INSERT:
+ this.dropMode = dropMode;
+ return;
+ }
+ }
+
+ throw new IllegalArgumentException(dropMode + ": Unsupported drop mode for text");
+ }
+
+ /**
+ * Returns the drop mode for this component.
+ *
+ * @return the drop mode for this component
+ * @see #setDropMode
+ * @since 1.6
+ */
+ public final DropMode getDropMode() {
+ return dropMode;
+ }
+
+
+ /**
+ * Calculates a drop location in this component, representing where a
+ * drop at the given point should insert data.
+ * <p>
+ * Note: This method is meant to override
+ * <code>JComponent.dropLocationForPoint()</code>, which is package-private
+ * in javax.swing. <code>TransferHandler</code> will detect text components
+ * and call this method instead via reflection. It's name should therefore
+ * not be changed.
+ *
+ * @param p the point to calculate a drop location for
+ * @return the drop location, or <code>null</code>
+ */
+ DropLocation dropLocationForPoint(Point p) {
+ Position.Bias[] bias = new Position.Bias[1];
+ int index = getUI().viewToModel(this, p, bias);
+
+ // viewToModel currently returns null for some HTML content
+ // when the point is within the component's top inset
+ if (bias[0] == null) {
+ bias[0] = Position.Bias.Forward;
+ }
+
+ return new DropLocation(p, index, bias[0]);
+ }
+
+ /**
+ * Called to set or clear the drop location during a DnD operation.
+ * In some cases, the component may need to use it's internal selection
+ * temporarily to indicate the drop location. To help facilitate this,
+ * this method returns and accepts as a parameter a state object.
+ * This state object can be used to store, and later restore, the selection
+ * state. Whatever this method returns will be passed back to it in
+ * future calls, as the state parameter. If it wants the DnD system to
+ * continue storing the same state, it must pass it back every time.
+ * Here's how this is used:
+ * <p>
+ * Let's say that on the first call to this method the component decides
+ * to save some state (because it is about to use the selection to show
+ * a drop index). It can return a state object to the caller encapsulating
+ * any saved selection state. On a second call, let's say the drop location
+ * is being changed to something else. The component doesn't need to
+ * restore anything yet, so it simply passes back the same state object
+ * to have the DnD system continue storing it. Finally, let's say this
+ * method is messaged with <code>null</code>. This means DnD
+ * is finished with this component for now, meaning it should restore
+ * state. At this point, it can use the state parameter to restore
+ * said state, and of course return <code>null</code> since there's
+ * no longer anything to store.
+ * <p>
+ * Note: This method is meant to override
+ * <code>JComponent.setDropLocation()</code>, which is package-private
+ * in javax.swing. <code>TransferHandler</code> will detect text components
+ * and call this method instead via reflection. It's name should therefore
+ * not be changed.
+ *
+ * @param location the drop location (as calculated by
+ * <code>dropLocationForPoint</code>) or <code>null</code>
+ * if there's no longer a valid drop location
+ * @param state the state object saved earlier for this component,
+ * or <code>null</code>
+ * @param forDrop whether or not the method is being called because an
+ * actual drop occurred
+ * @return any saved state for this component, or <code>null</code> if none
+ */
+ Object setDropLocation(TransferHandler.DropLocation location,
+ Object state,
+ boolean forDrop) {
+
+ Object retVal = null;
+ DropLocation textLocation = (DropLocation)location;
+
+ if (dropMode == DropMode.USE_SELECTION) {
+ if (textLocation == null) {
+ if (state != null) {
+ /*
+ * This object represents the state saved earlier.
+ * If the caret is a DefaultCaret it will be
+ * an Object array containing, in order:
+ * - the saved caret mark (Integer)
+ * - the saved caret dot (Integer)
+ * - the saved caret visibility (Boolean)
+ * - the saved mark bias (Position.Bias)
+ * - the saved dot bias (Position.Bias)
+ * If the caret is not a DefaultCaret it will
+ * be similar, but will not contain the dot
+ * or mark bias.
+ */
+ Object[] vals = (Object[])state;
+
+ if (!forDrop) {
+ if (caret instanceof DefaultCaret) {
+ ((DefaultCaret)caret).setDot(((Integer)vals[0]).intValue(),
+ (Position.Bias)vals[3]);
+ ((DefaultCaret)caret).moveDot(((Integer)vals[1]).intValue(),
+ (Position.Bias)vals[4]);
+ } else {
+ caret.setDot(((Integer)vals[0]).intValue());
+ caret.moveDot(((Integer)vals[1]).intValue());
+ }
+ }
+
+ caret.setVisible(((Boolean)vals[2]).booleanValue());
+ }
+ } else {
+ if (dropLocation == null) {
+ boolean visible;
+
+ if (caret instanceof DefaultCaret) {
+ DefaultCaret dc = (DefaultCaret)caret;
+ visible = dc.isActive();
+ retVal = new Object[] {Integer.valueOf(dc.getMark()),
+ Integer.valueOf(dc.getDot()),
+ Boolean.valueOf(visible),
+ dc.getMarkBias(),
+ dc.getDotBias()};
+ } else {
+ visible = caret.isVisible();
+ retVal = new Object[] {Integer.valueOf(caret.getMark()),
+ Integer.valueOf(caret.getDot()),
+ Boolean.valueOf(visible)};
+ }
+
+ caret.setVisible(true);
+ } else {
+ retVal = state;
+ }
+
+ if (caret instanceof DefaultCaret) {
+ ((DefaultCaret)caret).setDot(textLocation.getIndex(), textLocation.getBias());
+ } else {
+ caret.setDot(textLocation.getIndex());
+ }
+ }
+ } else {
+ if (textLocation == null) {
+ if (state != null) {
+ caret.setVisible(((Boolean)state).booleanValue());
+ }
+ } else {
+ if (dropLocation == null) {
+ boolean visible = caret instanceof DefaultCaret
+ ? ((DefaultCaret)caret).isActive()
+ : caret.isVisible();
+ retVal = Boolean.valueOf(visible);
+ caret.setVisible(false);
+ } else {
+ retVal = state;
+ }
+ }
+ }
+
+ DropLocation old = dropLocation;
+ dropLocation = textLocation;
+ firePropertyChange("dropLocation", old, dropLocation);
+
+ return retVal;
+ }
+
+ /**
+ * Returns the location that this component should visually indicate
+ * as the drop location during a DnD operation over the component,
+ * or {@code null} if no location is to currently be shown.
+ * <p>
+ * This method is not meant for querying the drop location
+ * from a {@code TransferHandler}, as the drop location is only
+ * set after the {@code TransferHandler}'s <code>canImport</code>
+ * has returned and has allowed for the location to be shown.
+ * <p>
+ * When this property changes, a property change event with
+ * name "dropLocation" is fired by the component.
+ *
+ * @return the drop location
+ * @see #setDropMode
+ * @see TransferHandler#canImport(TransferHandler.TransferSupport)
+ * @since 1.6
+ */
+ public final DropLocation getDropLocation() {
+ return dropLocation;
+ }
+
+
+ /**
+ * Updates the <code>InputMap</code>s in response to a
+ * <code>Keymap</code> change.
+ * @param oldKm the old <code>Keymap</code>
+ * @param newKm the new <code>Keymap</code>
+ */
+ void updateInputMap(Keymap oldKm, Keymap newKm) {
+ // Locate the current KeymapWrapper.
+ InputMap km = getInputMap(JComponent.WHEN_FOCUSED);
+ InputMap last = km;
+ while (km != null && !(km instanceof KeymapWrapper)) {
+ last = km;
+ km = km.getParent();
+ }
+ if (km != null) {
+ // Found it, tweak the InputMap that points to it, as well
+ // as anything it points to.
+ if (newKm == null) {
+ if (last != km) {
+ last.setParent(km.getParent());
+ }
+ else {
+ last.setParent(null);
+ }
+ }
+ else {
+ InputMap newKM = new KeymapWrapper(newKm);
+ last.setParent(newKM);
+ if (last != km) {
+ newKM.setParent(km.getParent());
+ }
+ }
+ }
+ else if (newKm != null) {
+ km = getInputMap(JComponent.WHEN_FOCUSED);
+ if (km != null) {
+ // Couldn't find it.
+ // Set the parent of WHEN_FOCUSED InputMap to be the new one.
+ InputMap newKM = new KeymapWrapper(newKm);
+ newKM.setParent(km.getParent());
+ km.setParent(newKM);
+ }
+ }
+
+ // Do the same thing with the ActionMap
+ ActionMap am = getActionMap();
+ ActionMap lastAM = am;
+ while (am != null && !(am instanceof KeymapActionMap)) {
+ lastAM = am;
+ am = am.getParent();
+ }
+ if (am != null) {
+ // Found it, tweak the Actionap that points to it, as well
+ // as anything it points to.
+ if (newKm == null) {
+ if (lastAM != am) {
+ lastAM.setParent(am.getParent());
+ }
+ else {
+ lastAM.setParent(null);
+ }
+ }
+ else {
+ ActionMap newAM = new KeymapActionMap(newKm);
+ lastAM.setParent(newAM);
+ if (lastAM != am) {
+ newAM.setParent(am.getParent());
+ }
+ }
+ }
+ else if (newKm != null) {
+ am = getActionMap();
+ if (am != null) {
+ // Couldn't find it.
+ // Set the parent of ActionMap to be the new one.
+ ActionMap newAM = new KeymapActionMap(newKm);
+ newAM.setParent(am.getParent());
+ am.setParent(newAM);
+ }
+ }
+ }
+
+ /**
+ * Fetches the keymap currently active in this text
+ * component.
+ *
+ * @return the keymap
+ */
+ public Keymap getKeymap() {
+ return keymap;
+ }
+
+ /**
+ * Adds a new keymap into the keymap hierarchy. Keymap bindings
+ * resolve from bottom up so an attribute specified in a child
+ * will override an attribute specified in the parent.
+ *
+ * @param nm the name of the keymap (must be unique within the
+ * collection of named keymaps in the document); the name may
+ * be <code>null</code> if the keymap is unnamed,
+ * but the caller is responsible for managing the reference
+ * returned as an unnamed keymap can't
+ * be fetched by name
+ * @param parent the parent keymap; this may be <code>null</code> if
+ * unspecified bindings need not be resolved in some other keymap
+ * @return the keymap
+ */
+ public static Keymap addKeymap(String nm, Keymap parent) {
+ Keymap map = new DefaultKeymap(nm, parent);
+ if (nm != null) {
+ // add a named keymap, a class of bindings
+ getKeymapTable().put(nm, map);
+ }
+ return map;
+ }
+
+ /**
+ * Removes a named keymap previously added to the document. Keymaps
+ * with <code>null</code> names may not be removed in this way.
+ *
+ * @param nm the name of the keymap to remove
+ * @return the keymap that was removed
+ */
+ public static Keymap removeKeymap(String nm) {
+ return getKeymapTable().remove(nm);
+ }
+
+ /**
+ * Fetches a named keymap previously added to the document.
+ * This does not work with <code>null</code>-named keymaps.
+ *
+ * @param nm the name of the keymap
+ * @return the keymap
+ */
+ public static Keymap getKeymap(String nm) {
+ return getKeymapTable().get(nm);
+ }
+
+ private static HashMap<String,Keymap> getKeymapTable() {
+ synchronized (KEYMAP_TABLE) {
+ AppContext appContext = AppContext.getAppContext();
+ HashMap<String,Keymap> keymapTable =
+ (HashMap<String,Keymap>)appContext.get(KEYMAP_TABLE);
+ if (keymapTable == null) {
+ keymapTable = new HashMap<String,Keymap>(17);
+ appContext.put(KEYMAP_TABLE, keymapTable);
+ //initialize default keymap
+ Keymap binding = addKeymap(DEFAULT_KEYMAP, null);
+ binding.setDefaultAction(new
+ DefaultEditorKit.DefaultKeyTypedAction());
+ }
+ return keymapTable;
+ }
+ }
+
+ /**
+ * Binding record for creating key bindings.
+ * <p>
+ * <strong>Warning:</strong>
+ * Serialized objects of this class will not be compatible with
+ * future Swing releases. The current serialization support is
+ * appropriate for short term storage or RMI between applications running
+ * the same version of Swing. As of 1.4, support for long term storage
+ * of all JavaBeans<sup><font size="-2">TM</font></sup>
+ * has been added to the <code>java.beans</code> package.
+ * Please see {@link java.beans.XMLEncoder}.
+ */
+ public static class KeyBinding {
+
+ /**
+ * The key.
+ */
+ public KeyStroke key;
+
+ /**
+ * The name of the action for the key.
+ */
+ public String actionName;
+
+ /**
+ * Creates a new key binding.
+ *
+ * @param key the key
+ * @param actionName the name of the action for the key
+ */
+ public KeyBinding(KeyStroke key, String actionName) {
+ this.key = key;
+ this.actionName = actionName;
+ }
+ }
+
+ /**
+ * <p>
+ * Loads a keymap with a bunch of
+ * bindings. This can be used to take a static table of
+ * definitions and load them into some keymap. The following
+ * example illustrates an example of binding some keys to
+ * the cut, copy, and paste actions associated with a
+ * JTextComponent. A code fragment to accomplish
+ * this might look as follows:
+ * <pre><code>
+ *
+ * static final JTextComponent.KeyBinding[] defaultBindings = {
+ * new JTextComponent.KeyBinding(
+ * KeyStroke.getKeyStroke(KeyEvent.VK_C, InputEvent.CTRL_MASK),
+ * DefaultEditorKit.copyAction),
+ * new JTextComponent.KeyBinding(
+ * KeyStroke.getKeyStroke(KeyEvent.VK_V, InputEvent.CTRL_MASK),
+ * DefaultEditorKit.pasteAction),
+ * new JTextComponent.KeyBinding(
+ * KeyStroke.getKeyStroke(KeyEvent.VK_X, InputEvent.CTRL_MASK),
+ * DefaultEditorKit.cutAction),
+ * };
+ *
+ * JTextComponent c = new JTextPane();
+ * Keymap k = c.getKeymap();
+ * JTextComponent.loadKeymap(k, defaultBindings, c.getActions());
+ *
+ * </code></pre>
+ * The sets of bindings and actions may be empty but must be
+ * non-<code>null</code>.
+ *
+ * @param map the keymap
+ * @param bindings the bindings
+ * @param actions the set of actions
+ */
+ public static void loadKeymap(Keymap map, KeyBinding[] bindings, Action[] actions) {
+ Hashtable h = new Hashtable();
+ for (int i = 0; i < actions.length; i++) {
+ Action a = actions[i];
+ String value = (String)a.getValue(Action.NAME);
+ h.put((value!=null ? value:""), a);
+ }
+ for (int i = 0; i < bindings.length; i++) {
+ Action a = (Action) h.get(bindings[i].actionName);
+ if (a != null) {
+ map.addActionForKeyStroke(bindings[i].key, a);
+ }
+ }
+ }
+
+ /**
+ * Returns true if <code>klass</code> is NOT a JTextComponent and it or
+ * one of its superclasses (stoping at JTextComponent) overrides
+ * <code>processInputMethodEvent</code>. It is assumed this will be
+ * invoked from within a <code>doPrivileged</code>, and it is also
+ * assumed <code>klass</code> extends <code>JTextComponent</code>.
+ */
+ private static Boolean isProcessInputMethodEventOverridden(Class klass) {
+ if (klass == JTextComponent.class) {
+ return Boolean.FALSE;
+ }
+ Boolean retValue = (Boolean)overrideMap.get(klass.getName());
+
+ if (retValue != null) {
+ return retValue;
+ }
+ Boolean sOverriden = isProcessInputMethodEventOverridden(
+ klass.getSuperclass());
+
+ if (sOverriden.booleanValue()) {
+ // If our superclass has overriden it, then by definition klass
+ // overrides it.
+ overrideMap.put(klass.getName(), sOverriden);
+ return sOverriden;
+ }
+ // klass's superclass didn't override it, check for an override in
+ // klass.
+ try {
+ Class[] classes = new Class[1];
+ classes[0] = InputMethodEvent.class;
+
+ Method m = klass.getDeclaredMethod("processInputMethodEvent",
+ classes);
+ retValue = Boolean.TRUE;
+ } catch (NoSuchMethodException nsme) {
+ retValue = Boolean.FALSE;
+ }
+ overrideMap.put(klass.getName(), retValue);
+ return retValue;
+ }
+
+ /**
+ * Fetches the current color used to render the
+ * caret.
+ *
+ * @return the color
+ */
+ public Color getCaretColor() {
+ return caretColor;
+ }
+
+ /**
+ * Sets the current color used to render the caret.
+ * Setting to <code>null</code> effectively restores the default color.
+ * Setting the color results in a PropertyChange event ("caretColor")
+ * being fired.
+ *
+ * @param c the color
+ * @see #getCaretColor
+ * @beaninfo
+ * description: the color used to render the caret
+ * bound: true
+ * preferred: true
+ */
+ public void setCaretColor(Color c) {
+ Color old = caretColor;
+ caretColor = c;
+ firePropertyChange("caretColor", old, caretColor);
+ }
+
+ /**
+ * Fetches the current color used to render the
+ * selection.
+ *
+ * @return the color
+ */
+ public Color getSelectionColor() {
+ return selectionColor;
+ }
+
+ /**
+ * Sets the current color used to render the selection.
+ * Setting the color to <code>null</code> is the same as setting
+ * <code>Color.white</code>. Setting the color results in a
+ * PropertyChange event ("selectionColor").
+ *
+ * @param c the color
+ * @see #getSelectionColor
+ * @beaninfo
+ * description: color used to render selection background
+ * bound: true
+ * preferred: true
+ */
+ public void setSelectionColor(Color c) {
+ Color old = selectionColor;
+ selectionColor = c;
+ firePropertyChange("selectionColor", old, selectionColor);
+ }
+
+ /**
+ * Fetches the current color used to render the
+ * selected text.
+ *
+ * @return the color
+ */
+ public Color getSelectedTextColor() {
+ return selectedTextColor;
+ }
+
+ /**
+ * Sets the current color used to render the selected text.
+ * Setting the color to <code>null</code> is the same as
+ * <code>Color.black</code>. Setting the color results in a
+ * PropertyChange event ("selectedTextColor") being fired.
+ *
+ * @param c the color
+ * @see #getSelectedTextColor
+ * @beaninfo
+ * description: color used to render selected text
+ * bound: true
+ * preferred: true
+ */
+ public void setSelectedTextColor(Color c) {
+ Color old = selectedTextColor;
+ selectedTextColor = c;
+ firePropertyChange("selectedTextColor", old, selectedTextColor);
+ }
+
+ /**
+ * Fetches the current color used to render the
+ * disabled text.
+ *
+ * @return the color
+ */
+ public Color getDisabledTextColor() {
+ return disabledTextColor;
+ }
+
+ /**
+ * Sets the current color used to render the
+ * disabled text. Setting the color fires off a
+ * PropertyChange event ("disabledTextColor").
+ *
+ * @param c the color
+ * @see #getDisabledTextColor
+ * @beaninfo
+ * description: color used to render disabled text
+ * bound: true
+ * preferred: true
+ */
+ public void setDisabledTextColor(Color c) {
+ Color old = disabledTextColor;
+ disabledTextColor = c;
+ firePropertyChange("disabledTextColor", old, disabledTextColor);
+ }
+
+ /**
+ * Replaces the currently selected content with new content
+ * represented by the given string. If there is no selection
+ * this amounts to an insert of the given text. If there
+ * is no replacement text this amounts to a removal of the
+ * current selection.
+ * <p>
+ * This is the method that is used by the default implementation
+ * of the action for inserting content that gets bound to the
+ * keymap actions.
+ * <p>
+ * This method is thread safe, although most Swing methods
+ * are not. Please see
+ * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How
+ * to Use Threads</A> for more information.
+ *
+ * @param content the content to replace the selection with
+ */
+ public void replaceSelection(String content) {
+ Document doc = getDocument();
+ if (doc != null) {
+ try {
+ boolean composedTextSaved = saveComposedText(caret.getDot());
+ int p0 = Math.min(caret.getDot(), caret.getMark());
+ int p1 = Math.max(caret.getDot(), caret.getMark());
+ if (doc instanceof AbstractDocument) {
+ ((AbstractDocument)doc).replace(p0, p1 - p0, content,null);
+ }
+ else {
+ if (p0 != p1) {
+ doc.remove(p0, p1 - p0);
+ }
+ if (content != null && content.length() > 0) {
+ doc.insertString(p0, content, null);
+ }
+ }
+ if (composedTextSaved) {
+ restoreComposedText();
+ }
+ } catch (BadLocationException e) {
+ UIManager.getLookAndFeel().provideErrorFeedback(JTextComponent.this);
+ }
+ }
+ }
+
+ /**
+ * Fetches a portion of the text represented by the
+ * component. Returns an empty string if length is 0.
+ *
+ * @param offs the offset >= 0
+ * @param len the length >= 0
+ * @return the text
+ * @exception BadLocationException if the offset or length are invalid
+ */
+ public String getText(int offs, int len) throws BadLocationException {
+ return getDocument().getText(offs, len);
+ }
+
+ /**
+ * Converts the given location in the model to a place in
+ * the view coordinate system.
+ * The component must have a positive size for
+ * this translation to be computed (i.e. layout cannot
+ * be computed until the component has been sized). The
+ * component does not have to be visible or painted.
+ *
+ * @param pos the position >= 0
+ * @return the coordinates as a rectangle, with (r.x, r.y) as the location
+ * in the coordinate system, or null if the component does
+ * not yet have a positive size.
+ * @exception BadLocationException if the given position does not
+ * represent a valid location in the associated document
+ * @see TextUI#modelToView
+ */
+ public Rectangle modelToView(int pos) throws BadLocationException {
+ return getUI().modelToView(this, pos);
+ }
+
+ /**
+ * Converts the given place in the view coordinate system
+ * to the nearest representative location in the model.
+ * The component must have a positive size for
+ * this translation to be computed (i.e. layout cannot
+ * be computed until the component has been sized). The
+ * component does not have to be visible or painted.
+ *
+ * @param pt the location in the view to translate
+ * @return the offset >= 0 from the start of the document,
+ * or -1 if the component does not yet have a positive
+ * size.
+ * @see TextUI#viewToModel
+ */
+ public int viewToModel(Point pt) {
+ return getUI().viewToModel(this, pt);
+ }
+
+ /**
+ * Transfers the currently selected range in the associated
+ * text model to the system clipboard, removing the contents
+ * from the model. The current selection is reset. Does nothing
+ * for <code>null</code> selections.
+ *
+ * @see java.awt.Toolkit#getSystemClipboard
+ * @see java.awt.datatransfer.Clipboard
+ */
+ public void cut() {
+ if (isEditable() && isEnabled()) {
+ invokeAction("cut", TransferHandler.getCutAction());
+ }
+ }
+
+ /**
+ * Transfers the currently selected range in the associated
+ * text model to the system clipboard, leaving the contents
+ * in the text model. The current selection remains intact.
+ * Does nothing for <code>null</code> selections.
+ *
+ * @see java.awt.Toolkit#getSystemClipboard
+ * @see java.awt.datatransfer.Clipboard
+ */
+ public void copy() {
+ invokeAction("copy", TransferHandler.getCopyAction());
+ }
+
+ /**
+ * Transfers the contents of the system clipboard into the
+ * associated text model. If there is a selection in the
+ * associated view, it is replaced with the contents of the
+ * clipboard. If there is no selection, the clipboard contents
+ * are inserted in front of the current insert position in
+ * the associated view. If the clipboard is empty, does nothing.
+ *
+ * @see #replaceSelection
+ * @see java.awt.Toolkit#getSystemClipboard
+ * @see java.awt.datatransfer.Clipboard
+ */
+ public void paste() {
+ if (isEditable() && isEnabled()) {
+ invokeAction("paste", TransferHandler.getPasteAction());
+ }
+ }
+
+ /**
+ * This is a conveniance method that is only useful for
+ * <code>cut</code>, <code>copy</code> and <code>paste</code>. If
+ * an <code>Action</code> with the name <code>name</code> does not
+ * exist in the <code>ActionMap</code>, this will attemp to install a
+ * <code>TransferHandler</code> and then use <code>altAction</code>.
+ */
+ private void invokeAction(String name, Action altAction) {
+ ActionMap map = getActionMap();
+ Action action = null;
+
+ if (map != null) {
+ action = map.get(name);
+ }
+ if (action == null) {
+ installDefaultTransferHandlerIfNecessary();
+ action = altAction;
+ }
+ action.actionPerformed(new ActionEvent(this,
+ ActionEvent.ACTION_PERFORMED, (String)action.
+ getValue(Action.NAME),
+ EventQueue.getMostRecentEventTime(),
+ getCurrentEventModifiers()));
+ }
+
+ /**
+ * If the current <code>TransferHandler</code> is null, this will
+ * install a new one.
+ */
+ private void installDefaultTransferHandlerIfNecessary() {
+ if (getTransferHandler() == null) {
+ if (defaultTransferHandler == null) {
+ defaultTransferHandler = new DefaultTransferHandler();
+ }
+ setTransferHandler(defaultTransferHandler);
+ }
+ }
+
+ /**
+ * Moves the caret to a new position, leaving behind a mark
+ * defined by the last time <code>setCaretPosition</code> was
+ * called. This forms a selection.
+ * If the document is <code>null</code>, does nothing. The position
+ * must be between 0 and the length of the component's text or else
+ * an exception is thrown.
+ *
+ * @param pos the position
+ * @exception IllegalArgumentException if the value supplied
+ * for <code>position</code> is less than zero or greater
+ * than the component's text length
+ * @see #setCaretPosition
+ */
+ public void moveCaretPosition(int pos) {
+ Document doc = getDocument();
+ if (doc != null) {
+ if (pos > doc.getLength() || pos < 0) {
+ throw new IllegalArgumentException("bad position: " + pos);
+ }
+ caret.moveDot(pos);
+ }
+ }
+
+ /**
+ * The bound property name for the focus accelerator.
+ */
+ public static final String FOCUS_ACCELERATOR_KEY = "focusAcceleratorKey";
+
+ /**
+ * Sets the key accelerator that will cause the receiving text
+ * component to get the focus. The accelerator will be the
+ * key combination of the <em>alt</em> key and the character
+ * given (converted to upper case). By default, there is no focus
+ * accelerator key. Any previous key accelerator setting will be
+ * superseded. A '\0' key setting will be registered, and has the
+ * effect of turning off the focus accelerator. When the new key
+ * is set, a PropertyChange event (FOCUS_ACCELERATOR_KEY) will be fired.
+ *
+ * @param aKey the key
+ * @see #getFocusAccelerator
+ * @beaninfo
+ * description: accelerator character used to grab focus
+ * bound: true
+ */
+ public void setFocusAccelerator(char aKey) {
+ aKey = Character.toUpperCase(aKey);
+ char old = focusAccelerator;
+ focusAccelerator = aKey;
+ // Fix for 4341002: value of FOCUS_ACCELERATOR_KEY is wrong.
+ // So we fire both FOCUS_ACCELERATOR_KEY, for compatibility,
+ // and the correct event here.
+ firePropertyChange(FOCUS_ACCELERATOR_KEY, old, focusAccelerator);
+ firePropertyChange("focusAccelerator", old, focusAccelerator);
+ }
+
+ /**
+ * Returns the key accelerator that will cause the receiving
+ * text component to get the focus. Return '\0' if no focus
+ * accelerator has been set.
+ *
+ * @return the key
+ */
+ public char getFocusAccelerator() {
+ return focusAccelerator;
+ }
+
+ /**
+ * Initializes from a stream. This creates a
+ * model of the type appropriate for the component
+ * and initializes the model from the stream.
+ * By default this will load the model as plain
+ * text. Previous contents of the model are discarded.
+ *
+ * @param in the stream to read from
+ * @param desc an object describing the stream; this
+ * might be a string, a File, a URL, etc. Some kinds
+ * of documents (such as html for example) might be
+ * able to make use of this information; if non-<code>null</code>,
+ * it is added as a property of the document
+ * @exception IOException as thrown by the stream being
+ * used to initialize
+ * @see EditorKit#createDefaultDocument
+ * @see #setDocument
+ * @see PlainDocument
+ */
+ public void read(Reader in, Object desc) throws IOException {
+ EditorKit kit = getUI().getEditorKit(this);
+ Document doc = kit.createDefaultDocument();
+ if (desc != null) {
+ doc.putProperty(Document.StreamDescriptionProperty, desc);
+ }
+ try {
+ kit.read(in, doc, 0);
+ setDocument(doc);
+ } catch (BadLocationException e) {
+ throw new IOException(e.getMessage());
+ }
+ }
+
+ /**
+ * Stores the contents of the model into the given
+ * stream. By default this will store the model as plain
+ * text.
+ *
+ * @param out the output stream
+ * @exception IOException on any I/O error
+ */
+ public void write(Writer out) throws IOException {
+ Document doc = getDocument();
+ try {
+ getUI().getEditorKit(this).write(out, doc, 0, doc.getLength());
+ } catch (BadLocationException e) {
+ throw new IOException(e.getMessage());
+ }
+ }
+
+ public void removeNotify() {
+ super.removeNotify();
+ if (getFocusedComponent() == this) {
+ AppContext.getAppContext().remove(FOCUSED_COMPONENT);
+ }
+ }
+
+ // --- java.awt.TextComponent methods ------------------------
+
+ /**
+ * Sets the position of the text insertion caret for the
+ * <code>TextComponent</code>. Note that the caret tracks change,
+ * so this may move if the underlying text of the component is changed.
+ * If the document is <code>null</code>, does nothing. The position
+ * must be between 0 and the length of the component's text or else
+ * an exception is thrown.
+ *
+ * @param position the position
+ * @exception IllegalArgumentException if the value supplied
+ * for <code>position</code> is less than zero or greater
+ * than the component's text length
+ * @beaninfo
+ * description: the caret position
+ */
+ public void setCaretPosition(int position) {
+ Document doc = getDocument();
+ if (doc != null) {
+ if (position > doc.getLength() || position < 0) {
+ throw new IllegalArgumentException("bad position: " + position);
+ }
+ caret.setDot(position);
+ }
+ }
+
+ /**
+ * Returns the position of the text insertion caret for the
+ * text component.
+ *
+ * @return the position of the text insertion caret for the
+ * text component >= 0
+ */
+ public int getCaretPosition() {
+ return caret.getDot();
+ }
+
+ /**
+ * Sets the text of this <code>TextComponent</code>
+ * to the specified text. If the text is <code>null</code>
+ * or empty, has the effect of simply deleting the old text.
+ * When text has been inserted, the resulting caret location
+ * is determined by the implementation of the caret class.
+ * <p>
+ * This method is thread safe, although most Swing methods
+ * are not. Please see
+ * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How
+ * to Use Threads</A> for more information.
+ *
+ * Note that text is not a bound property, so no <code>PropertyChangeEvent
+ * </code> is fired when it changes. To listen for changes to the text,
+ * use <code>DocumentListener</code>.
+ *
+ * @param t the new text to be set
+ * @see #getText
+ * @see DefaultCaret
+ * @beaninfo
+ * description: the text of this component
+ */
+ public void setText(String t) {
+ try {
+ Document doc = getDocument();
+ if (doc instanceof AbstractDocument) {
+ ((AbstractDocument)doc).replace(0, doc.getLength(), t,null);
+ }
+ else {
+ doc.remove(0, doc.getLength());
+ doc.insertString(0, t, null);
+ }
+ } catch (BadLocationException e) {
+ UIManager.getLookAndFeel().provideErrorFeedback(JTextComponent.this);
+ }
+ }
+
+ /**
+ * Returns the text contained in this <code>TextComponent</code>.
+ * If the underlying document is <code>null</code>,
+ * will give a <code>NullPointerException</code>.
+ *
+ * Note that text is not a bound property, so no <code>PropertyChangeEvent
+ * </code> is fired when it changes. To listen for changes to the text,
+ * use <code>DocumentListener</code>.
+ *
+ * @return the text
+ * @exception NullPointerException if the document is <code>null</code>
+ * @see #setText
+ */
+ public String getText() {
+ Document doc = getDocument();
+ String txt;
+ try {
+ txt = doc.getText(0, doc.getLength());
+ } catch (BadLocationException e) {
+ txt = null;
+ }
+ return txt;
+ }
+
+ /**
+ * Returns the selected text contained in this
+ * <code>TextComponent</code>. If the selection is
+ * <code>null</code> or the document empty, returns <code>null</code>.
+ *
+ * @return the text
+ * @exception IllegalArgumentException if the selection doesn't
+ * have a valid mapping into the document for some reason
+ * @see #setText
+ */
+ public String getSelectedText() {
+ String txt = null;
+ int p0 = Math.min(caret.getDot(), caret.getMark());
+ int p1 = Math.max(caret.getDot(), caret.getMark());
+ if (p0 != p1) {
+ try {
+ Document doc = getDocument();
+ txt = doc.getText(p0, p1 - p0);
+ } catch (BadLocationException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+ return txt;
+ }
+
+ /**
+ * Returns the boolean indicating whether this
+ * <code>TextComponent</code> is editable or not.
+ *
+ * @return the boolean value
+ * @see #setEditable
+ */
+ public boolean isEditable() {
+ return editable;
+ }
+
+ /**
+ * Sets the specified boolean to indicate whether or not this
+ * <code>TextComponent</code> should be editable.
+ * A PropertyChange event ("editable") is fired when the
+ * state is changed.
+ *
+ * @param b the boolean to be set
+ * @see #isEditable
+ * @beaninfo
+ * description: specifies if the text can be edited
+ * bound: true
+ */
+ public void setEditable(boolean b) {
+ if (b != editable) {
+ boolean oldVal = editable;
+ editable = b;
+ enableInputMethods(editable);
+ firePropertyChange("editable", Boolean.valueOf(oldVal), Boolean.valueOf(editable));
+ repaint();
+ }
+ }
+
+ /**
+ * Returns the selected text's start position. Return 0 for an
+ * empty document, or the value of dot if no selection.
+ *
+ * @return the start position >= 0
+ */
+ public int getSelectionStart() {
+ int start = Math.min(caret.getDot(), caret.getMark());
+ return start;
+ }
+
+ /**
+ * Sets the selection start to the specified position. The new
+ * starting point is constrained to be before or at the current
+ * selection end.
+ * <p>
+ * This is available for backward compatibility to code
+ * that called this method on <code>java.awt.TextComponent</code>.
+ * This is implemented to forward to the <code>Caret</code>
+ * implementation which is where the actual selection is maintained.
+ *
+ * @param selectionStart the start position of the text >= 0
+ * @beaninfo
+ * description: starting location of the selection.
+ */
+ public void setSelectionStart(int selectionStart) {
+ /* Route through select method to enforce consistent policy
+ * between selectionStart and selectionEnd.
+ */
+ select(selectionStart, getSelectionEnd());
+ }
+
+ /**
+ * Returns the selected text's end position. Return 0 if the document
+ * is empty, or the value of dot if there is no selection.
+ *
+ * @return the end position >= 0
+ */
+ public int getSelectionEnd() {
+ int end = Math.max(caret.getDot(), caret.getMark());
+ return end;
+ }
+
+ /**
+ * Sets the selection end to the specified position. The new
+ * end point is constrained to be at or after the current
+ * selection start.
+ * <p>
+ * This is available for backward compatibility to code
+ * that called this method on <code>java.awt.TextComponent</code>.
+ * This is implemented to forward to the <code>Caret</code>
+ * implementation which is where the actual selection is maintained.
+ *
+ * @param selectionEnd the end position of the text >= 0
+ * @beaninfo
+ * description: ending location of the selection.
+ */
+ public void setSelectionEnd(int selectionEnd) {
+ /* Route through select method to enforce consistent policy
+ * between selectionStart and selectionEnd.
+ */
+ select(getSelectionStart(), selectionEnd);
+ }
+
+ /**
+ * Selects the text between the specified start and end positions.
+ * <p>
+ * This method sets the start and end positions of the
+ * selected text, enforcing the restriction that the start position
+ * must be greater than or equal to zero. The end position must be
+ * greater than or equal to the start position, and less than or
+ * equal to the length of the text component's text.
+ * <p>
+ * If the caller supplies values that are inconsistent or out of
+ * bounds, the method enforces these constraints silently, and
+ * without failure. Specifically, if the start position or end
+ * position is greater than the length of the text, it is reset to
+ * equal the text length. If the start position is less than zero,
+ * it is reset to zero, and if the end position is less than the
+ * start position, it is reset to the start position.
+ * <p>
+ * This call is provided for backward compatibility.
+ * It is routed to a call to <code>setCaretPosition</code>
+ * followed by a call to <code>moveCaretPosition</code>.
+ * The preferred way to manage selection is by calling
+ * those methods directly.
+ *
+ * @param selectionStart the start position of the text
+ * @param selectionEnd the end position of the text
+ * @see #setCaretPosition
+ * @see #moveCaretPosition
+ */
+ public void select(int selectionStart, int selectionEnd) {
+ // argument adjustment done by java.awt.TextComponent
+ int docLength = getDocument().getLength();
+
+ if (selectionStart < 0) {
+ selectionStart = 0;
+ }
+ if (selectionStart > docLength) {
+ selectionStart = docLength;
+ }
+ if (selectionEnd > docLength) {
+ selectionEnd = docLength;
+ }
+ if (selectionEnd < selectionStart) {
+ selectionEnd = selectionStart;
+ }
+
+ setCaretPosition(selectionStart);
+ moveCaretPosition(selectionEnd);
+ }
+
+ /**
+ * Selects all the text in the <code>TextComponent</code>.
+ * Does nothing on a <code>null</code> or empty document.
+ */
+ public void selectAll() {
+ Document doc = getDocument();
+ if (doc != null) {
+ setCaretPosition(0);
+ moveCaretPosition(doc.getLength());
+ }
+ }
+
+ // --- Tooltip Methods ---------------------------------------------
+
+ /**
+ * Returns the string to be used as the tooltip for <code>event</code>.
+ * This will return one of:
+ * <ol>
+ * <li>If <code>setToolTipText</code> has been invoked with a
+ * non-<code>null</code>
+ * value, it will be returned, otherwise
+ * <li>The value from invoking <code>getToolTipText</code> on
+ * the UI will be returned.
+ * </ol>
+ * By default <code>JTextComponent</code> does not register
+ * itself with the <code>ToolTipManager</code>.
+ * This means that tooltips will NOT be shown from the
+ * <code>TextUI</code> unless <code>registerComponent</code> has
+ * been invoked on the <code>ToolTipManager</code>.
+ *
+ * @param event the event in question
+ * @return the string to be used as the tooltip for <code>event</code>
+ * @see javax.swing.JComponent#setToolTipText
+ * @see javax.swing.plaf.TextUI#getToolTipText
+ * @see javax.swing.ToolTipManager#registerComponent
+ */
+ public String getToolTipText(MouseEvent event) {
+ String retValue = super.getToolTipText(event);
+
+ if (retValue == null) {
+ TextUI ui = getUI();
+ if (ui != null) {
+ retValue = ui.getToolTipText(this, new Point(event.getX(),
+ event.getY()));
+ }
+ }
+ return retValue;
+ }
+
+ // --- Scrollable methods ---------------------------------------------
+
+ /**
+ * Returns the preferred size of the viewport for a view component.
+ * This is implemented to do the default behavior of returning
+ * the preferred size of the component.
+ *
+ * @return the <code>preferredSize</code> of a <code>JViewport</code>
+ * whose view is this <code>Scrollable</code>
+ */
+ public Dimension getPreferredScrollableViewportSize() {
+ return getPreferredSize();
+ }
+
+
+ /**
+ * Components that display logical rows or columns should compute
+ * the scroll increment that will completely expose one new row
+ * or column, depending on the value of orientation. Ideally,
+ * components should handle a partially exposed row or column by
+ * returning the distance required to completely expose the item.
+ * <p>
+ * The default implementation of this is to simply return 10% of
+ * the visible area. Subclasses are likely to be able to provide
+ * a much more reasonable value.
+ *
+ * @param visibleRect the view area visible within the viewport
+ * @param orientation either <code>SwingConstants.VERTICAL</code> or
+ * <code>SwingConstants.HORIZONTAL</code>
+ * @param direction less than zero to scroll up/left, greater than
+ * zero for down/right
+ * @return the "unit" increment for scrolling in the specified direction
+ * @exception IllegalArgumentException for an invalid orientation
+ * @see JScrollBar#setUnitIncrement
+ */
+ public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
+ switch(orientation) {
+ case SwingConstants.VERTICAL:
+ return visibleRect.height / 10;
+ case SwingConstants.HORIZONTAL:
+ return visibleRect.width / 10;
+ default:
+ throw new IllegalArgumentException("Invalid orientation: " + orientation);
+ }
+ }
+
+
+ /**
+ * Components that display logical rows or columns should compute
+ * the scroll increment that will completely expose one block
+ * of rows or columns, depending on the value of orientation.
+ * <p>
+ * The default implementation of this is to simply return the visible
+ * area. Subclasses will likely be able to provide a much more
+ * reasonable value.
+ *
+ * @param visibleRect the view area visible within the viewport
+ * @param orientation either <code>SwingConstants.VERTICAL</code> or
+ * <code>SwingConstants.HORIZONTAL</code>
+ * @param direction less than zero to scroll up/left, greater than zero
+ * for down/right
+ * @return the "block" increment for scrolling in the specified direction
+ * @exception IllegalArgumentException for an invalid orientation
+ * @see JScrollBar#setBlockIncrement
+ */
+ public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
+ switch(orientation) {
+ case SwingConstants.VERTICAL:
+ return visibleRect.height;
+ case SwingConstants.HORIZONTAL:
+ return visibleRect.width;
+ default:
+ throw new IllegalArgumentException("Invalid orientation: " + orientation);
+ }
+ }
+
+
+ /**
+ * Returns true if a viewport should always force the width of this
+ * <code>Scrollable</code> to match the width of the viewport.
+ * For example a normal text view that supported line wrapping
+ * would return true here, since it would be undesirable for
+ * wrapped lines to disappear beyond the right
+ * edge of the viewport. Note that returning true for a
+ * <code>Scrollable</code> whose ancestor is a <code>JScrollPane</code>
+ * effectively disables horizontal scrolling.
+ * <p>
+ * Scrolling containers, like <code>JViewport</code>,
+ * will use this method each time they are validated.
+ *
+ * @return true if a viewport should force the <code>Scrollable</code>s
+ * width to match its own
+ */
+ public boolean getScrollableTracksViewportWidth() {
+ if (getParent() instanceof JViewport) {
+ return (((JViewport)getParent()).getWidth() > getPreferredSize().width);
+ }
+ return false;
+ }
+
+ /**
+ * Returns true if a viewport should always force the height of this
+ * <code>Scrollable</code> to match the height of the viewport.
+ * For example a columnar text view that flowed text in left to
+ * right columns could effectively disable vertical scrolling by
+ * returning true here.
+ * <p>
+ * Scrolling containers, like <code>JViewport</code>,
+ * will use this method each time they are validated.
+ *
+ * @return true if a viewport should force the Scrollables height
+ * to match its own
+ */
+ public boolean getScrollableTracksViewportHeight() {
+ if (getParent() instanceof JViewport) {
+ return (((JViewport)getParent()).getHeight() > getPreferredSize().height);
+ }
+ return false;
+ }
+
+
+//////////////////
+// Printing Support
+//////////////////
+
+ /**
+ * A convenience print method that displays a print dialog, and then
+ * prints this {@code JTextComponent} in <i>interactive</i> mode with no
+ * header or footer text. Note: this method
+ * blocks until printing is done.
+ * <p>
+ * Note: In <i>headless</i> mode, no dialogs will be shown.
+ *
+ * <p> This method calls the full featured
+ * {@link #print(MessageFormat, MessageFormat, boolean, PrintService, PrintRequestAttributeSet, boolean)
+ * print} method to perform printing.
+ * @return {@code true}, unless printing is canceled by the user
+ * @throws PrinterException if an error in the print system causes the job
+ * to be aborted
+ * @throws SecurityException if this thread is not allowed to
+ * initiate a print job request
+ *
+ * @see #print(MessageFormat, MessageFormat, boolean, PrintService, PrintRequestAttributeSet, boolean)
+ *
+ * @since 1.6
+ */
+
+ public boolean print() throws PrinterException {
+ return print(null, null, true, null, null, true);
+ }
+
+ /**
+ * A convenience print method that displays a print dialog, and then
+ * prints this {@code JTextComponent} in <i>interactive</i> mode with
+ * the specified header and footer text. Note: this method
+ * blocks until printing is done.
+ * <p>
+ * Note: In <i>headless</i> mode, no dialogs will be shown.
+ *
+ * <p> This method calls the full featured
+ * {@link #print(MessageFormat, MessageFormat, boolean, PrintService, PrintRequestAttributeSet, boolean)
+ * print} method to perform printing.
+ * @param headerFormat the text, in {@code MessageFormat}, to be
+ * used as the header, or {@code null} for no header
+ * @param footerFormat the text, in {@code MessageFormat}, to be
+ * used as the footer, or {@code null} for no footer
+ * @return {@code true}, unless printing is canceled by the user
+ * @throws PrinterException if an error in the print system causes the job
+ * to be aborted
+ * @throws SecurityException if this thread is not allowed to
+ * initiate a print job request
+ *
+ * @see #print(MessageFormat, MessageFormat, boolean, PrintService, PrintRequestAttributeSet, boolean)
+ * @see java.text.MessageFormat
+ * @since 1.6
+ */
+ public boolean print(final MessageFormat headerFormat,
+ final MessageFormat footerFormat) throws PrinterException {
+ return print(headerFormat, footerFormat, true, null, null, true);
+ }
+
+ /**
+ * Prints the content of this {@code JTextComponent}. Note: this method
+ * blocks until printing is done.
+ *
+ * <p>
+ * Page header and footer text can be added to the output by providing
+ * {@code MessageFormat} arguments. The printing code requests
+ * {@code Strings} from the formats, providing a single item which may be
+ * included in the formatted string: an {@code Integer} representing the
+ * current page number.
+ *
+ * <p>
+ * {@code showPrintDialog boolean} parameter allows you to specify whether
+ * a print dialog is displayed to the user. When it is, the user
+ * may use the dialog to change printing attributes or even cancel the
+ * print.
+ *
+ * <p>
+ * {@code service} allows you to provide the initial
+ * {@code PrintService} for the print dialog, or to specify
+ * {@code PrintService} to print to when the dialog is not shown.
+ *
+ * <p>
+ * {@code attributes} can be used to provide the
+ * initial values for the print dialog, or to supply any needed
+ * attributes when the dialog is not shown. {@code attributes} can
+ * be used to control how the job will print, for example
+ * <i>duplex</i> or <i>single-sided</i>.
+ *
+ * <p>
+ * {@code interactive boolean} parameter allows you to specify
+ * whether to perform printing in <i>interactive</i>
+ * mode. If {@code true}, a progress dialog, with an abort option,
+ * is displayed for the duration of printing. This dialog is
+ * <i>modal</i> when {@code print} is invoked on the <i>Event Dispatch
+ * Thread</i> and <i>non-modal</i> otherwise. <b>Warning</b>:
+ * calling this method on the <i>Event Dispatch Thread</i> with {@code
+ * interactive false} blocks <i>all</i> events, including repaints, from
+ * being processed until printing is complete. It is only
+ * recommended when printing from an application with no
+ * visible GUI.
+ *
+ * <p>
+ * Note: In <i>headless</i> mode, {@code showPrintDialog} and
+ * {@code interactive} parameters are ignored and no dialogs are
+ * shown.
+ *
+ * <p>
+ * This method ensures the {@code document} is not mutated during printing.
+ * To indicate it visually, {@code setEnabled(false)} is set for the
+ * duration of printing.
+ *
+ * <p>
+ * This method uses {@link #getPrintable} to render document content.
+ *
+ * <p>
+ * This method is thread-safe, although most Swing methods are not. Please
+ * see <A
+ * HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">
+ * How to Use Threads</A> for more information.
+ *
+ * <p>
+ * <b>Sample Usage</b>. This code snippet shows a cross-platform print
+ * dialog and then prints the {@code JTextComponent} in <i>interactive</i> mode
+ * unless the user cancels the dialog:
+ *
+ * <pre>
+ * textComponent.print(new MessageFormat("My text component header"),
+ * new MessageFormat("Footer. Page - {0}"), true, null, null, true);
+ * </pre>
+ * <p>
+ * Executing this code off the <i>Event Dispatch Thread</i>
+ * performs printing on the <i>background</i>.
+ * The following pattern might be used for <i>background</i>
+ * printing:
+ * <pre>
+ * FutureTask<Boolean> future =
+ * new FutureTask<Boolean>(
+ * new Callable<Boolean>() {
+ * public Boolean call() {
+ * return textComponent.print(.....);
+ * }
+ * });
+ * executor.execute(future);
+ * </pre>
+ *
+ * @param headerFormat the text, in {@code MessageFormat}, to be
+ * used as the header, or {@code null} for no header
+ * @param footerFormat the text, in {@code MessageFormat}, to be
+ * used as the footer, or {@code null} for no footer
+ * @param showPrintDialog {@code true} to display a print dialog,
+ * {@code false} otherwise
+ * @param service initial {@code PrintService}, or {@code null} for the
+ * default
+ * @param attributes the job attributes to be applied to the print job, or
+ * {@code null} for none
+ * @param interactive whether to print in an interactive mode
+ * @return {@code true}, unless printing is canceled by the user
+ * @throws PrinterException if an error in the print system causes the job
+ * to be aborted
+ * @throws SecurityException if this thread is not allowed to
+ * initiate a print job request
+ *
+ * @see #getPrintable
+ * @see java.text.MessageFormat
+ * @see java.awt.GraphicsEnvironment#isHeadless
+ * @see java.util.concurrent.FutureTask
+ *
+ * @since 1.6
+ */
+ public boolean print(final MessageFormat headerFormat,
+ final MessageFormat footerFormat,
+ final boolean showPrintDialog,
+ final PrintService service,
+ final PrintRequestAttributeSet attributes,
+ final boolean interactive)
+ throws PrinterException {
+
+ final PrinterJob job = PrinterJob.getPrinterJob();
+ final Printable printable;
+ final PrintingStatus printingStatus;
+ final boolean isHeadless = GraphicsEnvironment.isHeadless();
+ final boolean isEventDispatchThread =
+ SwingUtilities.isEventDispatchThread();
+ final Printable textPrintable = getPrintable(headerFormat, footerFormat);
+ if (interactive && ! isHeadless) {
+ printingStatus =
+ PrintingStatus.createPrintingStatus(this, job);
+ printable =
+ printingStatus.createNotificationPrintable(textPrintable);
+ } else {
+ printingStatus = null;
+ printable = textPrintable;
+ }
+
+ if (service != null) {
+ job.setPrintService(service);
+ }
+
+ job.setPrintable(printable);
+
+ final PrintRequestAttributeSet attr = (attributes == null)
+ ? new HashPrintRequestAttributeSet()
+ : attributes;
+
+ if (showPrintDialog && ! isHeadless && ! job.printDialog(attr)) {
+ return false;
+ }
+
+ /*
+ * there are three cases for printing:
+ * 1. print non interactively (! interactive || isHeadless)
+ * 2. print interactively off EDT
+ * 3. print interactively on EDT
+ *
+ * 1 and 2 prints on the current thread (3 prints on another thread)
+ * 2 and 3 deal with PrintingStatusDialog
+ */
+ final Callable<Object> doPrint =
+ new Callable<Object>() {
+ public Object call() throws Exception {
+ try {
+ job.print(attr);
+ } finally {
+ if (printingStatus != null) {
+ printingStatus.dispose();
+ }
+ }
+ return null;
+ }
+ };
+
+ final FutureTask<Object> futurePrinting =
+ new FutureTask<Object>(doPrint);
+
+ final Runnable runnablePrinting =
+ new Runnable() {
+ public void run() {
+ //disable component
+ boolean wasEnabled = false;
+ if (isEventDispatchThread) {
+ if (isEnabled()) {
+ wasEnabled = true;
+ setEnabled(false);
+ }
+ } else {
+ try {
+ wasEnabled = SwingUtilities2.submit(
+ new Callable<Boolean>() {
+ public Boolean call() throws Exception {
+ boolean rv = isEnabled();
+ if (rv) {
+ setEnabled(false);
+ }
+ return rv;
+ }
+ }).get();
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ } catch (ExecutionException e) {
+ Throwable cause = e.getCause();
+ if (cause instanceof Error) {
+ throw (Error) cause;
+ }
+ if (cause instanceof RuntimeException) {
+ throw (RuntimeException) cause;
+ }
+ throw new AssertionError(cause);
+ }
+ }
+
+ getDocument().render(futurePrinting);
+
+ //enable component
+ if (wasEnabled) {
+ if (isEventDispatchThread) {
+ setEnabled(true);
+ } else {
+ try {
+ SwingUtilities2.submit(
+ new Runnable() {
+ public void run() {
+ setEnabled(true);
+ }
+ }, null).get();
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ } catch (ExecutionException e) {
+ Throwable cause = e.getCause();
+ if (cause instanceof Error) {
+ throw (Error) cause;
+ }
+ if (cause instanceof RuntimeException) {
+ throw (RuntimeException) cause;
+ }
+ throw new AssertionError(cause);
+ }
+ }
+ }
+ }
+ };
+
+ if (! interactive || isHeadless) {
+ runnablePrinting.run();
+ } else {
+ if (isEventDispatchThread) {
+ (new Thread(runnablePrinting)).start();
+ printingStatus.showModal(true);
+ } else {
+ printingStatus.showModal(false);
+ runnablePrinting.run();
+ }
+ }
+
+ //the printing is done successfully or otherwise.
+ //dialog is hidden if needed.
+ try {
+ futurePrinting.get();
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ } catch (ExecutionException e) {
+ Throwable cause = e.getCause();
+ if (cause instanceof PrinterAbortException) {
+ if (printingStatus != null
+ && printingStatus.isAborted()) {
+ return false;
+ } else {
+ throw (PrinterAbortException) cause;
+ }
+ } else if (cause instanceof PrinterException) {
+ throw (PrinterException) cause;
+ } else if (cause instanceof RuntimeException) {
+ throw (RuntimeException) cause;
+ } else if (cause instanceof Error) {
+ throw (Error) cause;
+ } else {
+ throw new AssertionError(cause);
+ }
+ }
+ return true;
+ }
+
+
+ /**
+ * Returns a {@code Printable} to use for printing the content of this
+ * {@code JTextComponent}. The returned {@code Printable} prints
+ * the document as it looks on the screen except being reformatted
+ * to fit the paper.
+ * The returned {@code Printable} can be wrapped inside another
+ * {@code Printable} in order to create complex reports and
+ * documents.
+ *
+ *
+ * <p>
+ * The returned {@code Printable} shares the {@code document} with this
+ * {@code JTextComponent}. It is the responsibility of the developer to
+ * ensure that the {@code document} is not mutated while this {@code Printable}
+ * is used. Printing behavior is undefined when the {@code document} is
+ * mutated during printing.
+ *
+ * <p>
+ * Page header and footer text can be added to the output by providing
+ * {@code MessageFormat} arguments. The printing code requests
+ * {@code Strings} from the formats, providing a single item which may be
+ * included in the formatted string: an {@code Integer} representing the
+ * current page number.
+ *
+ * <p>
+ * The returned {@code Printable} when printed, formats the
+ * document content appropriately for the page size. For correct
+ * line wrapping the {@code imageable width} of all pages must be the
+ * same. See {@link java.awt.print.PageFormat#getImageableWidth}.
+ *
+ * <p>
+ * This method is thread-safe, although most Swing methods are not. Please
+ * see <A
+ * HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">
+ * How to Use Threads</A> for more information.
+ *
+ * <p>
+ * The returned {@code Printable} can be printed on any thread.
+ *
+ * <p>
+ * This implementation returned {@code Printable} performs all painting on
+ * the <i>Event Dispatch Thread</i>, regardless of what thread it is
+ * used on.
+ *
+ * @param headerFormat the text, in {@code MessageFormat}, to be
+ * used as the header, or {@code null} for no header
+ * @param footerFormat the text, in {@code MessageFormat}, to be
+ * used as the footer, or {@code null} for no footer
+ * @return a {@code Printable} for use in printing content of this
+ * {@code JTextComponent}
+ *
+ *
+ * @see java.awt.print.Printable
+ * @see java.awt.print.PageFormat
+ * @see javax.swing.text.Document#render(java.lang.Runnable)
+ *
+ * @since 1.6
+ */
+ public Printable getPrintable(final MessageFormat headerFormat,
+ final MessageFormat footerFormat) {
+ return TextComponentPrintable.getPrintable(
+ this, headerFormat, footerFormat);
+ }
+
+
+/////////////////
+// Accessibility support
+////////////////
+
+
+ /**
+ * Gets the <code>AccessibleContext</code> associated with this
+ * <code>JTextComponent</code>. For text components,
+ * the <code>AccessibleContext</code> takes the form of an
+ * <code>AccessibleJTextComponent</code>.
+ * A new <code>AccessibleJTextComponent</code> instance
+ * is created if necessary.
+ *
+ * @return an <code>AccessibleJTextComponent</code> that serves as the
+ * <code>AccessibleContext</code> of this
+ * <code>JTextComponent</code>
+ */
+ public AccessibleContext getAccessibleContext() {
+ if (accessibleContext == null) {
+ accessibleContext = new AccessibleJTextComponent();
+ }
+ return accessibleContext;
+ }
+
+ /**
+ * This class implements accessibility support for the
+ * <code>JTextComponent</code> class. It provides an implementation of
+ * the Java Accessibility API appropriate to menu user-interface elements.
+ * <p>
+ * <strong>Warning:</strong>
+ * Serialized objects of this class will not be compatible with
+ * future Swing releases. The current serialization support is
+ * appropriate for short term storage or RMI between applications running
+ * the same version of Swing. As of 1.4, support for long term storage
+ * of all JavaBeans<sup><font size="-2">TM</font></sup>
+ * has been added to the <code>java.beans</code> package.
+ * Please see {@link java.beans.XMLEncoder}.
+ */
+ public class AccessibleJTextComponent extends AccessibleJComponent
+ implements AccessibleText, CaretListener, DocumentListener,
+ AccessibleAction, AccessibleEditableText,
+ AccessibleExtendedText {
+
+ int caretPos;
+ Point oldLocationOnScreen;
+
+ /**
+ * Constructs an AccessibleJTextComponent. Adds a listener to track
+ * caret change.
+ */
+ public AccessibleJTextComponent() {
+ Document doc = JTextComponent.this.getDocument();
+ if (doc != null) {
+ doc.addDocumentListener(this);
+ }
+ JTextComponent.this.addCaretListener(this);
+ caretPos = getCaretPosition();
+
+ try {
+ oldLocationOnScreen = getLocationOnScreen();
+ } catch (IllegalComponentStateException iae) {
+ }
+
+ // Fire a ACCESSIBLE_VISIBLE_DATA_PROPERTY PropertyChangeEvent
+ // when the text component moves (e.g., when scrolling).
+ // Using an anonymous class since making AccessibleJTextComponent
+ // implement ComponentListener would be an API change.
+ JTextComponent.this.addComponentListener(new ComponentAdapter() {
+
+ public void componentMoved(ComponentEvent e) {
+ try {
+ Point newLocationOnScreen = getLocationOnScreen();
+ firePropertyChange(ACCESSIBLE_VISIBLE_DATA_PROPERTY,
+ oldLocationOnScreen,
+ newLocationOnScreen);
+
+ oldLocationOnScreen = newLocationOnScreen;
+ } catch (IllegalComponentStateException iae) {
+ }
+ }
+ });
+ }
+
+ /**
+ * Handles caret updates (fire appropriate property change event,
+ * which are AccessibleContext.ACCESSIBLE_CARET_PROPERTY and
+ * AccessibleContext.ACCESSIBLE_SELECTION_PROPERTY).
+ * This keeps track of the dot position internally. When the caret
+ * moves, the internal position is updated after firing the event.
+ *
+ * @param e the CaretEvent
+ */
+ public void caretUpdate(CaretEvent e) {
+ int dot = e.getDot();
+ int mark = e.getMark();
+ if (caretPos != dot) {
+ // the caret moved
+ firePropertyChange(ACCESSIBLE_CARET_PROPERTY,
+ new Integer(caretPos), new Integer(dot));
+ caretPos = dot;
+
+ try {
+ oldLocationOnScreen = getLocationOnScreen();
+ } catch (IllegalComponentStateException iae) {
+ }
+ }
+ if (mark != dot) {
+ // there is a selection
+ firePropertyChange(ACCESSIBLE_SELECTION_PROPERTY, null,
+ getSelectedText());
+ }
+ }
+
+ // DocumentListener methods
+
+ /**
+ * Handles document insert (fire appropriate property change event
+ * which is AccessibleContext.ACCESSIBLE_TEXT_PROPERTY).
+ * This tracks the changed offset via the event.
+ *
+ * @param e the DocumentEvent
+ */
+ public void insertUpdate(DocumentEvent e) {
+ final Integer pos = new Integer (e.getOffset());
+ if (SwingUtilities.isEventDispatchThread()) {
+ firePropertyChange(ACCESSIBLE_TEXT_PROPERTY, null, pos);
+ } else {
+ Runnable doFire = new Runnable() {
+ public void run() {
+ firePropertyChange(ACCESSIBLE_TEXT_PROPERTY,
+ null, pos);
+ }
+ };
+ SwingUtilities.invokeLater(doFire);
+ }
+ }
+
+ /**
+ * Handles document remove (fire appropriate property change event,
+ * which is AccessibleContext.ACCESSIBLE_TEXT_PROPERTY).
+ * This tracks the changed offset via the event.
+ *
+ * @param e the DocumentEvent
+ */
+ public void removeUpdate(DocumentEvent e) {
+ final Integer pos = new Integer (e.getOffset());
+ if (SwingUtilities.isEventDispatchThread()) {
+ firePropertyChange(ACCESSIBLE_TEXT_PROPERTY, null, pos);
+ } else {
+ Runnable doFire = new Runnable() {
+ public void run() {
+ firePropertyChange(ACCESSIBLE_TEXT_PROPERTY,
+ null, pos);
+ }
+ };
+ SwingUtilities.invokeLater(doFire);
+ }
+ }
+
+ /**
+ * Handles document remove (fire appropriate property change event,
+ * which is AccessibleContext.ACCESSIBLE_TEXT_PROPERTY).
+ * This tracks the changed offset via the event.
+ *
+ * @param e the DocumentEvent
+ */
+ public void changedUpdate(DocumentEvent e) {
+ final Integer pos = new Integer (e.getOffset());
+ if (SwingUtilities.isEventDispatchThread()) {
+ firePropertyChange(ACCESSIBLE_TEXT_PROPERTY, null, pos);
+ } else {
+ Runnable doFire = new Runnable() {
+ public void run() {
+ firePropertyChange(ACCESSIBLE_TEXT_PROPERTY,
+ null, pos);
+ }
+ };
+ SwingUtilities.invokeLater(doFire);
+ }
+ }
+
+ /**
+ * Gets the state set of the JTextComponent.
+ * The AccessibleStateSet of an object is composed of a set of
+ * unique AccessibleState's. A change in the AccessibleStateSet
+ * of an object will cause a PropertyChangeEvent to be fired
+ * for the AccessibleContext.ACCESSIBLE_STATE_PROPERTY property.
+ *
+ * @return an instance of AccessibleStateSet containing the
+ * current state set of the object
+ * @see AccessibleStateSet
+ * @see AccessibleState
+ * @see #addPropertyChangeListener
+ */
+ public AccessibleStateSet getAccessibleStateSet() {
+ AccessibleStateSet states = super.getAccessibleStateSet();
+ if (JTextComponent.this.isEditable()) {
+ states.add(AccessibleState.EDITABLE);
+ }
+ return states;
+ }
+
+
+ /**
+ * Gets the role of this object.
+ *
+ * @return an instance of AccessibleRole describing the role of the
+ * object (AccessibleRole.TEXT)
+ * @see AccessibleRole
+ */
+ public AccessibleRole getAccessibleRole() {
+ return AccessibleRole.TEXT;
+ }
+
+ /**
+ * Get the AccessibleText associated with this object. In the
+ * implementation of the Java Accessibility API for this class,
+ * return this object, which is responsible for implementing the
+ * AccessibleText interface on behalf of itself.
+ *
+ * @return this object
+ */
+ public AccessibleText getAccessibleText() {
+ return this;
+ }
+
+
+ // --- interface AccessibleText methods ------------------------
+
+ /**
+ * Many of these methods are just convenience methods; they
+ * just call the equivalent on the parent
+ */
+
+ /**
+ * Given a point in local coordinates, return the zero-based index
+ * of the character under that Point. If the point is invalid,
+ * this method returns -1.
+ *
+ * @param p the Point in local coordinates
+ * @return the zero-based index of the character under Point p.
+ */
+ public int getIndexAtPoint(Point p) {
+ if (p == null) {
+ return -1;
+ }
+ return JTextComponent.this.viewToModel(p);
+ }
+
+ /**
+ * Gets the editor's drawing rectangle. Stolen
+ * from the unfortunately named
+ * BasicTextUI.getVisibleEditorRect()
+ *
+ * @return the bounding box for the root view
+ */
+ Rectangle getRootEditorRect() {
+ Rectangle alloc = JTextComponent.this.getBounds();
+ if ((alloc.width > 0) && (alloc.height > 0)) {
+ alloc.x = alloc.y = 0;
+ Insets insets = JTextComponent.this.getInsets();
+ alloc.x += insets.left;
+ alloc.y += insets.top;
+ alloc.width -= insets.left + insets.right;
+ alloc.height -= insets.top + insets.bottom;
+ return alloc;
+ }
+ return null;
+ }
+
+ /**
+ * Determines the bounding box of the character at the given
+ * index into the string. The bounds are returned in local
+ * coordinates. If the index is invalid a null rectangle
+ * is returned.
+ *
+ * The screen coordinates returned are "unscrolled coordinates"
+ * if the JTextComponent is contained in a JScrollPane in which
+ * case the resulting rectangle should be composed with the parent
+ * coordinates. A good algorithm to use is:
+ * <nf>
+ * Accessible a:
+ * AccessibleText at = a.getAccessibleText();
+ * AccessibleComponent ac = a.getAccessibleComponent();
+ * Rectangle r = at.getCharacterBounds();
+ * Point p = ac.getLocation();
+ * r.x += p.x;
+ * r.y += p.y;
+ * </nf>
+ *
+ * Note: the JTextComponent must have a valid size (e.g. have
+ * been added to a parent container whose ancestor container
+ * is a valid top-level window) for this method to be able
+ * to return a meaningful (non-null) value.
+ *
+ * @param i the index into the String >= 0
+ * @return the screen coordinates of the character's bounding box
+ */
+ public Rectangle getCharacterBounds(int i) {
+ if (i < 0 || i > model.getLength()-1) {
+ return null;
+ }
+ TextUI ui = getUI();
+ if (ui == null) {
+ return null;
+ }
+ Rectangle rect = null;
+ Rectangle alloc = getRootEditorRect();
+ if (alloc == null) {
+ return null;
+ }
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readLock();
+ }
+ try {
+ View rootView = ui.getRootView(JTextComponent.this);
+ if (rootView != null) {
+ rootView.setSize(alloc.width, alloc.height);
+
+ Shape bounds = rootView.modelToView(i,
+ Position.Bias.Forward, i+1,
+ Position.Bias.Backward, alloc);
+
+ rect = (bounds instanceof Rectangle) ?
+ (Rectangle)bounds : bounds.getBounds();
+
+ }
+ } catch (BadLocationException e) {
+ } finally {
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readUnlock();
+ }
+ }
+ return rect;
+ }
+
+ /**
+ * Returns the number of characters (valid indices)
+ *
+ * @return the number of characters >= 0
+ */
+ public int getCharCount() {
+ return model.getLength();
+ }
+
+ /**
+ * Returns the zero-based offset of the caret.
+ *
+ * Note: The character to the right of the caret will have the
+ * same index value as the offset (the caret is between
+ * two characters).
+ *
+ * @return the zero-based offset of the caret.
+ */
+ public int getCaretPosition() {
+ return JTextComponent.this.getCaretPosition();
+ }
+
+ /**
+ * Returns the AttributeSet for a given character (at a given index).
+ *
+ * @param i the zero-based index into the text
+ * @return the AttributeSet of the character
+ */
+ public AttributeSet getCharacterAttribute(int i) {
+ Element e = null;
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readLock();
+ }
+ try {
+ for (e = model.getDefaultRootElement(); ! e.isLeaf(); ) {
+ int index = e.getElementIndex(i);
+ e = e.getElement(index);
+ }
+ } finally {
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readUnlock();
+ }
+ }
+ return e.getAttributes();
+ }
+
+
+ /**
+ * Returns the start offset within the selected text.
+ * If there is no selection, but there is
+ * a caret, the start and end offsets will be the same.
+ * Return 0 if the text is empty, or the caret position
+ * if no selection.
+ *
+ * @return the index into the text of the start of the selection >= 0
+ */
+ public int getSelectionStart() {
+ return JTextComponent.this.getSelectionStart();
+ }
+
+ /**
+ * Returns the end offset within the selected text.
+ * If there is no selection, but there is
+ * a caret, the start and end offsets will be the same.
+ * Return 0 if the text is empty, or the caret position
+ * if no selection.
+ *
+ * @return the index into teh text of the end of the selection >= 0
+ */
+ public int getSelectionEnd() {
+ return JTextComponent.this.getSelectionEnd();
+ }
+
+ /**
+ * Returns the portion of the text that is selected.
+ *
+ * @return the text, null if no selection
+ */
+ public String getSelectedText() {
+ return JTextComponent.this.getSelectedText();
+ }
+
+ /**
+ * IndexedSegment extends Segment adding the offset into the
+ * the model the <code>Segment</code> was asked for.
+ */
+ private class IndexedSegment extends Segment {
+ /**
+ * Offset into the model that the position represents.
+ */
+ public int modelOffset;
+ }
+
+
+ // TIGER - 4170173
+ /**
+ * Returns the String at a given index. Whitespace
+ * between words is treated as a word.
+ *
+ * @param part the CHARACTER, WORD, or SENTENCE to retrieve
+ * @param index an index within the text
+ * @return the letter, word, or sentence.
+ *
+ */
+ public String getAtIndex(int part, int index) {
+ return getAtIndex(part, index, 0);
+ }
+
+
+ /**
+ * Returns the String after a given index. Whitespace
+ * between words is treated as a word.
+ *
+ * @param part the CHARACTER, WORD, or SENTENCE to retrieve
+ * @param index an index within the text
+ * @return the letter, word, or sentence.
+ */
+ public String getAfterIndex(int part, int index) {
+ return getAtIndex(part, index, 1);
+ }
+
+
+ /**
+ * Returns the String before a given index. Whitespace
+ * between words is treated a word.
+ *
+ * @param part the CHARACTER, WORD, or SENTENCE to retrieve
+ * @param index an index within the text
+ * @return the letter, word, or sentence.
+ */
+ public String getBeforeIndex(int part, int index) {
+ return getAtIndex(part, index, -1);
+ }
+
+
+ /**
+ * Gets the word, sentence, or character at <code>index</code>.
+ * If <code>direction</code> is non-null this will find the
+ * next/previous word/sentence/character.
+ */
+ private String getAtIndex(int part, int index, int direction) {
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readLock();
+ }
+ try {
+ if (index < 0 || index >= model.getLength()) {
+ return null;
+ }
+ switch (part) {
+ case AccessibleText.CHARACTER:
+ if (index + direction < model.getLength() &&
+ index + direction >= 0) {
+ return model.getText(index + direction, 1);
+ }
+ break;
+
+
+ case AccessibleText.WORD:
+ case AccessibleText.SENTENCE:
+ IndexedSegment seg = getSegmentAt(part, index);
+ if (seg != null) {
+ if (direction != 0) {
+ int next;
+
+
+ if (direction < 0) {
+ next = seg.modelOffset - 1;
+ }
+ else {
+ next = seg.modelOffset + direction * seg.count;
+ }
+ if (next >= 0 && next <= model.getLength()) {
+ seg = getSegmentAt(part, next);
+ }
+ else {
+ seg = null;
+ }
+ }
+ if (seg != null) {
+ return new String(seg.array, seg.offset,
+ seg.count);
+ }
+ }
+ break;
+
+
+ default:
+ break;
+ }
+ } catch (BadLocationException e) {
+ } finally {
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readUnlock();
+ }
+ }
+ return null;
+ }
+
+
+ /*
+ * Returns the paragraph element for the specified index.
+ */
+ private Element getParagraphElement(int index) {
+ if (model instanceof PlainDocument ) {
+ PlainDocument sdoc = (PlainDocument)model;
+ return sdoc.getParagraphElement(index);
+ } else if (model instanceof StyledDocument) {
+ StyledDocument sdoc = (StyledDocument)model;
+ return sdoc.getParagraphElement(index);
+ } else {
+ Element para = null;
+ for (para = model.getDefaultRootElement(); ! para.isLeaf(); ) {
+ int pos = para.getElementIndex(index);
+ para = para.getElement(pos);
+ }
+ if (para == null) {
+ return null;
+ }
+ return para.getParentElement();
+ }
+ }
+
+ /*
+ * Returns a <code>Segment</code> containing the paragraph text
+ * at <code>index</code>, or null if <code>index</code> isn't
+ * valid.
+ */
+ private IndexedSegment getParagraphElementText(int index)
+ throws BadLocationException {
+ Element para = getParagraphElement(index);
+
+
+ if (para != null) {
+ IndexedSegment segment = new IndexedSegment();
+ try {
+ int length = para.getEndOffset() - para.getStartOffset();
+ model.getText(para.getStartOffset(), length, segment);
+ } catch (BadLocationException e) {
+ return null;
+ }
+ segment.modelOffset = para.getStartOffset();
+ return segment;
+ }
+ return null;
+ }
+
+
+ /**
+ * Returns the Segment at <code>index</code> representing either
+ * the paragraph or sentence as identified by <code>part</code>, or
+ * null if a valid paragraph/sentence can't be found. The offset
+ * will point to the start of the word/sentence in the array, and
+ * the modelOffset will point to the location of the word/sentence
+ * in the model.
+ */
+ private IndexedSegment getSegmentAt(int part, int index) throws
+ BadLocationException {
+ IndexedSegment seg = getParagraphElementText(index);
+ if (seg == null) {
+ return null;
+ }
+ BreakIterator iterator;
+ switch (part) {
+ case AccessibleText.WORD:
+ iterator = BreakIterator.getWordInstance(getLocale());
+ break;
+ case AccessibleText.SENTENCE:
+ iterator = BreakIterator.getSentenceInstance(getLocale());
+ break;
+ default:
+ return null;
+ }
+ seg.first();
+ iterator.setText(seg);
+ int end = iterator.following(index - seg.modelOffset + seg.offset);
+ if (end == BreakIterator.DONE) {
+ return null;
+ }
+ if (end > seg.offset + seg.count) {
+ return null;
+ }
+ int begin = iterator.previous();
+ if (begin == BreakIterator.DONE ||
+ begin >= seg.offset + seg.count) {
+ return null;
+ }
+ seg.modelOffset = seg.modelOffset + begin - seg.offset;
+ seg.offset = begin;
+ seg.count = end - begin;
+ return seg;
+ }
+
+ // begin AccessibleEditableText methods -----
+
+ /**
+ * Returns the AccessibleEditableText interface for
+ * this text component.
+ *
+ * @return the AccessibleEditableText interface
+ * @since 1.4
+ */
+ public AccessibleEditableText getAccessibleEditableText() {
+ return this;
+ }
+
+ /**
+ * Sets the text contents to the specified string.
+ *
+ * @param s the string to set the text contents
+ * @since 1.4
+ */
+ public void setTextContents(String s) {
+ JTextComponent.this.setText(s);
+ }
+
+ /**
+ * Inserts the specified string at the given index
+ *
+ * @param index the index in the text where the string will
+ * be inserted
+ * @param s the string to insert in the text
+ * @since 1.4
+ */
+ public void insertTextAtIndex(int index, String s) {
+ Document doc = JTextComponent.this.getDocument();
+ if (doc != null) {
+ try {
+ if (s != null && s.length() > 0) {
+ boolean composedTextSaved = saveComposedText(index);
+ doc.insertString(index, s, null);
+ if (composedTextSaved) {
+ restoreComposedText();
+ }
+ }
+ } catch (BadLocationException e) {
+ UIManager.getLookAndFeel().provideErrorFeedback(JTextComponent.this);
+ }
+ }
+ }
+
+ /**
+ * Returns the text string between two indices.
+ *
+ * @param startIndex the starting index in the text
+ * @param endIndex the ending index in the text
+ * @return the text string between the indices
+ * @since 1.4
+ */
+ public String getTextRange(int startIndex, int endIndex) {
+ String txt = null;
+ int p0 = Math.min(startIndex, endIndex);
+ int p1 = Math.max(startIndex, endIndex);
+ if (p0 != p1) {
+ try {
+ Document doc = JTextComponent.this.getDocument();
+ txt = doc.getText(p0, p1 - p0);
+ } catch (BadLocationException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+ return txt;
+ }
+
+ /**
+ * Deletes the text between two indices
+ *
+ * @param startIndex the starting index in the text
+ * @param endIndex the ending index in the text
+ * @since 1.4
+ */
+ public void delete(int startIndex, int endIndex) {
+ if (isEditable() && isEnabled()) {
+ try {
+ int p0 = Math.min(startIndex, endIndex);
+ int p1 = Math.max(startIndex, endIndex);
+ if (p0 != p1) {
+ Document doc = getDocument();
+ doc.remove(p0, p1 - p0);
+ }
+ } catch (BadLocationException e) {
+ }
+ } else {
+ UIManager.getLookAndFeel().provideErrorFeedback(JTextComponent.this);
+ }
+ }
+
+ /**
+ * Cuts the text between two indices into the system clipboard.
+ *
+ * @param startIndex the starting index in the text
+ * @param endIndex the ending index in the text
+ * @since 1.4
+ */
+ public void cut(int startIndex, int endIndex) {
+ selectText(startIndex, endIndex);
+ JTextComponent.this.cut();
+ }
+
+ /**
+ * Pastes the text from the system clipboard into the text
+ * starting at the specified index.
+ *
+ * @param startIndex the starting index in the text
+ * @since 1.4
+ */
+ public void paste(int startIndex) {
+ setCaretPosition(startIndex);
+ JTextComponent.this.paste();
+ }
+
+ /**
+ * Replaces the text between two indices with the specified
+ * string.
+ *
+ * @param startIndex the starting index in the text
+ * @param endIndex the ending index in the text
+ * @param s the string to replace the text between two indices
+ * @since 1.4
+ */
+ public void replaceText(int startIndex, int endIndex, String s) {
+ selectText(startIndex, endIndex);
+ JTextComponent.this.replaceSelection(s);
+ }
+
+ /**
+ * Selects the text between two indices.
+ *
+ * @param startIndex the starting index in the text
+ * @param endIndex the ending index in the text
+ * @since 1.4
+ */
+ public void selectText(int startIndex, int endIndex) {
+ JTextComponent.this.select(startIndex, endIndex);
+ }
+
+ /**
+ * Sets attributes for the text between two indices.
+ *
+ * @param startIndex the starting index in the text
+ * @param endIndex the ending index in the text
+ * @param as the attribute set
+ * @see AttributeSet
+ * @since 1.4
+ */
+ public void setAttributes(int startIndex, int endIndex,
+ AttributeSet as) {
+
+ // Fixes bug 4487492
+ Document doc = JTextComponent.this.getDocument();
+ if (doc != null && doc instanceof StyledDocument) {
+ StyledDocument sDoc = (StyledDocument)doc;
+ int offset = startIndex;
+ int length = endIndex - startIndex;
+ sDoc.setCharacterAttributes(offset, length, as, true);
+ }
+ }
+
+ // ----- end AccessibleEditableText methods
+
+
+ // ----- begin AccessibleExtendedText methods
+
+// Probably should replace the helper method getAtIndex() to return
+// instead an AccessibleTextSequence also for LINE & ATTRIBUTE_RUN
+// and then make the AccessibleText methods get[At|After|Before]Point
+// call this new method instead and return only the string portion
+
+ /**
+ * Returns the AccessibleTextSequence at a given <code>index</code>.
+ * If <code>direction</code> is non-null this will find the
+ * next/previous word/sentence/character.
+ *
+ * @param part the <code>CHARACTER</code>, <code>WORD</code>,
+ * <code>SENTENCE</code>, <code>LINE</code> or
+ * <code>ATTRIBUTE_RUN</code> to retrieve
+ * @param index an index within the text
+ * @param direction is either -1, 0, or 1
+ * @return an <code>AccessibleTextSequence</code> specifying the text
+ * if <code>part</code> and <code>index</code> are valid. Otherwise,
+ * <code>null</code> is returned.
+ *
+ * @see javax.accessibility.AccessibleText#CHARACTER
+ * @see javax.accessibility.AccessibleText#WORD
+ * @see javax.accessibility.AccessibleText#SENTENCE
+ * @see javax.accessibility.AccessibleExtendedText#LINE
+ * @see javax.accessibility.AccessibleExtendedText#ATTRIBUTE_RUN
+ *
+ * @since 1.6
+ */
+ private AccessibleTextSequence getSequenceAtIndex(int part,
+ int index, int direction) {
+ if (index < 0 || index >= model.getLength()) {
+ return null;
+ }
+ if (direction < -1 || direction > 1) {
+ return null; // direction must be 1, 0, or -1
+ }
+
+ switch (part) {
+ case AccessibleText.CHARACTER:
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readLock();
+ }
+ AccessibleTextSequence charSequence = null;
+ try {
+ if (index + direction < model.getLength() &&
+ index + direction >= 0) {
+ charSequence =
+ new AccessibleTextSequence(index + direction,
+ index + direction + 1,
+ model.getText(index + direction, 1));
+ }
+
+ } catch (BadLocationException e) {
+ // we are intentionally silent; our contract says we return
+ // null if there is any failure in this method
+ } finally {
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readUnlock();
+ }
+ }
+ return charSequence;
+
+ case AccessibleText.WORD:
+ case AccessibleText.SENTENCE:
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readLock();
+ }
+ AccessibleTextSequence rangeSequence = null;
+ try {
+ IndexedSegment seg = getSegmentAt(part, index);
+ if (seg != null) {
+ if (direction != 0) {
+ int next;
+
+ if (direction < 0) {
+ next = seg.modelOffset - 1;
+ }
+ else {
+ next = seg.modelOffset + seg.count;
+ }
+ if (next >= 0 && next <= model.getLength()) {
+ seg = getSegmentAt(part, next);
+ }
+ else {
+ seg = null;
+ }
+ }
+ if (seg != null &&
+ (seg.offset + seg.count) <= model.getLength()) {
+ rangeSequence =
+ new AccessibleTextSequence (seg.offset,
+ seg.offset + seg.count,
+ new String(seg.array, seg.offset, seg.count));
+ } // else we leave rangeSequence set to null
+ }
+ } catch(BadLocationException e) {
+ // we are intentionally silent; our contract says we return
+ // null if there is any failure in this method
+ } finally {
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readUnlock();
+ }
+ }
+ return rangeSequence;
+
+ case AccessibleExtendedText.LINE:
+ AccessibleTextSequence lineSequence = null;
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readLock();
+ }
+ try {
+ int startIndex =
+ Utilities.getRowStart(JTextComponent.this, index);
+ int endIndex =
+ Utilities.getRowEnd(JTextComponent.this, index);
+ if (startIndex >= 0 && endIndex >= startIndex) {
+ if (direction == 0) {
+ lineSequence =
+ new AccessibleTextSequence(startIndex, endIndex,
+ model.getText(startIndex,
+ endIndex - startIndex + 1));
+ } else if (direction == -1 && startIndex > 0) {
+ endIndex =
+ Utilities.getRowEnd(JTextComponent.this,
+ startIndex - 1);
+ startIndex =
+ Utilities.getRowStart(JTextComponent.this,
+ startIndex - 1);
+ if (startIndex >= 0 && endIndex >= startIndex) {
+ lineSequence =
+ new AccessibleTextSequence(startIndex,
+ endIndex,
+ model.getText(startIndex,
+ endIndex - startIndex + 1));
+ }
+ } else if (direction == 1 &&
+ endIndex < model.getLength()) {
+ startIndex =
+ Utilities.getRowStart(JTextComponent.this,
+ endIndex + 1);
+ endIndex =
+ Utilities.getRowEnd(JTextComponent.this,
+ endIndex + 1);
+ if (startIndex >= 0 && endIndex >= startIndex) {
+ lineSequence =
+ new AccessibleTextSequence(startIndex,
+ endIndex, model.getText(startIndex,
+ endIndex - startIndex + 1));
+ }
+ }
+ // already validated 'direction' above...
+ }
+ } catch(BadLocationException e) {
+ // we are intentionally silent; our contract says we return
+ // null if there is any failure in this method
+ } finally {
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readUnlock();
+ }
+ }
+ return lineSequence;
+
+ case AccessibleExtendedText.ATTRIBUTE_RUN:
+ // assumptions: (1) that all characters in a single element
+ // share the same attribute set; (2) that adjacent elements
+ // *may* share the same attribute set
+
+ int attributeRunStartIndex, attributeRunEndIndex;
+ String runText = null;
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readLock();
+ }
+
+ try {
+ attributeRunStartIndex = attributeRunEndIndex =
+ Integer.MIN_VALUE;
+ int tempIndex = index;
+ switch (direction) {
+ case -1:
+ // going backwards, so find left edge of this run -
+ // that'll be the end of the previous run
+ // (off-by-one counting)
+ attributeRunEndIndex = getRunEdge(index, direction);
+ // now set ourselves up to find the left edge of the
+ // prev. run
+ tempIndex = attributeRunEndIndex - 1;
+ break;
+ case 1:
+ // going forward, so find right edge of this run -
+ // that'll be the start of the next run
+ // (off-by-one counting)
+ attributeRunStartIndex = getRunEdge(index, direction);
+ // now set ourselves up to find the right edge of the
+ // next run
+ tempIndex = attributeRunStartIndex;
+ break;
+ case 0:
+ // interested in the current run, so nothing special to
+ // set up in advance...
+ break;
+ default:
+ // only those three values of direction allowed...
+ throw new AssertionError(direction);
+ }
+
+ // set the unset edge; if neither set then we're getting
+ // both edges of the current run around our 'index'
+ attributeRunStartIndex =
+ (attributeRunStartIndex != Integer.MIN_VALUE) ?
+ attributeRunStartIndex : getRunEdge(tempIndex, -1);
+ attributeRunEndIndex =
+ (attributeRunEndIndex != Integer.MIN_VALUE) ?
+ attributeRunEndIndex : getRunEdge(tempIndex, 1);
+
+ runText = model.getText(attributeRunStartIndex,
+ attributeRunEndIndex -
+ attributeRunStartIndex);
+ } catch (BadLocationException e) {
+ // we are intentionally silent; our contract says we return
+ // null if there is any failure in this method
+ return null;
+ } finally {
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readUnlock();
+ }
+ }
+ return new AccessibleTextSequence(attributeRunStartIndex,
+ attributeRunEndIndex,
+ runText);
+
+ default:
+ break;
+ }
+ return null;
+ }
+
+
+ /**
+ * Starting at text position <code>index</code>, and going in
+ * <code>direction</code>, return the edge of run that shares the
+ * same <code>AttributeSet</code> and parent element as those at
+ * <code>index</code>.
+ *
+ * Note: we assume the document is already locked...
+ */
+ private int getRunEdge(int index, int direction) throws
+ BadLocationException {
+ if (index < 0 || index >= model.getLength()) {
+ throw new BadLocationException("Location out of bounds", index);
+ }
+ // locate the Element at index
+ Element indexElement = null;
+ // locate the Element at our index/offset
+ int elementIndex = -1; // test for initialization
+ for (indexElement = model.getDefaultRootElement();
+ ! indexElement.isLeaf(); ) {
+ elementIndex = indexElement.getElementIndex(index);
+ indexElement = indexElement.getElement(elementIndex);
+ }
+ if (elementIndex == -1) {
+ throw new AssertionError(index);
+ }
+ // cache the AttributeSet and parentElement atindex
+ AttributeSet indexAS = indexElement.getAttributes();
+ Element parent = indexElement.getParentElement();
+
+ // find the first Element before/after ours w/the same AttributeSet
+ // if we are already at edge of the first element in our parent
+ // then return that edge
+ Element edgeElement = indexElement;
+ switch (direction) {
+ case -1:
+ case 1:
+ int edgeElementIndex = elementIndex;
+ int elementCount = parent.getElementCount();
+ while ((edgeElementIndex + direction) > 0 &&
+ ((edgeElementIndex + direction) < elementCount) &&
+ parent.getElement(edgeElementIndex
+ + direction).getAttributes().isEqual(indexAS)) {
+ edgeElementIndex += direction;
+ }
+ edgeElement = parent.getElement(edgeElementIndex);
+ break;
+ default:
+ throw new AssertionError(direction);
+ }
+ switch (direction) {
+ case -1:
+ return edgeElement.getStartOffset();
+ case 1:
+ return edgeElement.getEndOffset();
+ default:
+ // we already caught this case earlier; this is to satisfy
+ // the compiler...
+ return Integer.MIN_VALUE;
+ }
+ }
+
+ // getTextRange() not needed; defined in AccessibleEditableText
+
+ /**
+ * Returns the <code>AccessibleTextSequence</code> at a given
+ * <code>index</code>.
+ *
+ * @param part the <code>CHARACTER</code>, <code>WORD</code>,
+ * <code>SENTENCE</code>, <code>LINE</code> or
+ * <code>ATTRIBUTE_RUN</code> to retrieve
+ * @param index an index within the text
+ * @return an <code>AccessibleTextSequence</code> specifying the text if
+ * <code>part</code> and <code>index</code> are valid. Otherwise,
+ * <code>null</code> is returned
+ *
+ * @see javax.accessibility.AccessibleText#CHARACTER
+ * @see javax.accessibility.AccessibleText#WORD
+ * @see javax.accessibility.AccessibleText#SENTENCE
+ * @see javax.accessibility.AccessibleExtendedText#LINE
+ * @see javax.accessibility.AccessibleExtendedText#ATTRIBUTE_RUN
+ *
+ * @since 1.6
+ */
+ public AccessibleTextSequence getTextSequenceAt(int part, int index) {
+ return getSequenceAtIndex(part, index, 0);
+ }
+
+ /**
+ * Returns the <code>AccessibleTextSequence</code> after a given
+ * <code>index</code>.
+ *
+ * @param part the <code>CHARACTER</code>, <code>WORD</code>,
+ * <code>SENTENCE</code>, <code>LINE</code> or
+ * <code>ATTRIBUTE_RUN</code> to retrieve
+ * @param index an index within the text
+ * @return an <code>AccessibleTextSequence</code> specifying the text
+ * if <code>part</code> and <code>index</code> are valid. Otherwise,
+ * <code>null</code> is returned
+ *
+ * @see javax.accessibility.AccessibleText#CHARACTER
+ * @see javax.accessibility.AccessibleText#WORD
+ * @see javax.accessibility.AccessibleText#SENTENCE
+ * @see javax.accessibility.AccessibleExtendedText#LINE
+ * @see javax.accessibility.AccessibleExtendedText#ATTRIBUTE_RUN
+ *
+ * @since 1.6
+ */
+ public AccessibleTextSequence getTextSequenceAfter(int part, int index) {
+ return getSequenceAtIndex(part, index, 1);
+ }
+
+ /**
+ * Returns the <code>AccessibleTextSequence</code> before a given
+ * <code>index</code>.
+ *
+ * @param part the <code>CHARACTER</code>, <code>WORD</code>,
+ * <code>SENTENCE</code>, <code>LINE</code> or
+ * <code>ATTRIBUTE_RUN</code> to retrieve
+ * @param index an index within the text
+ * @return an <code>AccessibleTextSequence</code> specifying the text
+ * if <code>part</code> and <code>index</code> are valid. Otherwise,
+ * <code>null</code> is returned
+ *
+ * @see javax.accessibility.AccessibleText#CHARACTER
+ * @see javax.accessibility.AccessibleText#WORD
+ * @see javax.accessibility.AccessibleText#SENTENCE
+ * @see javax.accessibility.AccessibleExtendedText#LINE
+ * @see javax.accessibility.AccessibleExtendedText#ATTRIBUTE_RUN
+ *
+ * @since 1.6
+ */
+ public AccessibleTextSequence getTextSequenceBefore(int part, int index) {
+ return getSequenceAtIndex(part, index, -1);
+ }
+
+ /**
+ * Returns the <code>Rectangle</code> enclosing the text between
+ * two indicies.
+ *
+ * @param startIndex the start index in the text
+ * @param endIndex the end index in the text
+ * @return the bounding rectangle of the text if the indices are valid.
+ * Otherwise, <code>null</code> is returned
+ *
+ * @since 1.6
+ */
+ public Rectangle getTextBounds(int startIndex, int endIndex) {
+ if (startIndex < 0 || startIndex > model.getLength()-1 ||
+ endIndex < 0 || endIndex > model.getLength()-1 ||
+ startIndex > endIndex) {
+ return null;
+ }
+ TextUI ui = getUI();
+ if (ui == null) {
+ return null;
+ }
+ Rectangle rect = null;
+ Rectangle alloc = getRootEditorRect();
+ if (alloc == null) {
+ return null;
+ }
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readLock();
+ }
+ try {
+ View rootView = ui.getRootView(JTextComponent.this);
+ if (rootView != null) {
+ Shape bounds = rootView.modelToView(startIndex,
+ Position.Bias.Forward, endIndex,
+ Position.Bias.Backward, alloc);
+
+ rect = (bounds instanceof Rectangle) ?
+ (Rectangle)bounds : bounds.getBounds();
+
+ }
+ } catch (BadLocationException e) {
+ } finally {
+ if (model instanceof AbstractDocument) {
+ ((AbstractDocument)model).readUnlock();
+ }
+ }
+ return rect;
+ }
+
+ // ----- end AccessibleExtendedText methods
+
+
+ // --- interface AccessibleAction methods ------------------------
+
+ public AccessibleAction getAccessibleAction() {
+ return this;
+ }
+
+ /**
+ * Returns the number of accessible actions available in this object
+ * If there are more than one, the first one is considered the
+ * "default" action of the object.
+ *
+ * @return the zero-based number of Actions in this object
+ * @since 1.4
+ */
+ public int getAccessibleActionCount() {
+ Action [] actions = JTextComponent.this.getActions();
+ return actions.length;
+ }
+
+ /**
+ * Returns a description of the specified action of the object.
+ *
+ * @param i zero-based index of the actions
+ * @return a String description of the action
+ * @see #getAccessibleActionCount
+ * @since 1.4
+ */
+ public String getAccessibleActionDescription(int i) {
+ Action [] actions = JTextComponent.this.getActions();
+ if (i < 0 || i >= actions.length) {
+ return null;
+ }
+ return (String)actions[i].getValue(Action.NAME);
+ }
+
+ /**
+ * Performs the specified Action on the object
+ *
+ * @param i zero-based index of actions
+ * @return true if the action was performed; otherwise false.
+ * @see #getAccessibleActionCount
+ * @since 1.4
+ */
+ public boolean doAccessibleAction(int i) {
+ Action [] actions = JTextComponent.this.getActions();
+ if (i < 0 || i >= actions.length) {
+ return false;
+ }
+ ActionEvent ae =
+ new ActionEvent(JTextComponent.this,
+ ActionEvent.ACTION_PERFORMED, null,
+ EventQueue.getMostRecentEventTime(),
+ getCurrentEventModifiers());
+ actions[i].actionPerformed(ae);
+ return true;
+ }
+
+ // ----- end AccessibleAction methods
+
+
+ }
+
+
+ // --- serialization ---------------------------------------------
+
+ private void readObject(ObjectInputStream s)
+ throws IOException, ClassNotFoundException
+ {
+ s.defaultReadObject();
+ caretEvent = new MutableCaretEvent(this);
+ addMouseListener(caretEvent);
+ addFocusListener(caretEvent);
+ }
+
+ // --- member variables ----------------------------------
+
+ /**
+ * The document model.
+ */
+ private Document model;
+
+ /**
+ * The caret used to display the insert position
+ * and navigate throughout the document.
+ *
+ * PENDING(prinz)
+ * This should be serializable, default installed
+ * by UI.
+ */
+ private transient Caret caret;
+
+ /**
+ * Object responsible for restricting the cursor navigation.
+ */
+ private NavigationFilter navigationFilter;
+
+ /**
+ * The object responsible for managing highlights.
+ *
+ * PENDING(prinz)
+ * This should be serializable, default installed
+ * by UI.
+ */
+ private transient Highlighter highlighter;
+
+ /**
+ * The current key bindings in effect.
+ *
+ * PENDING(prinz)
+ * This should be serializable, default installed
+ * by UI.
+ */
+ private transient Keymap keymap;
+
+ private transient MutableCaretEvent caretEvent;
+ private Color caretColor;
+ private Color selectionColor;
+ private Color selectedTextColor;
+ private Color disabledTextColor;
+ private boolean editable;
+ private Insets margin;
+ private char focusAccelerator;
+ private boolean dragEnabled;
+
+ /**
+ * The drop mode for this component.
+ */
+ private DropMode dropMode = DropMode.USE_SELECTION;
+
+ /**
+ * The drop location.
+ */
+ private transient DropLocation dropLocation;
+
+ /**
+ * Represents a drop location for <code>JTextComponent</code>s.
+ *
+ * @see #getDropLocation
+ * @since 1.6
+ */
+ public static final class DropLocation extends TransferHandler.DropLocation {
+ private final int index;
+ private final Position.Bias bias;
+
+ private DropLocation(Point p, int index, Position.Bias bias) {
+ super(p);
+ this.index = index;
+ this.bias = bias;
+ }
+
+ /**
+ * Returns the index where dropped data should be inserted into the
+ * associated component. This index represents a position between
+ * characters, as would be interpreted by a caret.
+ *
+ * @return the drop index
+ */
+ public int getIndex() {
+ return index;
+ }
+
+ /**
+ * Returns the bias for the drop index.
+ *
+ * @return the drop bias
+ */
+ public Position.Bias getBias() {
+ return bias;
+ }
+
+ /**
+ * Returns a string representation of this drop location.
+ * This method is intended to be used for debugging purposes,
+ * and the content and format of the returned string may vary
+ * between implementations.
+ *
+ * @return a string representation of this drop location
+ */
+ public String toString() {
+ return getClass().getName()
+ + "[dropPoint=" + getDropPoint() + ","
+ + "index=" + index + ","
+ + "bias=" + bias + "]";
+ }
+ }
+
+ /**
+ * TransferHandler used if one hasn't been supplied by the UI.
+ */
+ private static DefaultTransferHandler defaultTransferHandler;
+
+ /**
+ * Maps from class name to Boolean indicating if
+ * <code>processInputMethodEvent</code> has been overriden.
+ */
+ private static Map overrideMap;
+
+ /**
+ * Returns a string representation of this <code>JTextComponent</code>.
+ * This method is intended to be used only for debugging purposes, and the
+ * content and format of the returned string may vary between
+ * implementations. The returned string may be empty but may not
+ * be <code>null</code>.
+ * <P>
+ * Overriding <code>paramString</code> to provide information about the
+ * specific new aspects of the JFC components.
+ *
+ * @return a string representation of this <code>JTextComponent</code>
+ */
+ protected String paramString() {
+ String editableString = (editable ?
+ "true" : "false");
+ String caretColorString = (caretColor != null ?
+ caretColor.toString() : "");
+ String selectionColorString = (selectionColor != null ?
+ selectionColor.toString() : "");
+ String selectedTextColorString = (selectedTextColor != null ?
+ selectedTextColor.toString() : "");
+ String disabledTextColorString = (disabledTextColor != null ?
+ disabledTextColor.toString() : "");
+ String marginString = (margin != null ?
+ margin.toString() : "");
+
+ return super.paramString() +
+ ",caretColor=" + caretColorString +
+ ",disabledTextColor=" + disabledTextColorString +
+ ",editable=" + editableString +
+ ",margin=" + marginString +
+ ",selectedTextColor=" + selectedTextColorString +
+ ",selectionColor=" + selectionColorString;
+ }
+
+
+ /**
+ * A Simple TransferHandler that exports the data as a String, and
+ * imports the data from the String clipboard. This is only used
+ * if the UI hasn't supplied one, which would only happen if someone
+ * hasn't subclassed Basic.
+ */
+ static class DefaultTransferHandler extends TransferHandler implements
+ UIResource {
+ public void exportToClipboard(JComponent comp, Clipboard clipboard,
+ int action) throws IllegalStateException {
+ if (comp instanceof JTextComponent) {
+ JTextComponent text = (JTextComponent)comp;
+ int p0 = text.getSelectionStart();
+ int p1 = text.getSelectionEnd();
+ if (p0 != p1) {
+ try {
+ Document doc = text.getDocument();
+ String srcData = doc.getText(p0, p1 - p0);
+ StringSelection contents =new StringSelection(srcData);
+
+ // this may throw an IllegalStateException,
+ // but it will be caught and handled in the
+ // action that invoked this method
+ clipboard.setContents(contents, null);
+
+ if (action == TransferHandler.MOVE) {
+ doc.remove(p0, p1 - p0);
+ }
+ } catch (BadLocationException ble) {}
+ }
+ }
+ }
+ public boolean importData(JComponent comp, Transferable t) {
+ if (comp instanceof JTextComponent) {
+ DataFlavor flavor = getFlavor(t.getTransferDataFlavors());
+
+ if (flavor != null) {
+ InputContext ic = comp.getInputContext();
+ if (ic != null) {
+ ic.endComposition();
+ }
+ try {
+ String data = (String)t.getTransferData(flavor);
+
+ ((JTextComponent)comp).replaceSelection(data);
+ return true;
+ } catch (UnsupportedFlavorException ufe) {
+ } catch (IOException ioe) {
+ }
+ }
+ }
+ return false;
+ }
+ public boolean canImport(JComponent comp,
+ DataFlavor[] transferFlavors) {
+ JTextComponent c = (JTextComponent)comp;
+ if (!(c.isEditable() && c.isEnabled())) {
+ return false;
+ }
+ return (getFlavor(transferFlavors) != null);
+ }
+ public int getSourceActions(JComponent c) {
+ return NONE;
+ }
+ private DataFlavor getFlavor(DataFlavor[] flavors) {
+ if (flavors != null) {
+ for (int counter = 0; counter < flavors.length; counter++) {
+ if (flavors[counter].equals(DataFlavor.stringFlavor)) {
+ return flavors[counter];
+ }
+ }
+ }
+ return null;
+ }
+ }
+
+ /**
+ * Returns the JTextComponent that most recently had focus. The returned
+ * value may currently have focus.
+ */
+ static final JTextComponent getFocusedComponent() {
+ return (JTextComponent)AppContext.getAppContext().
+ get(FOCUSED_COMPONENT);
+ }
+
+ private int getCurrentEventModifiers() {
+ int modifiers = 0;
+ AWTEvent currentEvent = EventQueue.getCurrentEvent();
+ if (currentEvent instanceof InputEvent) {
+ modifiers = ((InputEvent)currentEvent).getModifiers();
+ } else if (currentEvent instanceof ActionEvent) {
+ modifiers = ((ActionEvent)currentEvent).getModifiers();
+ }
+ return modifiers;
+ }
+
+ private static final Object KEYMAP_TABLE =
+ new StringBuilder("JTextComponent_KeymapTable");
+ private JTextComponent editor;
+ //
+ // member variables used for on-the-spot input method
+ // editing style support
+ //
+ private transient InputMethodRequests inputMethodRequestsHandler;
+ private SimpleAttributeSet composedTextAttribute;
+ private String composedTextContent;
+ private Position composedTextStart;
+ private Position composedTextEnd;
+ private Position latestCommittedTextStart;
+ private Position latestCommittedTextEnd;
+ private ComposedTextCaret composedTextCaret;
+ private transient Caret originalCaret;
+ /**
+ * Set to true after the check for the override of processInputMethodEvent
+ * has been checked.
+ */
+ private boolean checkedInputOverride;
+ private boolean needToSendKeyTypedEvent;
+
+ static class DefaultKeymap implements Keymap {
+
+ DefaultKeymap(String nm, Keymap parent) {
+ this.nm = nm;
+ this.parent = parent;
+ bindings = new Hashtable();
+ }
+
+ /**
+ * Fetch the default action to fire if a
+ * key is typed (ie a KEY_TYPED KeyEvent is received)
+ * and there is no binding for it. Typically this
+ * would be some action that inserts text so that
+ * the keymap doesn't require an action for each
+ * possible key.
+ */
+ public Action getDefaultAction() {
+ if (defaultAction != null) {
+ return defaultAction;
+ }
+ return (parent != null) ? parent.getDefaultAction() : null;
+ }
+
+ /**
+ * Set the default action to fire if a key is typed.
+ */
+ public void setDefaultAction(Action a) {
+ defaultAction = a;
+ }
+
+ public String getName() {
+ return nm;
+ }
+
+ public Action getAction(KeyStroke key) {
+ Action a = (Action) bindings.get(key);
+ if ((a == null) && (parent != null)) {
+ a = parent.getAction(key);
+ }
+ return a;
+ }
+
+ public KeyStroke[] getBoundKeyStrokes() {
+ KeyStroke[] keys = new KeyStroke[bindings.size()];
+ int i = 0;
+ for (Enumeration e = bindings.keys() ; e.hasMoreElements() ;) {
+ keys[i++] = (KeyStroke) e.nextElement();
+ }
+ return keys;
+ }
+
+ public Action[] getBoundActions() {
+ Action[] actions = new Action[bindings.size()];
+ int i = 0;
+ for (Enumeration e = bindings.elements() ; e.hasMoreElements() ;) {
+ actions[i++] = (Action) e.nextElement();
+ }
+ return actions;
+ }
+
+ public KeyStroke[] getKeyStrokesForAction(Action a) {
+ if (a == null) {
+ return null;
+ }
+ KeyStroke[] retValue = null;
+ // Determine local bindings first.
+ Vector keyStrokes = null;
+ for (Enumeration enum_ = bindings.keys();
+ enum_.hasMoreElements();) {
+ Object key = enum_.nextElement();
+ if (bindings.get(key) == a) {
+ if (keyStrokes == null) {
+ keyStrokes = new Vector();
+ }
+ keyStrokes.addElement(key);
+ }
+ }
+ // See if the parent has any.
+ if (parent != null) {
+ KeyStroke[] pStrokes = parent.getKeyStrokesForAction(a);
+ if (pStrokes != null) {
+ // Remove any bindings defined in the parent that
+ // are locally defined.
+ int rCount = 0;
+ for (int counter = pStrokes.length - 1; counter >= 0;
+ counter--) {
+ if (isLocallyDefined(pStrokes[counter])) {
+ pStrokes[counter] = null;
+ rCount++;
+ }
+ }
+ if (rCount > 0 && rCount < pStrokes.length) {
+ if (keyStrokes == null) {
+ keyStrokes = new Vector();
+ }
+ for (int counter = pStrokes.length - 1; counter >= 0;
+ counter--) {
+ if (pStrokes[counter] != null) {
+ keyStrokes.addElement(pStrokes[counter]);
+ }
+ }
+ }
+ else if (rCount == 0) {
+ if (keyStrokes == null) {
+ retValue = pStrokes;
+ }
+ else {
+ retValue = new KeyStroke[keyStrokes.size() +
+ pStrokes.length];
+ keyStrokes.copyInto(retValue);
+ System.arraycopy(pStrokes, 0, retValue,
+ keyStrokes.size(), pStrokes.length);
+ keyStrokes = null;
+ }
+ }
+ }
+ }
+ if (keyStrokes != null) {
+ retValue = new KeyStroke[keyStrokes.size()];
+ keyStrokes.copyInto(retValue);
+ }
+ return retValue;
+ }
+
+ public boolean isLocallyDefined(KeyStroke key) {
+ return bindings.containsKey(key);
+ }
+
+ public void addActionForKeyStroke(KeyStroke key, Action a) {
+ bindings.put(key, a);
+ }
+
+ public void removeKeyStrokeBinding(KeyStroke key) {
+ bindings.remove(key);
+ }
+
+ public void removeBindings() {
+ bindings.clear();
+ }
+
+ public Keymap getResolveParent() {
+ return parent;
+ }
+
+ public void setResolveParent(Keymap parent) {
+ this.parent = parent;
+ }
+
+ /**
+ * String representation of the keymap... potentially
+ * a very long string.
+ */
+ public String toString() {
+ return "Keymap[" + nm + "]" + bindings;
+ }
+
+ String nm;
+ Keymap parent;
+ Hashtable bindings;
+ Action defaultAction;
+ }
+
+
+ /**
+ * KeymapWrapper wraps a Keymap inside an InputMap. For KeymapWrapper
+ * to be useful it must be used with a KeymapActionMap.
+ * KeymapWrapper for the most part, is an InputMap with two parents.
+ * The first parent visited is ALWAYS the Keymap, with the second
+ * parent being the parent inherited from InputMap. If
+ * <code>keymap.getAction</code> returns null, implying the Keymap
+ * does not have a binding for the KeyStroke,
+ * the parent is then visited. If the Keymap has a binding, the
+ * Action is returned, if not and the KeyStroke represents a
+ * KeyTyped event and the Keymap has a defaultAction,
+ * <code>DefaultActionKey</code> is returned.
+ * <p>KeymapActionMap is then able to transate the object passed in
+ * to either message the Keymap, or message its default implementation.
+ */
+ static class KeymapWrapper extends InputMap {
+ static final Object DefaultActionKey = new Object();
+
+ private Keymap keymap;
+
+ KeymapWrapper(Keymap keymap) {
+ this.keymap = keymap;
+ }
+
+ public KeyStroke[] keys() {
+ KeyStroke[] sKeys = super.keys();
+ KeyStroke[] keymapKeys = keymap.getBoundKeyStrokes();
+ int sCount = (sKeys == null) ? 0 : sKeys.length;
+ int keymapCount = (keymapKeys == null) ? 0 : keymapKeys.length;
+ if (sCount == 0) {
+ return keymapKeys;
+ }
+ if (keymapCount == 0) {
+ return sKeys;
+ }
+ KeyStroke[] retValue = new KeyStroke[sCount + keymapCount];
+ // There may be some duplication here...
+ System.arraycopy(sKeys, 0, retValue, 0, sCount);
+ System.arraycopy(keymapKeys, 0, retValue, sCount, keymapCount);
+ return retValue;
+ }
+
+ public int size() {
+ // There may be some duplication here...
+ KeyStroke[] keymapStrokes = keymap.getBoundKeyStrokes();
+ int keymapCount = (keymapStrokes == null) ? 0:
+ keymapStrokes.length;
+ return super.size() + keymapCount;
+ }
+
+ public Object get(KeyStroke keyStroke) {
+ Object retValue = keymap.getAction(keyStroke);
+ if (retValue == null) {
+ retValue = super.get(keyStroke);
+ if (retValue == null &&
+ keyStroke.getKeyChar() != KeyEvent.CHAR_UNDEFINED &&
+ keymap.getDefaultAction() != null) {
+ // Implies this is a KeyTyped event, use the default
+ // action.
+ retValue = DefaultActionKey;
+ }
+ }
+ return retValue;
+ }
+ }
+
+
+ /**
+ * Wraps a Keymap inside an ActionMap. This is used with
+ * a KeymapWrapper. If <code>get</code> is passed in
+ * <code>KeymapWrapper.DefaultActionKey</code>, the default action is
+ * returned, otherwise if the key is an Action, it is returned.
+ */
+ static class KeymapActionMap extends ActionMap {
+ private Keymap keymap;
+
+ KeymapActionMap(Keymap keymap) {
+ this.keymap = keymap;
+ }
+
+ public Object[] keys() {
+ Object[] sKeys = super.keys();
+ Object[] keymapKeys = keymap.getBoundActions();
+ int sCount = (sKeys == null) ? 0 : sKeys.length;
+ int keymapCount = (keymapKeys == null) ? 0 : keymapKeys.length;
+ boolean hasDefault = (keymap.getDefaultAction() != null);
+ if (hasDefault) {
+ keymapCount++;
+ }
+ if (sCount == 0) {
+ if (hasDefault) {
+ Object[] retValue = new Object[keymapCount];
+ if (keymapCount > 1) {
+ System.arraycopy(keymapKeys, 0, retValue, 0,
+ keymapCount - 1);
+ }
+ retValue[keymapCount - 1] = KeymapWrapper.DefaultActionKey;
+ return retValue;
+ }
+ return keymapKeys;
+ }
+ if (keymapCount == 0) {
+ return sKeys;
+ }
+ Object[] retValue = new Object[sCount + keymapCount];
+ // There may be some duplication here...
+ System.arraycopy(sKeys, 0, retValue, 0, sCount);
+ if (hasDefault) {
+ if (keymapCount > 1) {
+ System.arraycopy(keymapKeys, 0, retValue, sCount,
+ keymapCount - 1);
+ }
+ retValue[sCount + keymapCount - 1] = KeymapWrapper.
+ DefaultActionKey;
+ }
+ else {
+ System.arraycopy(keymapKeys, 0, retValue, sCount, keymapCount);
+ }
+ return retValue;
+ }
+
+ public int size() {
+ // There may be some duplication here...
+ Object[] actions = keymap.getBoundActions();
+ int keymapCount = (actions == null) ? 0 : actions.length;
+ if (keymap.getDefaultAction() != null) {
+ keymapCount++;
+ }
+ return super.size() + keymapCount;
+ }
+
+ public Action get(Object key) {
+ Action retValue = super.get(key);
+ if (retValue == null) {
+ // Try the Keymap.
+ if (key == KeymapWrapper.DefaultActionKey) {
+ retValue = keymap.getDefaultAction();
+ }
+ else if (key instanceof Action) {
+ // This is a little iffy, technically an Action is
+ // a valid Key. We're assuming the Action came from
+ // the InputMap though.
+ retValue = (Action)key;
+ }
+ }
+ return retValue;
+ }
+ }
+
+ private static final Object FOCUSED_COMPONENT =
+ new StringBuilder("JTextComponent_FocusedComponent");
+
+ /**
+ * The default keymap that will be shared by all
+ * <code>JTextComponent</code> instances unless they
+ * have had a different keymap set.
+ */
+ public static final String DEFAULT_KEYMAP = "default";
+
+ /**
+ * Event to use when firing a notification of change to caret
+ * position. This is mutable so that the event can be reused
+ * since caret events can be fairly high in bandwidth.
+ */
+ static class MutableCaretEvent extends CaretEvent implements ChangeListener, FocusListener, MouseListener {
+
+ MutableCaretEvent(JTextComponent c) {
+ super(c);
+ }
+
+ final void fire() {
+ JTextComponent c = (JTextComponent) getSource();
+ if (c != null) {
+ Caret caret = c.getCaret();
+ dot = caret.getDot();
+ mark = caret.getMark();
+ c.fireCaretUpdate(this);
+ }
+ }
+
+ public final String toString() {
+ return "dot=" + dot + "," + "mark=" + mark;
+ }
+
+ // --- CaretEvent methods -----------------------
+
+ public final int getDot() {
+ return dot;
+ }
+
+ public final int getMark() {
+ return mark;
+ }
+
+ // --- ChangeListener methods -------------------
+
+ public final void stateChanged(ChangeEvent e) {
+ if (! dragActive) {
+ fire();
+ }
+ }
+
+ // --- FocusListener methods -----------------------------------
+ public void focusGained(FocusEvent fe) {
+ AppContext.getAppContext().put(FOCUSED_COMPONENT,
+ fe.getSource());
+ }
+
+ public void focusLost(FocusEvent fe) {
+ }
+
+ // --- MouseListener methods -----------------------------------
+
+ /**
+ * Requests focus on the associated
+ * text component, and try to set the cursor position.
+ *
+ * @param e the mouse event
+ * @see MouseListener#mousePressed
+ */
+ public final void mousePressed(MouseEvent e) {
+ dragActive = true;
+ }
+
+ /**
+ * Called when the mouse is released.
+ *
+ * @param e the mouse event
+ * @see MouseListener#mouseReleased
+ */
+ public final void mouseReleased(MouseEvent e) {
+ dragActive = false;
+ fire();
+ }
+
+ public final void mouseClicked(MouseEvent e) {
+ }
+
+ public final void mouseEntered(MouseEvent e) {
+ }
+
+ public final void mouseExited(MouseEvent e) {
+ }
+
+ private boolean dragActive;
+ private int dot;
+ private int mark;
+ }
+
+ //
+ // Process any input method events that the component itself
+ // recognizes. The default on-the-spot handling for input method
+ // composed(uncommitted) text is done here after all input
+ // method listeners get called for stealing the events.
+ //
+ protected void processInputMethodEvent(InputMethodEvent e) {
+ // let listeners handle the events
+ super.processInputMethodEvent(e);
+
+ if (!e.isConsumed()) {
+ if (! isEditable()) {
+ return;
+ } else {
+ switch (e.getID()) {
+ case InputMethodEvent.INPUT_METHOD_TEXT_CHANGED:
+ replaceInputMethodText(e);
+
+ // fall through
+
+ case InputMethodEvent.CARET_POSITION_CHANGED:
+ setInputMethodCaretPosition(e);
+ break;
+ }
+ }
+
+ e.consume();
+ }
+ }
+
+ //
+ // Overrides this method to become an active input method client.
+ //
+ public InputMethodRequests getInputMethodRequests() {
+ if (inputMethodRequestsHandler == null) {
+ inputMethodRequestsHandler =
+ (InputMethodRequests)new InputMethodRequestsHandler();
+ Document doc = getDocument();
+ if (doc != null) {
+ doc.addDocumentListener((DocumentListener)inputMethodRequestsHandler);
+ }
+ }
+
+ return inputMethodRequestsHandler;
+ }
+
+ //
+ // Overrides this method to watch the listener installed.
+ //
+ public void addInputMethodListener(InputMethodListener l) {
+ super.addInputMethodListener(l);
+ if (l != null) {
+ needToSendKeyTypedEvent = false;
+ checkedInputOverride = true;
+ }
+ }
+
+
+ //
+ // Default implementation of the InputMethodRequests interface.
+ //
+ class InputMethodRequestsHandler implements InputMethodRequests, DocumentListener {
+
+ // --- InputMethodRequests methods ---
+
+ public AttributedCharacterIterator cancelLatestCommittedText(
+ Attribute[] attributes) {
+ Document doc = getDocument();
+ if ((doc != null) && (latestCommittedTextStart != null)
+ && (!latestCommittedTextStart.equals(latestCommittedTextEnd))) {
+ try {
+ int startIndex = latestCommittedTextStart.getOffset();
+ int endIndex = latestCommittedTextEnd.getOffset();
+ String latestCommittedText =
+ doc.getText(startIndex, endIndex - startIndex);
+ doc.remove(startIndex, endIndex - startIndex);
+ return new AttributedString(latestCommittedText).getIterator();
+ } catch (BadLocationException ble) {}
+ }
+ return null;
+ }
+
+ public AttributedCharacterIterator getCommittedText(int beginIndex,
+ int endIndex, Attribute[] attributes) {
+ int composedStartIndex = 0;
+ int composedEndIndex = 0;
+ if (composedTextExists()) {
+ composedStartIndex = composedTextStart.getOffset();
+ composedEndIndex = composedTextEnd.getOffset();
+ }
+
+ String committed;
+ try {
+ if (beginIndex < composedStartIndex) {
+ if (endIndex <= composedStartIndex) {
+ committed = getText(beginIndex, endIndex - beginIndex);
+ } else {
+ int firstPartLength = composedStartIndex - beginIndex;
+ committed = getText(beginIndex, firstPartLength) +
+ getText(composedEndIndex, endIndex - beginIndex - firstPartLength);
+ }
+ } else {
+ committed = getText(beginIndex + (composedEndIndex - composedStartIndex),
+ endIndex - beginIndex);
+ }
+ } catch (BadLocationException ble) {
+ throw new IllegalArgumentException("Invalid range");
+ }
+ return new AttributedString(committed).getIterator();
+ }
+
+ public int getCommittedTextLength() {
+ Document doc = getDocument();
+ int length = 0;
+ if (doc != null) {
+ length = doc.getLength();
+ if (composedTextContent != null) {
+ if (composedTextEnd == null
+ || composedTextStart == null) {
+ /*
+ * fix for : 6355666
+ * this is the case when this method is invoked
+ * from DocumentListener. At this point
+ * composedTextEnd and composedTextStart are
+ * not defined yet.
+ */
+ length -= composedTextContent.length();
+ } else {
+ length -= composedTextEnd.getOffset() -
+ composedTextStart.getOffset();
+ }
+ }
+ }
+ return length;
+ }
+
+ public int getInsertPositionOffset() {
+ int composedStartIndex = 0;
+ int composedEndIndex = 0;
+ if (composedTextExists()) {
+ composedStartIndex = composedTextStart.getOffset();
+ composedEndIndex = composedTextEnd.getOffset();
+ }
+ int caretIndex = getCaretPosition();
+
+ if (caretIndex < composedStartIndex) {
+ return caretIndex;
+ } else if (caretIndex < composedEndIndex) {
+ return composedStartIndex;
+ } else {
+ return caretIndex - (composedEndIndex - composedStartIndex);
+ }
+ }
+
+ public TextHitInfo getLocationOffset(int x, int y) {
+ if (composedTextAttribute == null) {
+ return null;
+ } else {
+ Point p = getLocationOnScreen();
+ p.x = x - p.x;
+ p.y = y - p.y;
+ int pos = viewToModel(p);
+ if ((pos >= composedTextStart.getOffset()) &&
+ (pos <= composedTextEnd.getOffset())) {
+ return TextHitInfo.leading(pos - composedTextStart.getOffset());
+ } else {
+ return null;
+ }
+ }
+ }
+
+ public Rectangle getTextLocation(TextHitInfo offset) {
+ Rectangle r;
+
+ try {
+ r = modelToView(getCaretPosition());
+ if (r != null) {
+ Point p = getLocationOnScreen();
+ r.translate(p.x, p.y);
+ }
+ } catch (BadLocationException ble) {
+ r = null;
+ }
+
+ if (r == null)
+ r = new Rectangle();
+
+ return r;
+ }
+
+ public AttributedCharacterIterator getSelectedText(
+ Attribute[] attributes) {
+ String selection = JTextComponent.this.getSelectedText();
+ if (selection != null) {
+ return new AttributedString(selection).getIterator();
+ } else {
+ return null;
+ }
+ }
+
+ // --- DocumentListener methods ---
+
+ public void changedUpdate(DocumentEvent e) {
+ latestCommittedTextStart = latestCommittedTextEnd = null;
+ }
+
+ public void insertUpdate(DocumentEvent e) {
+ latestCommittedTextStart = latestCommittedTextEnd = null;
+ }
+
+ public void removeUpdate(DocumentEvent e) {
+ latestCommittedTextStart = latestCommittedTextEnd = null;
+ }
+ }
+
+ //
+ // Replaces the current input method (composed) text according to
+ // the passed input method event. This method also inserts the
+ // committed text into the document.
+ //
+ private void replaceInputMethodText(InputMethodEvent e) {
+ int commitCount = e.getCommittedCharacterCount();
+ AttributedCharacterIterator text = e.getText();
+ int composedTextIndex;
+
+ // old composed text deletion
+ Document doc = getDocument();
+ if (composedTextExists()) {
+ try {
+ doc.remove(composedTextStart.getOffset(),
+ composedTextEnd.getOffset() -
+ composedTextStart.getOffset());
+ } catch (BadLocationException ble) {}
+ composedTextStart = composedTextEnd = null;
+ composedTextAttribute = null;
+ composedTextContent = null;
+ }
+
+ if (text != null) {
+ text.first();
+ int committedTextStartIndex = 0;
+ int committedTextEndIndex = 0;
+
+ // committed text insertion
+ if (commitCount > 0) {
+ // Remember latest committed text start index
+ committedTextStartIndex = caret.getDot();
+
+ // Need to generate KeyTyped events for the committed text for components
+ // that are not aware they are active input method clients.
+ if (shouldSynthensizeKeyEvents()) {
+ for (char c = text.current(); commitCount > 0;
+ c = text.next(), commitCount--) {
+ KeyEvent ke = new KeyEvent(this, KeyEvent.KEY_TYPED,
+ EventQueue.getMostRecentEventTime(),
+ 0, KeyEvent.VK_UNDEFINED, c);
+ processKeyEvent(ke);
+ }
+ } else {
+ StringBuffer strBuf = new StringBuffer();
+ for (char c = text.current(); commitCount > 0;
+ c = text.next(), commitCount--) {
+ strBuf.append(c);
+ }
+
+ // map it to an ActionEvent
+ mapCommittedTextToAction(new String(strBuf));
+ }
+
+ // Remember latest committed text end index
+ committedTextEndIndex = caret.getDot();
+ }
+
+ // new composed text insertion
+ composedTextIndex = text.getIndex();
+ if (composedTextIndex < text.getEndIndex()) {
+ createComposedTextAttribute(composedTextIndex, text);
+ try {
+ replaceSelection(null);
+ doc.insertString(caret.getDot(), composedTextContent,
+ composedTextAttribute);
+ composedTextStart = doc.createPosition(caret.getDot() -
+ composedTextContent.length());
+ composedTextEnd = doc.createPosition(caret.getDot());
+ } catch (BadLocationException ble) {
+ composedTextStart = composedTextEnd = null;
+ composedTextAttribute = null;
+ composedTextContent = null;
+ }
+ }
+
+ // Save the latest committed text information
+ if (committedTextStartIndex != committedTextEndIndex) {
+ try {
+ latestCommittedTextStart = doc.
+ createPosition(committedTextStartIndex);
+ latestCommittedTextEnd = doc.
+ createPosition(committedTextEndIndex);
+ } catch (BadLocationException ble) {
+ latestCommittedTextStart =
+ latestCommittedTextEnd = null;
+ }
+ } else {
+ latestCommittedTextStart =
+ latestCommittedTextEnd = null;
+ }
+ }
+ }
+
+ private void createComposedTextAttribute(int composedIndex,
+ AttributedCharacterIterator text) {
+ Document doc = getDocument();
+ StringBuffer strBuf = new StringBuffer();
+
+ // create attributed string with no attributes
+ for (char c = text.setIndex(composedIndex);
+ c != CharacterIterator.DONE; c = text.next()) {
+ strBuf.append(c);
+ }
+
+ composedTextContent = new String(strBuf);
+ composedTextAttribute = new SimpleAttributeSet();
+ composedTextAttribute.addAttribute(StyleConstants.ComposedTextAttribute,
+ new AttributedString(text, composedIndex, text.getEndIndex()));
+ }
+
+ private boolean saveComposedText(int pos) {
+ if (composedTextExists()) {
+ int start = composedTextStart.getOffset();
+ int len = composedTextEnd.getOffset() -
+ composedTextStart.getOffset();
+ if (pos >= start && pos <= start + len) {
+ try {
+ getDocument().remove(start, len);
+ return true;
+ } catch (BadLocationException ble) {}
+ }
+ }
+ return false;
+ }
+
+ private void restoreComposedText() {
+ Document doc = getDocument();
+ try {
+ doc.insertString(caret.getDot(),
+ composedTextContent,
+ composedTextAttribute);
+ composedTextStart = doc.createPosition(caret.getDot() -
+ composedTextContent.length());
+ composedTextEnd = doc.createPosition(caret.getDot());
+ } catch (BadLocationException ble) {}
+ }
+
+ //
+ // Map committed text to an ActionEvent. If the committed text length is 1,
+ // treat it as a KeyStroke, otherwise or there is no KeyStroke defined,
+ // treat it just as a default action.
+ //
+ private void mapCommittedTextToAction(String committedText) {
+ Keymap binding = getKeymap();
+ if (binding != null) {
+ Action a = null;
+ if (committedText.length() == 1) {
+ KeyStroke k = KeyStroke.getKeyStroke(committedText.charAt(0));
+ a = binding.getAction(k);
+ }
+
+ if (a == null) {
+ a = binding.getDefaultAction();
+ }
+
+ if (a != null) {
+ ActionEvent ae =
+ new ActionEvent(this, ActionEvent.ACTION_PERFORMED,
+ committedText,
+ EventQueue.getMostRecentEventTime(),
+ getCurrentEventModifiers());
+ a.actionPerformed(ae);
+ }
+ }
+ }
+
+ //
+ // Sets the caret position according to the passed input method
+ // event. Also, sets/resets composed text caret appropriately.
+ //
+ private void setInputMethodCaretPosition(InputMethodEvent e) {
+ int dot;
+
+ if (composedTextExists()) {
+ dot = composedTextStart.getOffset();
+ if (!(caret instanceof ComposedTextCaret)) {
+ if (composedTextCaret == null) {
+ composedTextCaret = new ComposedTextCaret();
+ }
+ originalCaret = caret;
+ // Sets composed text caret
+ exchangeCaret(originalCaret, composedTextCaret);
+ }
+
+ TextHitInfo caretPos = e.getCaret();
+ if (caretPos != null) {
+ int index = caretPos.getInsertionIndex();
+ dot += index;
+ if (index == 0) {
+ // Scroll the component if needed so that the composed text
+ // becomes visible.
+ try {
+ Rectangle d = modelToView(dot);
+ Rectangle end = modelToView(composedTextEnd.getOffset());
+ Rectangle b = getBounds();
+ d.x += Math.min(end.x - d.x, b.width);
+ scrollRectToVisible(d);
+ } catch (BadLocationException ble) {}
+ }
+ }
+ caret.setDot(dot);
+ } else if (caret instanceof ComposedTextCaret) {
+ dot = caret.getDot();
+ // Restores original caret
+ exchangeCaret(caret, originalCaret);
+ caret.setDot(dot);
+ }
+ }
+
+ private void exchangeCaret(Caret oldCaret, Caret newCaret) {
+ int blinkRate = oldCaret.getBlinkRate();
+ setCaret(newCaret);
+ caret.setBlinkRate(blinkRate);
+ caret.setVisible(hasFocus());
+ }
+
+ /**
+ * Returns true if KeyEvents should be synthesized from an InputEvent.
+ */
+ private boolean shouldSynthensizeKeyEvents() {
+ if (!checkedInputOverride) {
+ checkedInputOverride = true;
+ needToSendKeyTypedEvent =
+ !isProcessInputMethodEventOverridden();
+ }
+ return needToSendKeyTypedEvent;
+ }
+
+ //
+ // Checks whether the client code overrides processInputMethodEvent. If it is overridden,
+ // need not to generate KeyTyped events for committed text. If it's not, behave as an
+ // passive input method client.
+ //
+ private boolean isProcessInputMethodEventOverridden() {
+ if (overrideMap == null) {
+ overrideMap = Collections.synchronizedMap(new HashMap());
+ }
+ Boolean retValue = (Boolean)overrideMap.get(getClass().getName());
+
+ if (retValue != null) {
+ return retValue.booleanValue();
+ }
+ Boolean ret = (Boolean)AccessController.doPrivileged(new
+ PrivilegedAction() {
+ public Object run() {
+ return isProcessInputMethodEventOverridden(
+ JTextComponent.this.getClass());
+ }
+ });
+
+ return ret.booleanValue();
+ }
+
+ //
+ // Checks whether a composed text in this text component
+ //
+ boolean composedTextExists() {
+ return (composedTextStart != null);
+ }
+
+ //
+ // Caret implementation for editing the composed text.
+ //
+ class ComposedTextCaret extends DefaultCaret implements Serializable {
+ Color bg;
+
+ //
+ // Get the background color of the component
+ //
+ public void install(JTextComponent c) {
+ super.install(c);
+
+ Document doc = c.getDocument();
+ if (doc instanceof StyledDocument) {
+ StyledDocument sDoc = (StyledDocument)doc;
+ Element elem = sDoc.getCharacterElement(c.composedTextStart.getOffset());
+ AttributeSet attr = elem.getAttributes();
+ bg = sDoc.getBackground(attr);
+ }
+
+ if (bg == null) {
+ bg = c.getBackground();
+ }
+ }
+
+ //
+ // Draw caret in XOR mode.
+ //
+ public void paint(Graphics g) {
+ if(isVisible()) {
+ try {
+ Rectangle r = component.modelToView(getDot());
+ g.setXORMode(bg);
+ g.drawLine(r.x, r.y, r.x, r.y + r.height - 1);
+ g.setPaintMode();
+ } catch (BadLocationException e) {
+ // can't render I guess
+ //System.err.println("Can't render cursor");
+ }
+ }
+ }
+
+ //
+ // If some area other than the composed text is clicked by mouse,
+ // issue endComposition() to force commit the composed text.
+ //
+ protected void positionCaret(MouseEvent me) {
+ JTextComponent host = component;
+ Point pt = new Point(me.getX(), me.getY());
+ int offset = host.viewToModel(pt);
+ int composedStartIndex = host.composedTextStart.getOffset();
+ if ((offset < composedStartIndex) ||
+ (offset > composedTextEnd.getOffset())) {
+ try {
+ // Issue endComposition
+ Position newPos = host.getDocument().createPosition(offset);
+ host.getInputContext().endComposition();
+
+ // Post a caret positioning runnable to assure that the positioning
+ // occurs *after* committing the composed text.
+ EventQueue.invokeLater(new DoSetCaretPosition(host, newPos));
+ } catch (BadLocationException ble) {
+ System.err.println(ble);
+ }
+ } else {
+ // Normal processing
+ super.positionCaret(me);
+ }
+ }
+ }
+
+ //
+ // Runnable class for invokeLater() to set caret position later.
+ //
+ private class DoSetCaretPosition implements Runnable {
+ JTextComponent host;
+ Position newPos;
+
+ DoSetCaretPosition(JTextComponent host, Position newPos) {
+ this.host = host;
+ this.newPos = newPos;
+ }
+
+ public void run() {
+ host.setCaretPosition(newPos.getOffset());
+ }
+ }
+}