javax.swing.text
Class JTextComponent

java.lang.Object
  |
  +--java.awt.Component
        |
        +--java.awt.Container
              |
              +--javax.swing.JComponent
                    |
                    +--javax.swing.text.JTextComponent

All Implemented Interfaces:

Accessible, java.awt.image.ImageObserver, MenuContainer, Scrollable, Serializable

Direct Known Subclasses:

JEditorPane, JTextArea, JTextField

public abstract class JTextComponent

extends JComponent

implements Scrollable, Accessible

Safe: JTextComponent is the base class for swing text components. It tries to be compatible with the 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 General Rules for Using Text Components, a section in The Java Tutorial.

Caret Changes

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 CaretListener interface that have been registered with the text component. The UI will install a default caret unless a customized caret has been set.

Commands

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 Action interface, using the TextAction implementation. The set of commands supported by the text component can be found with the getActions() method. These actions can be bound to key events, fired from buttons, etc.

Text Input

The text components support flexible and internationalized text input, using keymaps and the input method framework, while maintaining compatibility with the AWT listener model.

A 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 TextAction. TextAction can determine which JTextComponent most recently has or had focus and therefore is the subject of the action (In the case that the ActionEvent sent to the action doesn't contain the target text component as its source).

The input method framework 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. JTextComponent is an active client 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 java.awt.event.InputMethodEvent instead of as a key event. The complete text input is the combination of the characters in keyTyped key events and committed text in input method events.

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.

Keyboard event and input method events are handled in the following stages, with each stage capable of consuming the event:

Stage	KeyEvent	InputMethodEvent
1.	input methods	(generated here)
2.	focus manager
3.	registered key listeners	registered input method listeners
4.		input method handling in JTextComponent
5.	keymap handling using the current keymap
6.	keyboard handling in JComponent (e.g. accelerators, component navigation, etc.)

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.

By default the component will create a keymap (named DEFAULT_KEYMAP) 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:

• inserting content into the editor for the printable keys.
• removing content with the backspace and del keys.
• caret movement forward and backward

Model/View Split

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

The model is defined by the 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 DocumentEvent which allows the views to stay up to date with the model. This event is sent to observers that have implemented the DocumentListener interface and registered interest with the model being observed.

Location Information

The capability of determining the location of text in the view is provided. There are two methods, modelToView(int) and viewToModel(java.awt.Point) for determining this information.

Undo/Redo support

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

Thread Safety

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 AbstractDocument describes the assumptions of the protection provided. The methods that are safe to call asynchronously are marked with comments.

Newlines

For a discussion on how newlines are handled, see DefaultEditorKit.

Warning: 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^TM has been added to the java.beans package. Please see java.beans.XMLEncoder.

Version:

1.196 05/15/02

Author:

Timothy Prinzing

See Also:

Document, DocumentEvent, DocumentListener, Caret, CaretEvent, CaretListener, TextUI, View, ViewFactory, Serialized Form

Field Summary

private Caret	caret The caret used to display the insert position and navigate throughout the document.
private Color	caretColor
private javax.swing.text.JTextComponent.MutableCaretEvent	caretEvent
private boolean	checkedInputOverride Set to true after the check for the override of processInputMethodEvent has been checked.
private java.text.AttributedString	composedText
private javax.swing.text.JTextComponent.ComposedTextCaret	composedTextCaret
private String	composedTextContent
private Position	composedTextEnd
private Position	composedTextStart
static String	DEFAULT_KEYMAP Suppressed: The default keymap that will be shared by all JTextComponent instances unless they have had a different keymap set.
private static javax.swing.text.JTextComponent.DefaultTransferHandler	defaultTransferHandler TransferHandler used if one hasn't been supplied by the UI.
private Color	disabledTextColor
private boolean	dragEnabled
private boolean	editable
private JTextComponent	editor
static String	FOCUS_ACCELERATOR_KEY Suppressed: The bound property name for the focus accelerator.
private char	focusAccelerator
private static JTextComponent	focusedComponent The most recent JTextComponent that has/had focus.
private Highlighter	highlighter The object responsible for managing highlights.
private java.awt.im.InputMethodRequests	inputMethodRequestsHandler
private Keymap	keymap The current key bindings in effect.
private static Hashtable	keymapTable
private Position	latestCommittedTextEnd
private Position	latestCommittedTextStart
private Insets	margin
private Document	model The document model.
private NavigationFilter	navigationFilter Object responsible for restricting the cursor navigation.
private boolean	needToSendKeyTypedEvent
private Caret	originalCaret
private static Map	overrideMap Maps from class name to Boolean indicating if processInputMethodEvent has been overriden.
private Color	selectedTextColor
private Color	selectionColor

Fields inherited from class javax.swing.JComponent

accessibleContext, listenerList, TOOL_TIP_TEXT_KEY, ui, UNDEFINED_CONDITION, WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, WHEN_FOCUSED, WHEN_IN_FOCUSED_WINDOW

Fields inherited from class java.awt.Container

Fields inherited from class java.awt.Component

BOTTOM_ALIGNMENT, CENTER_ALIGNMENT, LEFT_ALIGNMENT, RIGHT_ALIGNMENT, TOP_ALIGNMENT

Constructor Summary

JTextComponent()
Enabled: Creates a new JTextComponent.

Method Summary

void	addCaretListener(CaretListener listener) Enabled: Adds a caret listener for notification of any changes to the caret.
void	addInputMethodListener(InputMethodListener l) Suppressed:
static Keymap	addKeymap() Added: Safe replacement for the suppressed static addKeymap/2.
static Keymap	addKeymap(String nm, Keymap parent) Suppressed: Adds a new keymap into the keymap hierarchy.
void	copy() Suppressed: Transfers the currently selected range in the associated text model to the system clipboard, leaving the contents in the text model.
private void	createComposedString(int composedIndex, java.text.AttributedCharacterIterator text)
void	cut() Suppressed: Transfers the currently selected range in the associated text model to the system clipboard, removing the contents from the model.
private void	exchangeCaret(Caret oldCaret, Caret newCaret)
protected void	fireCaretUpdate(CaretEvent e) Notifies all listeners that have registered interest for notification on this event type.
AccessibleContext	getAccessibleContext() Suppressed: Gets the AccessibleContext associated with this JTextComponent.
Action[]	getActions() Suppressed: Fetches the command list for the editor.
Caret	getCaret() Enabled: Fetches the caret that allows text-oriented navigation over the view.
Color	getCaretColor() Enabled: Fetches the current color used to render the caret.
CaretListener[]	getCaretListeners() Suppressed: Returns an array of all the caret listeners registered on this text component.
int	getCaretPosition() Enabled: Returns the position of the text insertion caret for the text component.
private int	getCurrentEventModifiers()
Color	getDisabledTextColor() Enabled: Fetches the current color used to render the selected text.
Document	getDocument() Enabled: Fetches the model associated with the editor.
boolean	getDragEnabled() Enabled: Gets the dragEnabled property.
char	getFocusAccelerator() Enabled: Returns the key accelerator that will cause the receiving text component to get the focus.
(package private) static JTextComponent	getFocusedComponent() Returns the JTextComponent that most recently had focus.
Highlighter	getHighlighter() Enabled: Fetches the object responsible for making highlights.
java.awt.im.InputMethodRequests	getInputMethodRequests() Suppressed:
Keymap	getKeymap() Suppressed: Fetches the keymap currently active in this text component.
static Keymap	getKeymap(String nm) Suppressed: Fetches a named keymap previously added to the document.
Insets	getMargin() Enabled: Returns the margin between the text component's border and its text.
NavigationFilter	getNavigationFilter() Enabled: Returns the NavigationFilter.
Dimension	getPreferredScrollableViewportSize() Enabled: Returns the preferred size of the viewport for a view component.
int	getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) Enabled: 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.
boolean	getScrollableTracksViewportHeight() Enabled: Returns true if a viewport should always force the height of this Scrollable to match the height of the viewport.
boolean	getScrollableTracksViewportWidth() Enabled: Returns true if a viewport should always force the width of this Scrollable to match the width of the viewport.
int	getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) Enabled: 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.
String	getSelectedText() Enabled: Returns the selected text contained in this TextComponent.
Color	getSelectedTextColor() Enabled: Fetches the current color used to render the selected text.
Color	getSelectionColor() Enabled: Fetches the current color used to render the selection.
int	getSelectionEnd() Enabled: Returns the selected text's end position.
int	getSelectionStart() Enabled: Returns the selected text's start position.
String	getText() Enabled: Returns the text contained in this TextComponent.
String	getText(int offs, int len) Enabled: Fetches a portion of the text represented by the component.
String	getToolTipText(MouseEvent event) Enabled: Returns the string to be used as the tooltip for event.
javax.swing.plaf.TextUI	getUI() Suppressed: Fetches the user-interface factory for this text-oriented editor.
private void	installDefaultTransferHandlerIfNecessary() If the current TransferHandler is null, this will install a new one.
private void	invokeAction(String name, Action altAction) This is a conveniance method that is only useful for cut, copy and paste.
boolean	isEditable() Enabled: Returns the boolean indicating whether this TextComponent is editable or not.
private boolean	isProcessInputMethodEventOverridden()
private static Boolean	isProcessInputMethodEventOverridden(Class klass) Returns true if klass is NOT a JTextComponent and it or one of its superclasses (stoping at JTextComponent) overrides processInputMethodEvent.
static void	loadKeymap(Keymap map, javax.swing.text.JTextComponent.KeyBinding[] bindings, Action[] actions) Suppressed:
private void	mapCommittedTextToAction(String committedText)
Rectangle	modelToView(int pos) Enabled: Converts the given location in the model to a place in the view coordinate system.
void	moveCaretPosition(int pos) Enabled: Moves the caret to a new position, leaving behind a mark defined by the last time setCaretPosition was called.
protected String	paramString() Returns a string representation of this JTextComponent.
void	paste() Suppressed: Transfers the contents of the system clipboard into the associated text model.
protected void	processInputMethodEvent(InputMethodEvent e) Processes input method events occurring on this component by dispatching them to any registered InputMethodListener objects.
void	read(Reader in, Object desc) Enabled: Initializes from a stream.
private void	readObject(ObjectInputStream s) We use the ObjectInputStream "registerValidation" callback to update the UI for the entire tree of components after they've all been read in.
void	removeCaretListener(CaretListener listener) Enabled: Removes a caret listener.
static Keymap	removeKeymap(String nm) Enabled: Removes a named keymap previously added to the document.
void	removeNotify() Suppressed:
private void	replaceInputMethodText(InputMethodEvent e)
void	replaceSelection(String content) Enabled: Replaces the currently selected content with new content represented by the given string.
void	select(int selectionStart, int selectionEnd) Enabled: Selects the text between the specified start and end positions.
void	selectAll() Enabled: Selects all the text in the TextComponent.
void	setCaret(Caret c) Enabled: Sets the caret to be used.
void	setCaretColor(Color c) Enabled: Sets the current color used to render the caret.
void	setCaretPosition(int position) Enabled: Sets the position of the text insertion caret for the TextComponent.
void	setComponentOrientation(ComponentOrientation o) Suppressed:
void	setDisabledTextColor(Color c) Enabled: Sets the current color used to render the disabled text.
void	setDocument(Document doc) Enabled: Associates the editor with a text document.
void	setDragEnabled(boolean b) Enabled: Sets the dragEnabled property, which must be true to enable automatic drag handling (the first part of drag and drop) on this component.
void	setEditable(boolean b) Enabled: Sets the specified boolean to indicate whether or not this TextComponent should be editable.
void	setFocusAccelerator(char aKey) Enabled: Sets the key accelerator that will cause the receiving text component to get the focus.
void	setHighlighter(Highlighter h) Enabled: Sets the highlighter to be used.
private void	setInputMethodCaretPosition(InputMethodEvent e)
void	setKeymap(Keymap map) Enabled: Sets the keymap to use for binding events to actions.
void	setMargin(Insets m) Enabled: Sets margin space between the text component's border and its text.
void	setNavigationFilter(NavigationFilter filter) Enabled: Sets the NavigationFilter.
void	setSelectedTextColor(Color c) Enabled: Sets the current color used to render the selected text.
void	setSelectionColor(Color c) Enabled: Sets the current color used to render the selection.
void	setSelectionEnd(int selectionEnd) Enabled: Sets the selection end to the specified position.
void	setSelectionStart(int selectionStart) Enabled: Sets the selection start to the specified position.
void	setText(String t) Enabled: Sets the text of this TextComponent to the specified text.
void	setUI(javax.swing.plaf.TextUI ui) Suppressed: Sets the user-interface factory for this text-oriented editor.
private boolean	shouldSynthensizeKeyEvents() Returns true if KeyEvents should be synthesized from an InputEvent.
(package private) void	updateInputMap(Keymap oldKm, Keymap newKm) Updates the InputMaps in response to a Keymap change.
void	updateUI() Suppressed: Reloads the pluggable UI.
int	viewToModel(Point pt) Enabled: Converts the given place in the view coordinate system to the nearest representative location in the model.
void	write(Writer out) Enabled: Stores the contents of the model into the given stream.

Methods inherited from class javax.swing.JComponent

addAncestorListener, addNotify, addPropertyChangeListener, addPropertyChangeListener, addVetoableChangeListener, computeVisibleRect, contains, createToolTip, disable, enable, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, fireVetoableChange, getActionForKeyStroke, getActionMap, getAlignmentX, getAlignmentY, getAncestorListeners, getAutoscrolls, getBorder, getBounds, getClientProperty, getComponentGraphics, getConditionForKeyStroke, getDebugGraphicsOptions, getDefaultLocale, getGraphics, getHeight, getInputMap, getInputMap, getInputVerifier, getInsets, getInsets, getListeners, getLocation, getMaximumSize, getMinimumSize, getNextFocusableComponent, getPreferredSize, getPropertyChangeListeners, getPropertyChangeListeners, getRegisteredKeyStrokes, getRootPane, getSize, getToolTipLocation, getToolTipText, getTopLevelAncestor, getTransferHandler, getUIClassID, getVerifyInputWhenFocusTarget, getVetoableChangeListeners, getVisibleRect, getWidth, getX, getY, grabFocus, isDoubleBuffered, isLightweightComponent, isManagingFocus, isMaximumSizeSet, isMinimumSizeSet, isOpaque, isOptimizedDrawingEnabled, isPaintingTile, isPreferredSizeSet, isRequestFocusEnabled, isValidateRoot, paint, paintBorder, paintChildren, paintComponent, paintImmediately, paintImmediately, print, printAll, printBorder, printChildren, printComponent, processComponentKeyEvent, processKeyBinding, processKeyEvent, processMouseMotionEvent, putClientProperty, registerKeyboardAction, registerKeyboardAction, removeAncestorListener, removePropertyChangeListener, removePropertyChangeListener, removeVetoableChangeListener, repaint, repaint, requestDefaultFocus, requestFocus, requestFocus, requestFocusInWindow, requestFocusInWindow, resetKeyboardActions, reshape, revalidate, scrollRectToVisible, setActionMap, setAlignmentX, setAlignmentY, setAutoscrolls, setBackground, setBorder, setDebugGraphicsOptions, setDefaultLocale, setDoubleBuffered, setEnabled, setFont, setForeground, setInputMap, setInputVerifier, setMaximumSize, setMinimumSize, setNextFocusableComponent, setOpaque, setPreferredSize, setRequestFocusEnabled, setToolTipText, setTransferHandler, setUI, setVerifyInputWhenFocusTarget, setVisible, unregisterKeyboardAction, update

Methods inherited from class java.awt.Container

add, add, add, add, add, addContainerListener, addImpl, applyComponentOrientation, areFocusTraversalKeysSet, countComponents, deliverEvent, doLayout, findComponentAt, findComponentAt, get, getComponent, getComponentAt, getComponentAt, getComponentCount, getComponents, getContainerListeners, getFocusTraversalKeys, getFocusTraversalPolicy, getLayout, insets, invalidate, isAncestorOf, isFocusCycleRoot, isFocusCycleRoot, isFocusTraversalPolicySet, iterate, layout, list, list, locate, minimumSize, paintComponents, preferredSize, printComponents, processContainerEvent, processEvent, remove, remove, removeAll, removeContainerListener, setFocusCycleRoot, setFocusTraversalKeys, setFocusTraversalPolicy, setLayout, size, transferFocusBackward, transferFocusDownCycle, validate, validateTree

Methods inherited from class java.awt.Component

action, add, addComponentListener, addFocusListener, addHierarchyBoundsListener, addHierarchyListener, addKeyListener, addMouseListener, addMouseMotionListener, addMouseWheelListener, bounds, checkImage, checkImage, coalesceEvents, contains, createImage, createImage, createVolatileImage, createVolatileImage, disableEvents, dispatchEvent, enable, enableEvents, enableInputMethods, getBackground, getBounds, getColorModel, getComponentListeners, getComponentOrientation, getCursor, getDropTarget, getFocusCycleRootAncestor, getFocusListeners, getFocusTraversalKeysEnabled, getFont, getFontMetrics, getForeground, getGraphicsConfiguration, getHierarchyBoundsListeners, getHierarchyListeners, getIgnoreRepaint, getInputContext, getInputMethodListeners, getKeyListeners, getLocale, getLocation, getLocationOnScreen, getMouseListeners, getMouseMotionListeners, getMouseWheelListeners, getName, getParent, getPeer, getSize, getToolkit, getTreeLock, gotFocus, handleEvent, hasFocus, hide, imageUpdate, inside, isBackgroundSet, isCursorSet, isDisplayable, isEnabled, isFocusable, isFocusOwner, isFocusTraversable, isFontSet, isForegroundSet, isLightweight, isShowing, isValid, isVisible, keyDown, keyUp, list, list, list, location, lostFocus, mouseDown, mouseDrag, mouseEnter, mouseExit, mouseMove, mouseUp, move, nextFocus, paintAll, postEvent, prepareImage, prepareImage, processComponentEvent, processFocusEvent, processHierarchyBoundsEvent, processHierarchyEvent, processMouseEvent, processMouseWheelEvent, remove, removeComponentListener, removeFocusListener, removeHierarchyBoundsListener, removeHierarchyListener, removeInputMethodListener, removeKeyListener, removeMouseListener, removeMouseMotionListener, removeMouseWheelListener, repaint, repaint, repaint, resize, resize, setBounds, setBounds, setCursor, setDropTarget, setFocusable, setFocusTraversalKeysEnabled, setIgnoreRepaint, setLocale, setLocation, setLocation, setName, setSize, setSize, show, show, toString, transferFocus, transferFocus, transferFocusUpCycle

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

FOCUS_ACCELERATOR_KEY

public static final String FOCUS_ACCELERATOR_KEY

Suppressed: The bound property name for the focus accelerator.

model

private Document model

The document model.

caret

private transient Caret caret

The caret used to display the insert position and navigate throughout the document. PENDING(prinz) This should be serializable, default installed by UI.

navigationFilter

private NavigationFilter navigationFilter

Object responsible for restricting the cursor navigation.

highlighter

private transient Highlighter highlighter

The object responsible for managing highlights. PENDING(prinz) This should be serializable, default installed by UI.

keymap

private transient Keymap keymap

The current key bindings in effect. PENDING(prinz) This should be serializable, default installed by UI.

caretEvent

private transient javax.swing.text.JTextComponent.MutableCaretEvent caretEvent

caretColor

private Color caretColor

selectionColor

private Color selectionColor

selectedTextColor

private Color selectedTextColor

disabledTextColor

private Color disabledTextColor

editable

private boolean editable

margin

private Insets margin

focusAccelerator

private char focusAccelerator

dragEnabled

private boolean dragEnabled

defaultTransferHandler

private static javax.swing.text.JTextComponent.DefaultTransferHandler defaultTransferHandler

TransferHandler used if one hasn't been supplied by the UI.

overrideMap

private static Map overrideMap

Maps from class name to Boolean indicating if processInputMethodEvent has been overriden.

focusedComponent

private static JTextComponent focusedComponent

The most recent JTextComponent that has/had focus. The text actions use this via the getFocusedComponent method as a fallback case when a JTextComponent doesn't have focus.

keymapTable

private static Hashtable keymapTable

editor

private JTextComponent editor

inputMethodRequestsHandler

private transient java.awt.im.InputMethodRequests inputMethodRequestsHandler

composedText

private java.text.AttributedString composedText

composedTextContent

private String composedTextContent

composedTextStart

private Position composedTextStart

composedTextEnd

private Position composedTextEnd

latestCommittedTextStart

private Position latestCommittedTextStart

latestCommittedTextEnd

private Position latestCommittedTextEnd

composedTextCaret

private javax.swing.text.JTextComponent.ComposedTextCaret composedTextCaret

originalCaret

private transient Caret originalCaret

checkedInputOverride

private boolean checkedInputOverride

Set to true after the check for the override of processInputMethodEvent has been checked.

needToSendKeyTypedEvent

private boolean needToSendKeyTypedEvent

DEFAULT_KEYMAP

public static final String DEFAULT_KEYMAP

Suppressed: The default keymap that will be shared by all JTextComponent instances unless they have had a different keymap set.

Constructor Detail

JTextComponent

public JTextComponent()

Enabled: Creates a new 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 null.

Method Detail

getUI

public javax.swing.plaf.TextUI getUI()

Suppressed: Fetches the user-interface factory for this text-oriented editor.

Returns:

the factory

setUI

public void setUI(javax.swing.plaf.TextUI ui)

Suppressed: Sets the user-interface factory for this text-oriented editor.

Parameters:

ui - the factory

updateUI

public void updateUI()

Suppressed: Reloads the pluggable UI. The key used to fetch the new interface is getUIClassID(). The type of the UI is TextUI. invalidate is called after setting the UI.

Overrides:

updateUI in class JComponent

See Also:

JComponent.setUI(javax.swing.plaf.ComponentUI), UIManager.getLookAndFeel(), UIManager.getUI(javax.swing.JComponent)

addCaretListener

public void addCaretListener(CaretListener listener)

Enabled: Adds a caret listener for notification of any changes to the caret.

Parameters:

listener - the listener to be added

See Also:

javax.swing.event.CaretEvent

removeCaretListener

public void removeCaretListener(CaretListener listener)

Enabled: Removes a caret listener.

Parameters:

listener - the listener to be removed

See Also:

javax.swing.event.CaretEvent

getCaretListeners

public CaretListener[] getCaretListeners()

Suppressed: Returns an array of all the caret listeners registered on this text component.

Returns:

all of this component's CaretListeners or an empty array if no caret listeners are currently registered

Since:

1.4

See Also:

addCaretListener(javax.swing.event.CaretListener), removeCaretListener(javax.swing.event.CaretListener)

fireCaretUpdate

protected void fireCaretUpdate(CaretEvent e)

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.

Parameters:

e - the event

See Also:

EventListenerList

setDocument

public void setDocument(Document doc)

Enabled: 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.

Parameters:

doc - the document to display/edit

See Also:

getDocument()

getDocument

public Document getDocument()

Enabled: 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 ty