JTextAreapublic class JTextArea extends JTextComponent A JTextArea is a multi-line area that displays plain text.
It is intended to be a lightweight component that provides source
compatibility with the java.awt.TextArea class where it can
reasonably do so.
You can find information and examples of using all the text components in
Using Text Components,
a section in The Java Tutorial.
This component has capabilities not found in the
java.awt.TextArea class. The superclass should be
consulted for additional capabilities.
Alternative multi-line text classes with
more capabilities are JTextPane and JEditorPane .
The java.awt.TextArea internally handles scrolling.
JTextArea is different in that it doesn't manage scrolling,
but implements the swing Scrollable interface. This allows it
to be placed inside a JScrollPane if scrolling
behavior is desired, and used directly if scrolling is not desired.
The java.awt.TextArea has the ability to do line wrapping.
This was controlled by the horizontal scrolling policy. Since
scrolling is not done by JTextArea directly, backward
compatibility must be provided another way. JTextArea has
a bound property for line wrapping that controls whether or
not it will wrap lines. By default, the line wrapping property
is set to false (not wrapped).
java.awt.TextArea has two properties rows
and columns that are used to determine the preferred size.
JTextArea uses these properties to indicate the
preferred size of the viewport when placed inside a JScrollPane
to match the functionality provided by java.awt.TextArea .
JTextArea has a preferred size of what is needed to
display all of the text, so that it functions properly inside of
a JScrollPane . If the value for rows
or columns is equal to zero,
the preferred size along that axis is used for
the viewport preferred size along the same axis.
The java.awt.TextArea could be monitored for changes by adding
a TextListener for TextEvent s.
In the JTextComponent based
components, changes are broadcasted from the model via a
DocumentEvent to DocumentListeners .
The DocumentEvent gives
the location of the change and the kind of change if desired.
The code fragment might look something like:
DocumentListener myListener = ??;
JTextArea myArea = ??;
myArea.getDocument().addDocumentListener(myListener);
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 JavaBeansTM
has been added to the java.beans package.
Please see {@link java.beans.XMLEncoder}. |
Fields Summary |
---|
private static final String | uiClassID | private int | rows | private int | columns | private int | columnWidth | private int | rowHeight | private boolean | wrap | private boolean | word |
Constructors Summary |
---|
public JTextArea()Constructs a new TextArea. A default model is set, the initial string
is null, and rows/columns are set to 0.
this(null, null, 0, 0);
| public JTextArea(String text)Constructs a new TextArea with the specified text displayed.
A default model is created and rows/columns are set to 0.
this(null, text, 0, 0);
| public JTextArea(int rows, int columns)Constructs a new empty TextArea with the specified number of
rows and columns. A default model is created, and the initial
string is null.
this(null, null, rows, columns);
| public JTextArea(String text, int rows, int columns)Constructs a new TextArea with the specified text and number
of rows and columns. A default model is created.
this(null, text, rows, columns);
| public JTextArea(Document doc)Constructs a new JTextArea with the given document model, and defaults
for all of the other arguments (null, 0, 0).
this(doc, null, 0, 0);
| public JTextArea(Document doc, String text, int rows, int columns)Constructs a new JTextArea with the specified number of rows
and columns, and the given model. All of the constructors
feed through this constructor.
super();
this.rows = rows;
this.columns = columns;
if (doc == null) {
doc = createDefaultModel();
}
setDocument(doc);
if (text != null) {
setText(text);
select(0, 0);
}
if (rows < 0) {
throw new IllegalArgumentException("rows: " + rows);
}
if (columns < 0) {
throw new IllegalArgumentException("columns: " + columns);
}
LookAndFeel.installProperty(this,
"focusTraversalKeysForward",
JComponent.
getManagingFocusForwardTraversalKeys());
LookAndFeel.installProperty(this,
"focusTraversalKeysBackward",
JComponent.
getManagingFocusBackwardTraversalKeys());
|
Methods Summary |
---|
public void | append(java.lang.String str)Appends the given text to the end of the document. Does nothing if
the model is null or the string is null or empty.
This method is thread safe, although most Swing methods
are not. Please see
Threads
and Swing for more information.
Document doc = getDocument();
if (doc != null) {
try {
doc.insertString(doc.getLength(), str, null);
} catch (BadLocationException e) {
}
}
| protected javax.swing.text.Document | createDefaultModel()Creates the default implementation of the model
to be used at construction if one isn't explicitly
given. A new instance of PlainDocument is returned.
return new PlainDocument();
| public javax.accessibility.AccessibleContext | getAccessibleContext()Gets the AccessibleContext associated with this JTextArea.
For JTextAreas, the AccessibleContext takes the form of an
AccessibleJTextArea.
A new AccessibleJTextArea instance is created if necessary.
if (accessibleContext == null) {
accessibleContext = new AccessibleJTextArea();
}
return accessibleContext;
| protected int | getColumnWidth()Gets column width.
The meaning of what a column is can be considered a fairly weak
notion for some fonts. This method is used to define the width
of a column. By default this is defined to be the width of the
character m for the font used. This method can be
redefined to be some alternative amount.
if (columnWidth == 0) {
FontMetrics metrics = getFontMetrics(getFont());
columnWidth = metrics.charWidth('m");
}
return columnWidth;
| public int | getColumns()Returns the number of columns in the TextArea.
return columns;
| public int | getLineCount()Determines the number of lines contained in the area.
Element map = getDocument().getDefaultRootElement();
return map.getElementCount();
| public int | getLineEndOffset(int line)Determines the offset of the end of the given line.
int lineCount = getLineCount();
if (line < 0) {
throw new BadLocationException("Negative line", -1);
} else if (line >= lineCount) {
throw new BadLocationException("No such line", getDocument().getLength()+1);
} else {
Element map = getDocument().getDefaultRootElement();
Element lineElem = map.getElement(line);
int endOffset = lineElem.getEndOffset();
// hide the implicit break at the end of the document
return ((line == lineCount - 1) ? (endOffset - 1) : endOffset);
}
| public int | getLineOfOffset(int offset)Translates an offset into the components text to a
line number.
Document doc = getDocument();
if (offset < 0) {
throw new BadLocationException("Can't translate offset to line", -1);
} else if (offset > doc.getLength()) {
throw new BadLocationException("Can't translate offset to line", doc.getLength()+1);
} else {
Element map = getDocument().getDefaultRootElement();
return map.getElementIndex(offset);
}
| public int | getLineStartOffset(int line)Determines the offset of the start of the given line.
int lineCount = getLineCount();
if (line < 0) {
throw new BadLocationException("Negative line", -1);
} else if (line >= lineCount) {
throw new BadLocationException("No such line", getDocument().getLength()+1);
} else {
Element map = getDocument().getDefaultRootElement();
Element lineElem = map.getElement(line);
return lineElem.getStartOffset();
}
| public boolean | getLineWrap()Gets the line-wrapping policy of the text area. If set
to true the lines will be wrapped if they are too long
to fit within the allocated width. If set to false,
the lines will always be unwrapped.
return wrap;
| public java.awt.Dimension | getPreferredScrollableViewportSize()Returns the preferred size of the viewport if this component
is embedded in a JScrollPane. This uses the desired column
and row settings if they have been set, otherwise the superclass
behavior is used.
Dimension size = super.getPreferredScrollableViewportSize();
size = (size == null) ? new Dimension(400,400) : size;
size.width = (columns == 0) ? size.width : columns * getColumnWidth();
size.height = (rows == 0) ? size.height : rows * getRowHeight();
return size;
| public java.awt.Dimension | getPreferredSize()Returns the preferred size of the TextArea. This is the
maximum of the size needed to display the text and the
size requested for the viewport.
Dimension d = super.getPreferredSize();
d = (d == null) ? new Dimension(400,400) : d;
Insets insets = getInsets();
if (columns != 0) {
d.width = Math.max(d.width, columns * getColumnWidth() +
insets.left + insets.right);
}
if (rows != 0) {
d.height = Math.max(d.height, rows * getRowHeight() +
insets.top + insets.bottom);
}
return d;
| protected int | getRowHeight()Defines the meaning of the height of a row. This defaults to
the height of the font.
if (rowHeight == 0) {
FontMetrics metrics = getFontMetrics(getFont());
rowHeight = metrics.getHeight();
}
return rowHeight;
| public int | getRows()Returns the number of rows in the TextArea.
return rows;
| public boolean | getScrollableTracksViewportWidth()Returns true if a viewport should always force the width of this
Scrollable to match the width of the viewport. This is implemented
to return true if the line wrapping policy is true, and false
if lines are not being wrapped.
return (wrap) ? true : super.getScrollableTracksViewportWidth();
| public int | getScrollableUnitIncrement(java.awt.Rectangle visibleRect, int orientation, int direction)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. This is implemented
to use the values returned by the getRowHeight and
getColumnWidth methods.
Scrolling containers, like JScrollPane, will use this method
each time the user requests a unit scroll.
switch (orientation) {
case SwingConstants.VERTICAL:
return getRowHeight();
case SwingConstants.HORIZONTAL:
return getColumnWidth();
default:
throw new IllegalArgumentException("Invalid orientation: " + orientation);
}
| public int | getTabSize()Gets the number of characters used to expand tabs. If the document is
null or doesn't have a tab setting, return a default of 8.
int size = 8;
Document doc = getDocument();
if (doc != null) {
Integer i = (Integer) doc.getProperty(PlainDocument.tabSizeAttribute);
if (i != null) {
size = i.intValue();
}
}
return size;
| public java.lang.String | getUIClassID()Returns the class ID for the UI.
return uiClassID;
| public boolean | getWrapStyleWord()Gets the style of wrapping used if the text area is wrapping
lines. If set to true the lines will be wrapped at word
boundaries (ie whitespace) if they are too long
to fit within the allocated width. If set to false,
the lines will be wrapped at character boundaries.
return word;
| public void | insert(java.lang.String str, int pos)Inserts the specified text at the specified position. Does nothing
if the model is null or if the text is null or empty.
This method is thread safe, although most Swing methods
are not. Please see
Threads
and Swing for more information.
Document doc = getDocument();
if (doc != null) {
try {
doc.insertString(pos, str, null);
} catch (BadLocationException e) {
throw new IllegalArgumentException(e.getMessage());
}
}
| protected java.lang.String | paramString()Returns a string representation of this JTextArea. 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 wrapString = (wrap ?
"true" : "false");
String wordString = (word ?
"true" : "false");
return super.paramString() +
",colums=" + columns +
",columWidth=" + columnWidth +
",rows=" + rows +
",rowHeight=" + rowHeight +
",word=" + wordString +
",wrap=" + wrapString;
| public void | replaceRange(java.lang.String str, int start, int end)Replaces text from the indicated start to end position with the
new text specified. Does nothing if the model is null. Simply
does a delete if the new string is null or empty.
This method is thread safe, although most Swing methods
are not. Please see
Threads
and Swing for more information.
if (end < start) {
throw new IllegalArgumentException("end before start");
}
Document doc = getDocument();
if (doc != null) {
try {
if (doc instanceof AbstractDocument) {
((AbstractDocument)doc).replace(start, end - start, str,
null);
}
else {
doc.remove(start, end - start);
doc.insertString(start, str, null);
}
} catch (BadLocationException e) {
throw new IllegalArgumentException(e.getMessage());
}
}
| public void | setColumns(int columns)Sets the number of columns for this TextArea. Does an invalidate()
after setting the new value.
int oldVal = this.columns;
if (columns < 0) {
throw new IllegalArgumentException("columns less than zero.");
}
if (columns != oldVal) {
this.columns = columns;
invalidate();
}
| public void | setFont(java.awt.Font f)Sets the current font. This removes cached row height and column
width so the new font will be reflected, and calls revalidate().
super.setFont(f);
rowHeight = 0;
columnWidth = 0;
| public void | setLineWrap(boolean wrap)Sets the line-wrapping policy of the text area. If set
to true the lines will be wrapped if they are too long
to fit within the allocated width. If set to false,
the lines will always be unwrapped. A PropertyChange
event ("lineWrap") is fired when the policy is changed.
By default this property is false.
boolean old = this.wrap;
this.wrap = wrap;
firePropertyChange("lineWrap", old, wrap);
| public void | setRows(int rows)Sets the number of rows for this TextArea. Calls invalidate() after
setting the new value.
int oldVal = this.rows;
if (rows < 0) {
throw new IllegalArgumentException("rows less than zero.");
}
if (rows != oldVal) {
this.rows = rows;
invalidate();
}
| public void | setTabSize(int size)Sets the number of characters to expand tabs to.
This will be multiplied by the maximum advance for
variable width fonts. A PropertyChange event ("tabSize") is fired
when the tab size changes.
Document doc = getDocument();
if (doc != null) {
int old = getTabSize();
doc.putProperty(PlainDocument.tabSizeAttribute, new Integer(size));
firePropertyChange("tabSize", old, size);
}
| public void | setWrapStyleWord(boolean word)Sets the style of wrapping used if the text area is wrapping
lines. If set to true the lines will be wrapped at word
boundaries (whitespace) if they are too long
to fit within the allocated width. If set to false,
the lines will be wrapped at character boundaries.
By default this property is false.
boolean old = this.word;
this.word = word;
firePropertyChange("wrapStyleWord", old, word);
| private void | writeObject(java.io.ObjectOutputStream s)See readObject() and writeObject() in JComponent for more
information about serialization in Swing.
s.defaultWriteObject();
if (getUIClassID().equals(uiClassID)) {
byte count = JComponent.getWriteObjCounter(this);
JComponent.setWriteObjCounter(this, --count);
if (count == 0 && ui != null) {
ui.installUI(this);
}
}
|
|