| Methods Summary |
|---|
| public void | addNotify()Makes this Component displayable by connecting it to a
native screen resource.
This method is called internally by the toolkit and should
not be called directly by programs.
super.addNotify();
enableInputMethodsIfNecessary();
|
| public synchronized void | addTextListener(java.awt.event.TextListener l)Adds the specified text event listener to receive text events
from this text component.
If l is null, no exception is
thrown and no action is performed.
Refer to AWT Threading Issues for details on AWT's threading model.
if (l == null) {
return;
}
textListener = AWTEventMulticaster.add(textListener, l);
newEventsOnly = true;
|
| boolean | areInputMethodsEnabled()
// moved from the constructor above to here and addNotify below,
// this call will initialize the toolkit if not already initialized.
if (checkForEnableIM) {
enableInputMethodsIfNecessary();
}
// TextComponent handles key events without touching the eventMask or
// having a key listener, so just check whether the flag is set
return (eventMask & AWTEvent.INPUT_METHODS_ENABLED_MASK) != 0;
|
| private void | checkSystemClipboardAccess()Assigns a valid value to the canAccessClipboard instance variable.
canAccessClipboard = true;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
try {
sm.checkSystemClipboardAccess();
}
catch (SecurityException e) {
canAccessClipboard = false;
}
}
|
| public void | enableInputMethods(boolean enable)Enables or disables input method support for this text component. If input
method support is enabled and the text component also processes key events,
incoming events are offered to the current input method and will only be
processed by the component or dispatched to its listeners if the input method
does not consume them. Whether and how input method support for this text
component is enabled or disabled by default is implementation dependent.
checkForEnableIM = false;
super.enableInputMethods(enable);
|
| private void | enableInputMethodsIfNecessary()
if (checkForEnableIM) {
checkForEnableIM = false;
try {
Toolkit toolkit = Toolkit.getDefaultToolkit();
boolean shouldEnable = false;
if (toolkit instanceof InputMethodSupport) {
shouldEnable = ((InputMethodSupport)toolkit)
.enableInputMethodsForTextComponent();
}
enableInputMethods(shouldEnable);
} catch (Exception e) {
// if something bad happens, just don't enable input methods
}
}
|
| boolean | eventEnabled(java.awt.AWTEvent e)
if (e.id == TextEvent.TEXT_VALUE_CHANGED) {
if ((eventMask & AWTEvent.TEXT_EVENT_MASK) != 0 ||
textListener != null) {
return true;
}
return false;
}
return super.eventEnabled(e);
|
| public javax.accessibility.AccessibleContext | getAccessibleContext()Gets the AccessibleContext associated with this TextComponent.
For text components, the AccessibleContext takes the form of an
AccessibleAWTTextComponent.
A new AccessibleAWTTextComponent instance is created if necessary.
if (accessibleContext == null) {
accessibleContext = new AccessibleAWTTextComponent();
}
return accessibleContext;
|
| public java.awt.Color | getBackground()Gets the background color of this text component.
By default, non-editable text components have a background color
of SystemColor.control. This default can be overridden by
calling setBackground.
if (!editable && !backgroundSetByClientCode) {
return SystemColor.control;
}
return super.getBackground();
|
| public synchronized int | getCaretPosition()Returns the position of the text insertion caret.
The caret position is constrained to be between 0
and the last character of the text, inclusive.
If the text or caret have not been set, the default
caret position is 0.
TextComponentPeer peer = (TextComponentPeer)this.peer;
int position = 0;
if (peer != null) {
position = peer.getCaretPosition();
} else {
position = selectionStart;
}
int maxposition = getText().length();
if (position > maxposition) {
position = maxposition;
}
return position;
|
| java.awt.Rectangle | getCharacterBounds(int i)
return null;
/* To be fully implemented in a future release
if (peer == null) {
return null;
}
TextComponentPeer peer = (TextComponentPeer)this.peer;
return peer.getCharacterBounds(i);
*/
|
| int | getIndexAtPoint(java.awt.Point p)
return -1;
/* To be fully implemented in a future release
if (peer == null) {
return -1;
}
TextComponentPeer peer = (TextComponentPeer)this.peer;
return peer.getIndexAtPoint(p.x, p.y);
*/
|
| public java.awt.im.InputMethodRequests | getInputMethodRequests()
TextComponentPeer peer = (TextComponentPeer)this.peer;
if (peer != null) return peer.getInputMethodRequests();
else return null;
|
| public T[] | getListeners(java.lang.Class listenerType)Returns an array of all the objects currently registered
as FooListeners
upon this TextComponent.
FooListeners are registered using the
addFooListener method.
You can specify the listenerType argument
with a class literal, such as
FooListener.class.
For example, you can query a
TextComponent t
for its text listeners with the following code:
TextListener[] tls = (TextListener[])(t.getListeners(TextListener.class));
If no such listeners exist, this method returns an empty array.
EventListener l = null;
if (listenerType == TextListener.class) {
l = textListener;
} else {
return super.getListeners(listenerType);
}
return AWTEventMulticaster.getListeners(l, listenerType);
|
| public synchronized java.lang.String | getSelectedText()Returns the selected text from the text that is
presented by this text component.
return getText().substring(getSelectionStart(), getSelectionEnd());
|
| public synchronized int | getSelectionEnd()Gets the end position of the selected text in
this text component.
TextComponentPeer peer = (TextComponentPeer)this.peer;
if (peer != null) {
selectionEnd = peer.getSelectionEnd();
}
return selectionEnd;
|
| public synchronized int | getSelectionStart()Gets the start position of the selected text in
this text component.
TextComponentPeer peer = (TextComponentPeer)this.peer;
if (peer != null) {
selectionStart = peer.getSelectionStart();
}
return selectionStart;
|
| public synchronized java.lang.String | getText()Returns the text that is presented by this text component.
By default, this is an empty string.
TextComponentPeer peer = (TextComponentPeer)this.peer;
if (peer != null) {
text = peer.getText();
}
return text;
|
| public synchronized java.awt.event.TextListener[] | getTextListeners()Returns an array of all the text listeners
registered on this text component.
return (TextListener[])(getListeners(TextListener.class));
|
| public boolean | isEditable()Indicates whether or not this text component is editable.
return editable;
|
| protected java.lang.String | paramString()Returns a string representing the state of this
TextComponent. 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
null.
String str = super.paramString() + ",text=" + getText();
if (editable) {
str += ",editable";
}
return str + ",selection=" + getSelectionStart() + "-" + getSelectionEnd();
|
| protected void | processEvent(java.awt.AWTEvent e)Processes events on this text component. If the event is a
TextEvent, it invokes the processTextEvent
method else it invokes its superclass's processEvent.
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception.
if (e instanceof TextEvent) {
processTextEvent((TextEvent)e);
return;
}
super.processEvent(e);
|
| protected void | processTextEvent(java.awt.event.TextEvent e)Processes text events occurring on this text component by
dispatching them to any registered TextListener objects.
NOTE: This method will not be called unless text events
are enabled for this component. This happens when one of the
following occurs:
- A
TextListener object is registered
via addTextListener
- Text events are enabled via
enableEvents
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception.
TextListener listener = textListener;
if (listener != null) {
int id = e.getID();
switch (id) {
case TextEvent.TEXT_VALUE_CHANGED:
listener.textValueChanged(e);
break;
}
}
|
| private void | readObject(java.io.ObjectInputStream s)Read the ObjectInputStream, and if it isn't null,
add a listener to receive text events fired by the
TextComponent. Unrecognized keys or values will be
ignored.
GraphicsEnvironment.checkHeadless();
s.defaultReadObject();
// Make sure the state we just read in for text,
// selectionStart and selectionEnd has legal values
this.text = (text != null) ? text : "";
select(selectionStart, selectionEnd);
Object keyOrNull;
while(null != (keyOrNull = s.readObject())) {
String key = ((String)keyOrNull).intern();
if (textListenerK == key) {
addTextListener((TextListener)(s.readObject()));
} else {
// skip value for unrecognized key
s.readObject();
}
}
enableInputMethodsIfNecessary();
checkSystemClipboardAccess();
|
| public void | removeNotify()Removes the TextComponent's peer.
The peer allows us to modify the appearance of the
TextComponent without changing its
functionality.
synchronized (getTreeLock()) {
TextComponentPeer peer = (TextComponentPeer)this.peer;
if (peer != null) {
text = peer.getText();
selectionStart = peer.getSelectionStart();
selectionEnd = peer.getSelectionEnd();
}
super.removeNotify();
}
|
| public synchronized void | removeTextListener(java.awt.event.TextListener l)Removes the specified text event listener so that it no longer
receives text events from this text component
If l is null, no exception is
thrown and no action is performed.
Refer to AWT Threading Issues for details on AWT's threading model.
if (l == null) {
return;
}
textListener = AWTEventMulticaster.remove(textListener, l);
|
| public synchronized void | select(int selectionStart, int selectionEnd)Selects the text between the specified start and end positions.
This method sets the start and end positions of the
selected text, enforcing the restriction that the start position
must be greater than or equal to zero. The end position must be
greater than or equal to the start position, and less than or
equal to the length of the text component's text. The
character positions are indexed starting with zero.
The length of the selection is
endPosition - startPosition, so the
character at endPosition is not selected.
If the start and end positions of the selected text are equal,
all text is deselected.
If the caller supplies values that are inconsistent or out of
bounds, the method enforces these constraints silently, and
without failure. Specifically, if the start position or end
position is greater than the length of the text, it is reset to
equal the text length. If the start position is less than zero,
it is reset to zero, and if the end position is less than the
start position, it is reset to the start position.
String text = getText();
if (selectionStart < 0) {
selectionStart = 0;
}
if (selectionStart > text.length()) {
selectionStart = text.length();
}
if (selectionEnd > text.length()) {
selectionEnd = text.length();
}
if (selectionEnd < selectionStart) {
selectionEnd = selectionStart;
}
this.selectionStart = selectionStart;
this.selectionEnd = selectionEnd;
TextComponentPeer peer = (TextComponentPeer)this.peer;
if (peer != null) {
peer.select(selectionStart, selectionEnd);
}
|
| public synchronized void | selectAll()Selects all the text in this text component.
String text = getText();
this.selectionStart = 0;
this.selectionEnd = getText().length();
TextComponentPeer peer = (TextComponentPeer)this.peer;
if (peer != null) {
peer.select(selectionStart, selectionEnd);
}
|
| public void | setBackground(java.awt.Color c)Sets the background color of this text component.
backgroundSetByClientCode = true;
super.setBackground(c);
|
| public synchronized void | setCaretPosition(int position)Sets the position of the text insertion caret.
The caret position is constrained to be between 0
and the last character of the text, inclusive.
If the passed-in value is greater than this range,
the value is set to the last character (or 0 if
the TextComponent contains no text)
and no error is returned. If the passed-in value is
less than 0, an IllegalArgumentException
is thrown.
if (position < 0) {
throw new IllegalArgumentException("position less than zero.");
}
int maxposition = getText().length();
if (position > maxposition) {
position = maxposition;
}
TextComponentPeer peer = (TextComponentPeer)this.peer;
if (peer != null) {
peer.setCaretPosition(position);
} else {
select(position, position);
}
|
| public synchronized void | setEditable(boolean b)Sets the flag that determines whether or not this
text component is editable.
If the flag is set to true, this text component
becomes user editable. If the flag is set to false,
the user cannot change the text of this text component.
By default, non-editable text components have a background color
of SystemColor.control. This default can be overridden by
calling setBackground.
if (editable == b) {
return;
}
editable = b;
TextComponentPeer peer = (TextComponentPeer)this.peer;
if (peer != null) {
peer.setEditable(b);
}
|
| public synchronized void | setSelectionEnd(int selectionEnd)Sets the selection end for this text component to
the specified position. The new end point is constrained
to be at or after the current selection start. It also
cannot be set beyond the end of the component's text.
If the caller supplies a value for selectionEnd
that is out of bounds, the method enforces these constraints
silently, and without failure.
/* Route through select method to enforce consistent policy
* between selectionStart and selectionEnd.
*/
select(getSelectionStart(), selectionEnd);
|
| public synchronized void | setSelectionStart(int selectionStart)Sets the selection start for this text component to
the specified position. The new start point is constrained
to be at or before the current selection end. It also
cannot be set to less than zero, the beginning of the
component's text.
If the caller supplies a value for selectionStart
that is out of bounds, the method enforces these constraints
silently, and without failure.
/* Route through select method to enforce consistent policy
* between selectionStart and selectionEnd.
*/
select(selectionStart, getSelectionEnd());
|
| public synchronized void | setText(java.lang.String t)Sets the text that is presented by this
text component to be the specified text.
text = (t != null) ? t : "";
TextComponentPeer peer = (TextComponentPeer)this.peer;
if (peer != null) {
peer.setText(text);
}
|
| private void | writeObject(java.io.ObjectOutputStream s)Writes default serializable fields to stream. Writes
a list of serializable TextListener(s) as optional data.
The non-serializable TextListener(s) are detected and
no attempt is made to serialize them.
// Serialization support. Since the value of the fields
// selectionStart, selectionEnd, and text aren't necessarily
// up to date, we sync them up with the peer before serializing.
TextComponentPeer peer = (TextComponentPeer)this.peer;
if (peer != null) {
text = peer.getText();
selectionStart = peer.getSelectionStart();
selectionEnd = peer.getSelectionEnd();
}
s.defaultWriteObject();
AWTEventMulticaster.save(s, textListenerK, textListener);
s.writeObject(null);
|
