< prev index next >
src/java.desktop/share/classes/javax/swing/text/JTextComponent.java
Print this page
*** 73,85 ****
import sun.swing.SwingUtilities2;
import sun.swing.text.TextComponentPrintable;
import sun.swing.SwingAccessor;
/**
! * <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
--- 73,85 ----
import sun.swing.SwingUtilities2;
import sun.swing.text.TextComponentPrintable;
import sun.swing.SwingAccessor;
/**
! * {@code JTextComponent} is the base class for swing text
* components. It tries to be compatible with the
! * {@code java.awt.TextComponent} 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
*** 89,120 ****
* <dl>
* <dt><b>Caret Changes</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.
*
* <dt><b>Commands</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.
*
* <dt><b>Text Input</b>
--- 89,120 ----
* <dl>
* <dt><b>Caret Changes</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}
* 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}
* tries to make itself visible which may lead to scrolling
! * of a text component within {@code JScrollPane}. 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.
*
* <dt><b>Commands</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} interface,
! * using the {@code TextAction} 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.
*
* <dt><b>Text Input</b>
*** 124,151 ****
* 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
--- 124,151 ----
* 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 TextAction} can determine which {@code JTextComponent}
* most recently has or had focus and therefore is the subject of
! * the action (In the case that the {@code ActionEvent}
* 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} 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} 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
*** 235,256 ****
* <dt><b>Undo/Redo support</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.
*
* <dt><b>Thread Safety</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.
*
* <dt><b>Newlines</b>
--- 235,256 ----
* <dt><b>Undo/Redo support</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} 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.
*
* <dt><b>Thread Safety</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}
* describes the assumptions of the protection provided.
* The methods that are safe to call asynchronously are marked
* with comments.
*
* <dt><b>Newlines</b>
*** 271,281 ****
* 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™
! * has been added to the <code>java.beans</code> package.
* Please see {@link java.beans.XMLEncoder}.
*
* @beaninfo
* attribute: isContainer false
*
--- 271,281 ----
* 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™
! * has been added to the {@code java.beans} package.
* Please see {@link java.beans.XMLEncoder}.
*
* @beaninfo
* attribute: isContainer false
*
*** 293,307 ****
*/
@SuppressWarnings("serial") // Same-version serialization only
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);
--- 293,307 ----
*/
@SuppressWarnings("serial") // Same-version serialization only
public abstract class JTextComponent extends JComponent implements Scrollable, Accessible
{
/**
! * Creates a new {@code JTextComponent}.
* 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}.
*/
public JTextComponent() {
super();
// enable InputMethodEvent for on-the-spot pre-editing
enableEvents(AWTEvent.KEY_EVENT_MASK | AWTEvent.INPUT_METHOD_EVENT_MASK);
*** 330,341 ****
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();
--- 330,341 ----
super.setUI(ui);
}
/**
* Reloads the pluggable UI. The key used to fetch the
! * new interface is {@code getUIClassID()}. The type of
! * the UI is {@code TextUI}. {@code invalidate}
* is called after setting the UI.
*/
public void updateUI() {
setUI((TextUI)UIManager.getUI(this));
invalidate();
*** 364,374 ****
/**
* 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
--- 364,374 ----
/**
* Returns an array of all the caret listeners
* registered on this text component.
*
! * @return all of this component's {@code CaretListener}s
* or an empty
* array if no caret listeners are currently registered
*
* @see #addCaretListener
* @see #removeCaretListener
*** 500,513 ****
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
--- 500,513 ----
return getUI().getEditorKit(this).getActions();
}
/**
* Sets margin space between the text component's border
! * and its text. The text component's default {@code Border}
* 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} 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
*** 531,554 ****
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.
* @param filter the filter
*
* @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
--- 531,554 ----
public Insets getMargin() {
return margin;
}
/**
! * Sets the {@code NavigationFilter}. {@code NavigationFilter}
! * is used by {@code DefaultCaret} and the default cursor movement
* actions as a way to restrict the cursor movement.
* @param filter the filter
*
* @since 1.4
*/
public void setNavigationFilter(NavigationFilter filter) {
navigationFilter = filter;
}
/**
! * Returns the {@code NavigationFilter}. {@code NavigationFilter}
! * is used by {@code DefaultCaret} 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
*** 606,616 ****
/**
* 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
--- 606,616 ----
/**
* 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} to disable it.
* A PropertyChange event ("highlighter") is fired
* when a new highlighter is installed.
*
* @param h the highlighter
* @see #getHighlighter
*** 631,641 ****
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
--- 631,641 ----
firePropertyChange("highlighter", old, h);
}
/**
* Sets the keymap to use for binding events to
! * actions. Setting to {@code null} effectively disables
* keyboard input.
* A PropertyChange event ("keymap") is fired when a new keymap
* is installed.
*
* @param map the keymap
*** 669,681 ****
* 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
--- 669,681 ----
* 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} is {@code true} and
! * {@code GraphicsEnvironment.isHeadless()}
! * returns {@code true}
* @see java.awt.GraphicsEnvironment#isHeadless
* @see #getDragEnabled
* @see #setTransferHandler
* @see TransferHandler
* @since 1.4
*** 706,733 ****
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
--- 706,733 ----
return dragEnabled;
}
/**
* Sets the drop mode for this component. For backward compatibility,
! * the default for this property is {@code DropMode.USE_SELECTION}.
! * Usage of {@code DropMode.INSERT} 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} support the following drop modes:
* <ul>
! * <li>{@code DropMode.USE_SELECTION}</li>
! * <li>{@code DropMode.INSERT}</li>
* </ul>
* <p>
* The drop mode is only meaningful if this component has a
! * {@code TransferHandler} that accepts drops.
*
* @param dropMode the drop mode to use
* @throws IllegalArgumentException if the drop mode is unsupported
! * or {@code null}
* @see #getDropMode
* @see #getDropLocation
* @see #setTransferHandler
* @see javax.swing.TransferHandler
* @since 1.6
*** 781,797 ****
/**
* 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);
--- 781,797 ----
/**
* 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()}, which is package-private
! * in javax.swing. {@code TransferHandler} 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}
*/
DropLocation dropLocationForPoint(Point p) {
Position.Bias[] bias = new Position.Bias[1];
int index = getUI().viewToModel(this, p, bias);
*** 820,849 ****
* 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) {
--- 820,849 ----
* 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}. 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} since there's
* no longer anything to store.
* <p>
* Note: This method is meant to override
! * {@code JComponent.setDropLocation()}, which is package-private
! * in javax.swing. {@code TransferHandler} 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}) or {@code null}
* if there's no longer a valid drop location
* @param state the state object saved earlier for this component,
! * or {@code null}
* @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} if none
*/
Object setDropLocation(TransferHandler.DropLocation location,
Object state,
boolean forDrop) {
*** 942,952 ****
* 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.
*
--- 942,952 ----
* 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}
* 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.
*
*** 959,972 ****
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;
--- 959,972 ----
return dropLocation;
}
/**
! * Updates the {@code InputMap}s in response to a
! * {@code Keymap} change.
! * @param oldKm the old {@code Keymap}
! * @param newKm the new {@code Keymap}
*/
void updateInputMap(Keymap oldKm, Keymap newKm) {
// Locate the current KeymapWrapper.
InputMap km = getInputMap(JComponent.WHEN_FOCUSED);
InputMap last = km;
*** 1057,1071 ****
* 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);
--- 1057,1071 ----
* 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} 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} 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);
*** 1076,1097 ****
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) {
--- 1076,1097 ----
return map;
}
/**
* Removes a named keymap previously added to the document. Keymaps
! * with {@code null} 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}-named keymaps.
*
* @param nm the name of the keymap
* @return the keymap
*/
public static Keymap getKeymap(String nm) {
*** 1123,1133 ****
* 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™
! * has been added to the <code>java.beans</code> package.
* Please see {@link java.beans.XMLEncoder}.
*/
@SuppressWarnings("serial") // Same-version serialization only
public static class KeyBinding {
--- 1123,1133 ----
* 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™
! * has been added to the {@code java.beans} package.
* Please see {@link java.beans.XMLEncoder}.
*/
@SuppressWarnings("serial") // Same-version serialization only
public static class KeyBinding {
*** 1160,1170 ****
* 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),
--- 1160,1170 ----
* 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),
*** 1178,1190 ****
*
* 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
*/
--- 1178,1190 ----
*
* JTextComponent c = new JTextPane();
* Keymap k = c.getKeymap();
* JTextComponent.loadKeymap(k, defaultBindings, c.getActions());
*
! * }</pre>
* The sets of bindings and actions may be empty but must be
! * non-{@code null}.
*
* @param map the keymap
* @param bindings the bindings
* @param actions the set of actions
*/
*** 1212,1222 ****
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
--- 1212,1222 ----
return caretColor;
}
/**
* Sets the current color used to render the caret.
! * Setting to {@code null} effectively restores the default color.
* Setting the color results in a PropertyChange event ("caretColor")
* being fired.
*
* @param c the color
* @see #getCaretColor
*** 1241,1252 ****
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
--- 1241,1252 ----
return selectionColor;
}
/**
* Sets the current color used to render the selection.
! * Setting the color to {@code null} is the same as setting
! * {@code Color.white}. Setting the color results in a
* PropertyChange event ("selectionColor").
*
* @param c the color
* @see #getSelectionColor
* @beaninfo
*** 1270,1281 ****
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
--- 1270,1281 ----
return selectedTextColor;
}
/**
* Sets the current color used to render the selected text.
! * Setting the color to {@code null} is the same as
! * {@code Color.black}. Setting the color results in a
* PropertyChange event ("selectedTextColor") being fired.
*
* @param c the color
* @see #getSelectedTextColor
* @beaninfo
*** 1410,1420 ****
/**
* 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() {
--- 1410,1420 ----
/**
* 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} selections.
*
* @see java.awt.Toolkit#getSystemClipboard
* @see java.awt.datatransfer.Clipboard
*/
public void cut() {
*** 1425,1435 ****
/**
* 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() {
--- 1425,1435 ----
/**
* 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} selections.
*
* @see java.awt.Toolkit#getSystemClipboard
* @see java.awt.datatransfer.Clipboard
*/
public void copy() {
*** 1454,1467 ****
}
}
/**
* This is a convenience 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 attempt 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;
--- 1454,1467 ----
}
}
/**
* This is a convenience method that is only useful for
! * {@code cut}, {@code copy} and {@code paste}. If
! * an {@code Action} with the name {@code name} does not
! * exist in the {@code ActionMap}, this will attempt to install a
! * {@code TransferHandler} and then use {@code altAction}.
*/
private void invokeAction(String name, Action altAction) {
ActionMap map = getActionMap();
Action action = null;
*** 1478,1488 ****
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) {
--- 1478,1488 ----
EventQueue.getMostRecentEventTime(),
getCurrentEventModifiers()));
}
/**
! * If the current {@code TransferHandler} is null, this will
* install a new one.
*/
private void installDefaultTransferHandlerIfNecessary() {
if (getTransferHandler() == null) {
if (defaultTransferHandler == null) {
*** 1492,1510 ****
}
}
/**
* 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();
--- 1492,1510 ----
}
}
/**
* Moves the caret to a new position, leaving behind a mark
! * defined by the last time {@code setCaretPosition} was
* called. This forms a selection.
! * If the document is {@code null}, 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} is less than zero or greater
* than the component's text length
* @see #setCaretPosition
*/
public void moveCaretPosition(int pos) {
Document doc = getDocument();
*** 1570,1580 ****
*
* @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
--- 1570,1580 ----
*
* @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},
* 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
*** 1620,1638 ****
// --- 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) {
--- 1620,1638 ----
// --- java.awt.TextComponent methods ------------------------
/**
* Sets the position of the text insertion caret for the
! * {@code TextComponent}. 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}, 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} is less than zero or greater
* than the component's text length
* @beaninfo
* description: the caret position
*/
public void setCaretPosition(int position) {
*** 1656,1675 ****
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>
! * 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
--- 1656,1675 ----
public int getCaretPosition() {
return caret.getDot();
}
/**
! * Sets the text of this {@code TextComponent}
! * to the specified text. If the text is {@code null}
* 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>
! * Note that text is not a bound property, so no {@code PropertyChangeEvent}
! * is fired when it changes. To listen for changes to the text,
! * use {@code DocumentListener}.
*
* @param t the new text to be set
* @see #getText
* @see DefaultCaret
* @beaninfo
*** 1689,1708 ****
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;
--- 1689,1708 ----
UIManager.getLookAndFeel().provideErrorFeedback(JTextComponent.this);
}
}
/**
! * Returns the text contained in this {@code TextComponent}.
! * If the underlying document is {@code null},
! * will give a {@code NullPointerException}.
! *
! * Note that text is not a bound property, so no {@code PropertyChangeEvent}
! * is fired when it changes. To listen for changes to the text,
! * use {@code DocumentListener}.
*
* @return the text
! * @exception NullPointerException if the document is {@code null}
* @see #setText
*/
public String getText() {
Document doc = getDocument();
String txt;
*** 1714,1725 ****
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
--- 1714,1725 ----
return txt;
}
/**
* Returns the selected text contained in this
! * {@code TextComponent}. If the selection is
! * {@code null} or the document empty, returns {@code null}.
*
* @return the text
* @exception IllegalArgumentException if the selection doesn't
* have a valid mapping into the document for some reason
* @see #setText
*** 1739,1760 ****
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
--- 1739,1760 ----
return txt;
}
/**
* Returns the boolean indicating whether this
! * {@code TextComponent} 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} should be editable.
* A PropertyChange event ("editable") is fired when the
* state is changed.
*
* @param b the boolean to be set
* @see #isEditable
*** 1788,1799 ****
* 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.
--- 1788,1799 ----
* 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}.
! * This is implemented to forward to the {@code Caret}
* 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.
*** 1821,1832 ****
* 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.
--- 1821,1832 ----
* 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}.
! * This is implemented to forward to the {@code Caret}
* 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.
*** 1854,1865 ****
* 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
--- 1854,1865 ----
* 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}
! * followed by a call to {@code moveCaretPosition}.
* 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
*** 1886,1897 ****
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);
--- 1886,1897 ----
setCaretPosition(selectionStart);
moveCaretPosition(selectionEnd);
}
/**
! * Selects all the text in the {@code TextComponent}.
! * Does nothing on a {@code null} or empty document.
*/
public void selectAll() {
Document doc = getDocument();
if (doc != null) {
setCaretPosition(0);
*** 1900,1926 ****
}
// --- 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) {
--- 1900,1926 ----
}
// --- Tooltip Methods ---------------------------------------------
/**
! * Returns the string to be used as the tooltip for {@code event}.
* This will return one of:
* <ol>
! * <li>If {@code setToolTipText} has been invoked with a
! * non-{@code null}
* value, it will be returned, otherwise
! * <li>The value from invoking {@code getToolTipText} on
* the UI will be returned.
* </ol>
! * By default {@code JTextComponent} does not register
! * itself with the {@code ToolTipManager}.
* This means that tooltips will NOT be shown from the
! * {@code TextUI} unless {@code registerComponent} has
! * been invoked on the {@code ToolTipManager}.
*
* @param event the event in question
! * @return the string to be used as the tooltip for {@code event}
* @see javax.swing.JComponent#setToolTipText
* @see javax.swing.plaf.TextUI#getToolTipText
* @see javax.swing.ToolTipManager#registerComponent
*/
public String getToolTipText(MouseEvent event) {
*** 1941,1952 ****
/**
* 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();
}
--- 1941,1952 ----
/**
* 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} of a {@code JViewport}
! * whose view is this {@code Scrollable}
*/
public Dimension getPreferredScrollableViewportSize() {
return getPreferredSize();
}
*** 1961,1972 ****
* 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
--- 1961,1972 ----
* 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} or
! * {@code SwingConstants.HORIZONTAL}
* @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
*** 1991,2002 ****
* 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
--- 1991,2002 ----
* 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} or
! * {@code SwingConstants.HORIZONTAL}
* @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
*** 2013,2034 ****
}
/**
* 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() {
Container parent = SwingUtilities.getUnwrappedParent(this);
if (parent instanceof JViewport) {
--- 2013,2034 ----
}
/**
* Returns true if a viewport should always force the width of this
! * {@code Scrollable} 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} whose ancestor is a {@code JScrollPane}
* effectively disables horizontal scrolling.
* <p>
! * Scrolling containers, like {@code JViewport},
* will use this method each time they are validated.
*
! * @return true if a viewport should force the {@code Scrollable}s
* width to match its own
*/
public boolean getScrollableTracksViewportWidth() {
Container parent = SwingUtilities.getUnwrappedParent(this);
if (parent instanceof JViewport) {
*** 2037,2052 ****
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
*/
--- 2037,2052 ----
return false;
}
/**
* Returns true if a viewport should always force the height of this
! * {@code Scrollable} 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},
* will use this method each time they are validated.
*
* @return true if a viewport should force the Scrollables height
* to match its own
*/
*** 2471,2510 ****
// 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™
! * has been added to the <code>java.beans</code> package.
* Please see {@link java.beans.XMLEncoder}.
*/
@SuppressWarnings("serial") // Same-version serialization only
public class AccessibleJTextComponent extends AccessibleJComponent
implements AccessibleText, CaretListener, DocumentListener,
--- 2471,2510 ----
// Accessibility support
////////////////
/**
! * Gets the {@code AccessibleContext} associated with this
! * {@code JTextComponent}. For text components,
! * the {@code AccessibleContext} takes the form of an
! * {@code AccessibleJTextComponent}.
! * A new {@code AccessibleJTextComponent} instance
* is created if necessary.
*
! * @return an {@code AccessibleJTextComponent} that serves as the
! * {@code AccessibleContext} of this
! * {@code JTextComponent}
*/
public AccessibleContext getAccessibleContext() {
if (accessibleContext == null) {
accessibleContext = new AccessibleJTextComponent();
}
return accessibleContext;
}
/**
* This class implements accessibility support for the
! * {@code JTextComponent} 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™
! * has been added to the {@code java.beans} package.
* Please see {@link java.beans.XMLEncoder}.
*/
@SuppressWarnings("serial") // Same-version serialization only
public class AccessibleJTextComponent extends AccessibleJComponent
implements AccessibleText, CaretListener, DocumentListener,
*** 2886,2896 ****
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.
*/
--- 2886,2896 ----
return JTextComponent.this.getSelectedText();
}
/**
* IndexedSegment extends Segment adding the offset into the
! * the model the {@code Segment} was asked for.
*/
private class IndexedSegment extends Segment {
/**
* Offset into the model that the position represents.
*/
*** 2938,2949 ****
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();
--- 2938,2949 ----
return getAtIndex(part, index, -1);
}
/**
! * Gets the word, sentence, or character at {@code index}.
! * If {@code direction} 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();
*** 3025,3036 ****
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);
--- 3025,3036 ----
return para.getParentElement();
}
}
/*
! * Returns a {@code Segment} containing the paragraph text
! * at {@code index}, or null if {@code index} isn't
* valid.
*/
private IndexedSegment getParagraphElementText(int index)
throws BadLocationException {
Element para = getParagraphElement(index);
*** 3050,3061 ****
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.
*/
--- 3050,3061 ----
return null;
}
/**
! * Returns the Segment at {@code index} representing either
! * the paragraph or sentence as identified by {@code part}, 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.
*/
*** 3270,3291 ****
// 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
--- 3270,3291 ----
// 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}.
! * If {@code direction} is non-null this will find the
* next/previous word/sentence/character.
*
! * @param part the {@code CHARACTER}, {@code WORD},
! * {@code SENTENCE}, {@code LINE} or
! * {@code ATTRIBUTE_RUN} to retrieve
* @param index an index within the text
* @param direction is either -1, 0, or 1
! * @return an {@code AccessibleTextSequence} specifying the text
! * if {@code part} and {@code index} are valid. Otherwise,
! * {@code null} is returned.
*
* @see javax.accessibility.AccessibleText#CHARACTER
* @see javax.accessibility.AccessibleText#WORD
* @see javax.accessibility.AccessibleText#SENTENCE
* @see javax.accessibility.AccessibleExtendedText#LINE
*** 3501,3514 ****
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 {
--- 3501,3514 ----
return null;
}
/**
! * Starting at text position {@code index}, and going in
! * {@code direction}, return the edge of run that shares the
! * same {@code AttributeSet} and parent element as those at
! * {@code index}.
*
* Note: we assume the document is already locked...
*/
private int getRunEdge(int index, int direction) throws
BadLocationException {
*** 3564,3583 ****
}
// 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
--- 3564,3583 ----
}
// getTextRange() not needed; defined in AccessibleEditableText
/**
! * Returns the {@code AccessibleTextSequence} at a given
! * {@code index}.
*
! * @param part the {@code CHARACTER}, {@code WORD},
! * {@code SENTENCE}, {@code LINE} or
! * {@code ATTRIBUTE_RUN} to retrieve
* @param index an index within the text
! * @return an {@code AccessibleTextSequence} specifying the text if
! * {@code part} and {@code index} are valid. Otherwise,
! * {@code null} is returned
*
* @see javax.accessibility.AccessibleText#CHARACTER
* @see javax.accessibility.AccessibleText#WORD
* @see javax.accessibility.AccessibleText#SENTENCE
* @see javax.accessibility.AccessibleExtendedText#LINE
*** 3588,3607 ****
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
--- 3588,3607 ----
public AccessibleTextSequence getTextSequenceAt(int part, int index) {
return getSequenceAtIndex(part, index, 0);
}
/**
! * Returns the {@code AccessibleTextSequence} after a given
! * {@code index}.
*
! * @param part the {@code CHARACTER}, {@code WORD},
! * {@code SENTENCE}, {@code LINE} or
! * {@code ATTRIBUTE_RUN} to retrieve
* @param index an index within the text
! * @return an {@code AccessibleTextSequence} specifying the text
! * if {@code part} and {@code index} are valid. Otherwise,
! * {@code null} is returned
*
* @see javax.accessibility.AccessibleText#CHARACTER
* @see javax.accessibility.AccessibleText#WORD
* @see javax.accessibility.AccessibleText#SENTENCE
* @see javax.accessibility.AccessibleExtendedText#LINE
*** 3612,3631 ****
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
--- 3612,3631 ----
public AccessibleTextSequence getTextSequenceAfter(int part, int index) {
return getSequenceAtIndex(part, index, 1);
}
/**
! * Returns the {@code AccessibleTextSequence} before a given
! * {@code index}.
*
! * @param part the {@code CHARACTER}, {@code WORD},
! * {@code SENTENCE}, {@code LINE} or
! * {@code ATTRIBUTE_RUN} to retrieve
* @param index an index within the text
! * @return an {@code AccessibleTextSequence} specifying the text
! * if {@code part} and {@code index} are valid. Otherwise,
! * {@code null} is returned
*
* @see javax.accessibility.AccessibleText#CHARACTER
* @see javax.accessibility.AccessibleText#WORD
* @see javax.accessibility.AccessibleText#SENTENCE
* @see javax.accessibility.AccessibleExtendedText#LINE
*** 3636,3652 ****
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 ||
--- 3636,3652 ----
public AccessibleTextSequence getTextSequenceBefore(int part, int index) {
return getSequenceAtIndex(part, index, -1);
}
/**
! * Returns the {@code Rectangle} 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} is returned
*
* @since 1.6
*/
public Rectangle getTextBounds(int startIndex, int endIndex) {
if (startIndex < 0 || startIndex > model.getLength()-1 ||
*** 3849,3859 ****
* 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 {
--- 3849,3859 ----
* The drop location.
*/
private transient DropLocation dropLocation;
/**
! * Represents a drop location for {@code JTextComponent}s.
*
* @see #getDropLocation
* @since 1.6
*/
public static final class DropLocation extends TransferHandler.DropLocation {
*** 3907,3917 ****
*/
private static DefaultTransferHandler defaultTransferHandler;
/**
* Maps from class name to Boolean indicating if
! * <code>processInputMethodEvent</code> has been overriden.
*/
private static Cache<Class<?>,Boolean> METHOD_OVERRIDDEN
= new Cache<Class<?>,Boolean>(Cache.Kind.WEAK, Cache.Kind.STRONG) {
/**
* Returns {@code true} if the specified {@code type} extends {@link JTextComponent}
--- 3907,3917 ----
*/
private static DefaultTransferHandler defaultTransferHandler;
/**
* Maps from class name to Boolean indicating if
! * {@code processInputMethodEvent} has been overriden.
*/
private static Cache<Class<?>,Boolean> METHOD_OVERRIDDEN
= new Cache<Class<?>,Boolean>(Cache.Kind.WEAK, Cache.Kind.STRONG) {
/**
* Returns {@code true} if the specified {@code type} extends {@link JTextComponent}
*** 3938,3957 ****
});
}
};
/**
! * 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 ?
--- 3938,3957 ----
});
}
};
/**
! * Returns a string representation of this {@code JTextComponent}.
* 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}.
* <P>
! * Overriding {@code paramString} to provide information about the
* specific new aspects of the JFC components.
*
! * @return a string representation of this {@code JTextComponent}
*/
protected String paramString() {
String editableString = (editable ?
"true" : "false");
String caretColorString = (caretColor != null ?
*** 4260,4275 ****
* 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();
--- 4260,4275 ----
* 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} 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} 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();
*** 4323,4334 ****
}
/**
* 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;
--- 4323,4334 ----
}
/**
* Wraps a Keymap inside an ActionMap. This is used with
! * a KeymapWrapper. If {@code get} is passed in
! * {@code KeymapWrapper.DefaultActionKey}, the default action is
* returned, otherwise if the key is an Action, it is returned.
*/
static class KeymapActionMap extends ActionMap {
private Keymap keymap;
*** 4408,4418 ****
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";
/**
--- 4408,4418 ----
private static final Object FOCUSED_COMPONENT =
new StringBuilder("JTextComponent_FocusedComponent");
/**
* The default keymap that will be shared by all
! * {@code JTextComponent} instances unless they
* have had a different keymap set.
*/
public static final String DEFAULT_KEYMAP = "default";
/**
< prev index next >