JTable is used to display and edit regular two-dimensional tables
of cells.
See How to Use Tables
in The Java Tutorial
for task-oriented documentation and examples of using JTable.
The JTable has many
facilities that make it possible to customize its rendering and editing
but provides defaults for these features so that simple tables can be
set up easily. For example, to set up a table with 10 rows and 10
columns of numbers:
TableModel dataModel = new AbstractTableModel() {
public int getColumnCount() { return 10; }
public int getRowCount() { return 10;}
public Object getValueAt(int row, int col) { return new Integer(row*col); }
};
JTable table = new JTable(dataModel);
JScrollPane scrollpane = new JScrollPane(table);
Note that if you wish to use a JTable in a standalone
view (outside of a JScrollPane) and want the header
displayed, you can get it using #getTableHeader
and
display it separately.
When designing applications that use the JTable it is worth paying
close attention to the data structures that will represent the table's data.
The DefaultTableModel is a model implementation that
uses a Vector of Vectors of Objects to
store the cell values. As well as copying the data from an
application into the DefaultTableModel,
it is also possible to wrap the data in the methods of the
TableModel interface so that the data can be passed to the
JTable directly, as in the example above. This often results
in more efficient applications because the model is free to choose the
internal representation that best suits the data.
A good rule of thumb for deciding whether to use the AbstractTableModel
or the DefaultTableModel is to use the AbstractTableModel
as the base class for creating subclasses and the DefaultTableModel
when subclassing is not required.
The "TableExample" directory in the demo area of the source distribution
gives a number of complete examples of JTable usage,
covering how the JTable can be used to provide an
editable view of data taken from a database and how to modify
the columns in the display to use specialized renderers and editors.
The JTable uses integers exclusively to refer to both the rows and the columns
of the model that it displays. The JTable simply takes a tabular range of cells
and uses getValueAt(int, int) to retrieve the
values from the model during painting.
By default, columns may be rearranged in the JTable so that the
view's columns appear in a different order to the columns in the model.
This does not affect the implementation of the model at all: when the
columns are reordered, the JTable maintains the new order of the columns
internally and converts its column indices before querying the model.
So, when writing a TableModel, it is not necessary to listen for column
reordering events as the model will be queried in its own coordinate
system regardless of what is happening in the view.
In the examples area there is a demonstration of a sorting algorithm making
use of exactly this technique to interpose yet another coordinate system
where the order of the rows is changed, rather than the order of the columns.
J2SE 5 adds methods to JTable to provide convenient access to some
common printing needs. Simple new
methods allow for quick
and easy addition of printing support to your application. In addition, a new
#getPrintable
method is available for more advanced printing needs.
As for all JComponent classes, you can use
InputMap
and ActionMap
to associate an
Action
object with a KeyStroke
and execute the
action under specified conditions.
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 java.beans.XMLEncoder
.
JTable that is initialized with a default
data model, a default column model, and a default selection
model.JTable that is initialized with
dm as the data model, a default column model,
and a default selection model.JTable that is initialized with
dm as the data model, cm
as the column model, and a default selection model.JTable that is initialized with
dm as the data model, cm as the
column model, and sm as the selection model.
If any of the parameters are null this method
will initialize the table with the corresponding default model.
The autoCreateColumnsFromModel flag is set to false
if cm is non-null, otherwise it is set to true
and the column model is populated with suitable
TableColumns for the columns in dm.JTable with numRows
and numColumns of empty cells using
DefaultTableModel. The columns will have
names of the form "A", "B", "C", etc.JTable to display the values in the
Vector of Vectors, rowData,
with column names, columnNames. The
Vectors contained in rowData
should contain the values for that row. In other words,
the value of the cell at row 1, column 5 can be obtained
with the following code:
((Vector)rowData.elementAt(1)).elementAt(5);
JTable to display the values in the two dimensional array,
rowData, with column names, columnNames.
rowData is an array of rows, so the value of the cell at row 1,
column 5 can be obtained with the following code:
rowData[1][5];
All rows must be of the same length as columnNames.
getAlignmentY.
Specifies an alignment to the bottom of the component.getAlignmentY and
getAlignmentX. Specifies an alignment to
the center of the componentgetAlignmentX.
Specifies an alignment to the left side of the component.getAlignmentX.
Specifies an alignment to the right side of the component.getAlignmentY().
Specifies an alignment to the top of the component.registerKeyboardAction that
means that the command should be invoked when the receiving
component is an ancestor of the focused component or is
itself the focused component.registerKeyboardAction that
means that the command should be invoked when
the component has the focus.registerKeyboardAction that
means that the command should be invoked when
the receiving component is in the window that has the focus
or is itself the focused component.
Note: If a component has been added to a container that
has been displayed, validate must be
called on that container to display the new component.
If multiple components are being added, you can improve
efficiency by calling validate only once,
after all the components have been added.
Note: If a component has been added to a container that
has been displayed, validate must be
called on that container to display the new component.
If multiple components are being added, you can improve
efficiency by calling validate only once,
after all the components have been added.
Note: If a component has been added to a container that
has been displayed, validate must be
called on that container to display the new component.
If multiple components are being added, you can improve
efficiency by calling validate only once,
after all the components have been added.
Note: If a component has been added to a container that
has been displayed, validate must be
called on that container to display the new component.
If multiple components are being added, you can improve
efficiency by calling validate only once,
after all the components have been added.
This method is obsolete as of 1.1. Please use the
method add(Component, Object) instead.
listener so that it will receive
AncestorEvents when it or any of its ancestors
move or are made visible or invisible.
Events are also sent when the component or its ancestors are added
or removed from the containment hierarchy.aColumn to the end of the array of columns held by
this JTable's column model.
If the column name of aColumn is null,
sets the column name of aColumn to the name
returned by getModel().getColumnName().
To add a column to this JTable to display the
modelColumn'th column of data in the model with a
given width, cellRenderer,
and cellEditor you can use:
addColumn(new TableColumn(modelColumn, width, cellRenderer, cellEditor));
[Any of the TableColumn constructors can be used
instead of this one.]
The model column number is stored inside the TableColumn
and is used during rendering and editing to locate the appropriates
data values in the model. The model column number does not change
when columns are reordered in the view.index0 to index1,
inclusive, to the current selection.l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.getInputMethodRequests to return an
InputMethodRequests instance.
If listener l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.For information on how mouse wheel events are dispatched, see the class description for MouseWheelEvent .
If l is null, no exception is thrown and no
action is performed.
configureEnclosingScrollPane method.If listener is null, no exception is thrown and no action is performed.
If listener is null, no exception is thrown and no action is performed.
index0 to index1, inclusive, to
the current selection.VetoableChangeListener to the listener list.
The listener is registered for all properties.ComponentOrientation property of this container
and all components contained within it.false, this Container is inheriting the
Set from an ancestor, or from the current KeyboardFocusManager.toggle and extend. Most changes
to the selection that are the result of keyboard or mouse events received
by the UI are channeled through this method so that the behavior may be
overridden by a subclass. Some UIs may need more functionality than
this method provides, such as when manipulating the lead for discontiguous
selection, and may not call into this method for some selection changes.
This implementation uses the following conventions:
toggle: false, extend: false.
Clear the previous selection and ensure the new cell is selected.
toggle: false, extend: true.
Extend the previous selection from the anchor to the specified cell,
clearing all other selections.
toggle: true, extend: false.
If the specified cell is selected, deselect it. If it is not selected, select it.
toggle: true, extend: true.
Leave the selection state as it is, but move the anchor index to the specified location.
This method does not cause the image to begin loading. An
application must use the prepareImage method
to force the loading of an image.
Information on the flags returned by this method can be found
with the discussion of the ImageObserver interface.
This method does not cause the image to begin loading. An
application must use the prepareImage method
to force the loading of an image.
The checkImage method of Component
calls its peer's checkImage method to calculate
the flags. If this component does not yet have a peer, the
component's toolkit's checkImage method is called
instead.
Information on the flags returned by this method can be found
with the discussion of the ImageObserver interface.
point lies in,
or -1 if the result is not in the range
[0, getColumnCount()-1].Component's "visible rect rectangle" - the
intersection of the visible rectangles for this component
and all of its ancestors. The return value is stored in
visibleRect.viewColumnIndex to the index of the column
in the table model. Returns the index of the corresponding
column in the model. If viewColumnIndex
is less than zero, returns viewColumnIndex.modelColumnIndex to the index of the column
in the view. Returns the index of the
corresponding column in the view; returns -1 if this column is not
being displayed. If modelColumnIndex is less than zero,
returns modelColumnIndex.getColumnCount method
defined in the TableModel interface.
Clears any existing columns before creating the new columns based on information from the model.
new JScrollPane(aTable).JToolTip that should be used
to display the tooltip.
Components typically would not override this method,
but it can be used to
cause different tooltips to be displayed differently.VolatileImage interface.processEvent before returning for 1.1-style
events which have been enabled for the Component.JTable's
columns is equal to the width of the table.
Before the layout begins the method gets the
resizingColumn of the tableHeader.
When the method is called as a result of the resizing of an enclosing window,
the resizingColumn is null. This means that resizing
has taken place "outside" the JTable and the change -
or "delta" - should be distributed to all of the columns regardless
of this JTable's automatic resize mode.
If the resizingColumn is not null, it is one of
the columns in the table that has changed size rather than
the table itself. In this case the auto-resize modes govern
the way the extra (or deficit) space is distributed
amongst the available columns.
The modes are:
Viewport. If the JTable is not
enclosed in a JScrollPane this may
leave parts of the table invisible.
JTable, including the one that is being
adjusted.
JTable makes adjustments
to the widths of the columns it respects their minimum and
maximum values absolutely. It is therefore possible that,
even after this method is called, the total width of the columns
is still not equal to the width of the table. When this happens
the JTable does not put itself
in AUTO_RESIZE_OFF mode to bring up a scroll bar, or break other
commitments of its current auto-resize mode -- instead it
allows its bounds to be set larger (or smaller) than the total of the
column minimum or maximum, meaning, either that there
will not be enough room to display all of the columns, or that the
columns will not fill the JTable's bounds.
These respectively, result in the clipping of some columns
or an area being painted in the JTable's
background color during painting.
The mechanism for distributing the delta amongst the available
columns is provided in a private method in the JTable
class:
adjustSizes(long targetSize, final Resizable3 r, boolean inverse)an explanation of which is provided in the following section.
Resizable3 is a private
interface that allows any data structure containing a collection
of elements with a size, preferred size, maximum size and minimum size
to have its elements manipulated by the algorithm.
Call "DELTA" the difference between the target size and the sum of the preferred sizes of the elements in r. The individual sizes are calculated by taking the original preferred sizes and adding a share of the DELTA - that share being based on how far each preferred size is from its limiting bound (minimum or maximum).
Call the individual constraints min[i], max[i], and pref[i].
Call their respective sums: MIN, MAX, and PREF.
Each new size will be calculated using:
size[i] = pref[i] + delta[i]
where each individual delta[i] is calculated according to:
If (DELTA < 0) we are in shrink mode where:
DELTA
delta[i] = ------------ * (pref[i] - min[i])
(PREF - MIN)
If (DELTA > 0) we are in expand mode where:
DELTA
delta[i] = ------------ * (max[i] - pref[i])
(MAX - PREF)
The overall effect is that the total size moves that same percentage, k, towards the total minimum or maximum and that percentage guarantees accomodation of the required space, DELTA.
Naive evaluation of the formulae presented here would be subject to
the aggregated rounding errors caused by doing this operation in finite
precision (using ints). To deal with this, the multiplying factor above,
is constantly recalculated and this takes account of the rounding
errors in the previous iterations. The result is an algorithm that
produces a set of integers whose values exactly sum to the supplied
targetSize, and does so by spreading the rounding
errors evenly over the given elements.
When targetSize is outside the [MIN, MAX] range,
the algorithm sets all sizes to their appropriate limiting value
(maximum or minimum).
row and
column, if those indices are in the valid range, and
the cell at those indices is editable.
Note that this is a convenience method for
editCellAt(int, int, null).row and
column, if those indices are in the valid range, and
the cell at those indices is editable.
To prevent the JTable from
editing a particular table, column or cell value, return false from
the isCellEditable method in the TableModel
interface.
The equals method implements an equivalence relation
on non-null object references:
x, x.equals(x) should return
true.
x and y, x.equals(y)
should return true if and only if
y.equals(x) returns true.
x, y, and z, if
x.equals(y) returns true and
y.equals(z) returns true, then
x.equals(z) should return true.
x and y, multiple invocations of
x.equals(y) consistently return true
or consistently return false, provided no
information used in equals comparisons on the
objects is modified.
x,
x.equals(null) should return false.
The equals method for class Object implements
the most discriminating possible equivalence relation on objects;
that is, for any non-null reference values x and
y, this method returns true if and only
if x and y refer to the same object
(x == y has the value true).
Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
The findComponentAt method is different from getComponentAt in that getComponentAt only searches the Container's immediate children; if the containing component is a Container, findComponentAt will search that child to find a nested component.
The findComponentAt method is different from getComponentAt in that getComponentAt only searches the Container's immediate children; if the containing component is a Container, findComponentAt will search that child to find a nested component.
ActionMap used to determine what
Action to fire for particular KeyStroke
binding. The returned ActionMap, unless otherwise
set, will have the ActionMap from the UI set as the parent.Container.getAlignmentX to return
the vertical alignment.Container.getAlignmentY to return
the horizontal alignment.setModel will clear any existing columns and
create new columns from the new model. Also, if the event in
the tableChanged notification specifies that the
entire table changed, then the columns will be rebuilt.
The default is true.autoscrolls property.null if no
border is currently set.Rectangle object. The bounds specify this
component's width, height, and location relative to
its parent.rv and returns rv.
If rv is null a new Rectangle
is allocated. This version of getBounds is useful
if the caller wants to avoid allocating a new Rectangle
object on the heap.row and column. If the
TableColumn for this column has a non-null editor,
returns that. If not, finds the class of the data in this
column (using getColumnClass)
and returns the default editor for this type of data.
Note: Throughout the table package, the internal implementations always use this method to provide editors so that this default behavior can be safely overridden by a subclass.
row and column.
If includeSpacing is true then the value returned
has the full height and width of the row and column
specified. If it is false, the returned rectangle is inset by the
intercell spacing to return the true bounds of the rendering or
editing component as it will be set during rendering.
If the column index is valid but the row index is less
than zero the method returns a rectangle with the
y and height values set appropriately
and the x and width values both set
to zero. In general, when either the row or column indices indicate a
cell outside the appropriate range, the method returns a rectangle
depicting the closest edge of the closest cell that is within
the table's range. When both row and column indices are out
of range the returned rectangle covers the closest
point of the closest cell.
In all cases, calculations that use this method to calculate
results along one axis will not fail because of anomalies in
calculations along the other axis. When the cell is not valid
the includeSpacing parameter is ignored.
TableColumn for this column has a non-null
renderer, returns that. If not, finds the class of the data in
this column (using getColumnClass)
and returns the default renderer for this type of data.
Note: Throughout the table package, the internal implementations always use this method to provide renderers so that this default behavior can be safely overridden by a subclass.
getRowSelectionAllowed() &&
getColumnSelectionAllowed().putClientProperty will return
a non-null value.ColorModel used to display
the component on the output device.TableColumn object for the column in the table
whose identifier is equal to identifier, when compared using
equals.column.TableColumnModel that contains all column information
of this table.column.LayoutManager
and Component
subclasses that wish to respect orientation should call this method to
get the component's orientation before performing layout or drawing.JPopupMenu that assigned for this component.
If this component does not have a JPopupMenu assigned
to it and getInheritsPopupMenu is true, this
will return getParent().getComponentPopupMenu() (assuming
the parent is valid.)
For Java 2 platform v1.3, a KeyStroke can be associated
with more than one condition.
For example, 'a' could be bound for the two
conditions WHEN_FOCUSED and
WHEN_IN_FOCUSED_WINDOW condition.
Cursor.DEFAULT_CURSOR is returned.TableColumn. During the editing of cells the editor is fetched from
a Hashtable of entries according to the class of the cells in the column. If
there is no entry for this columnClass the method returns
the entry for the most specific superclass. The JTable installs entries
for Object, Number, and Boolean, all of which can be modified
or replaced.TableColumn. During the rendering of cells the renderer is fetched from
a Hashtable of entries according to the class of the cells in the column. If
there is no entry for this columnClass the method returns
the entry for the most specific superclass. The JTable installs entries
for Object, Number, and Boolean, all of which can be modified
or replaced.dragEnabled property.DropTarget associated with this
Component.setFocusTraversalKeys for a full description of each key.)
If a Set of traversal keys has not been explicitly defined for this Container, then this Container's parent's Set is returned. If no Set has been explicitly defined for any of this Container's ancestors, then the current KeyboardFocusManager's default Set is returned.
FontMetrics for the specified Font.Graphics object and
then invoke operations on that object to draw on the component.GraphicsConfiguration associated with this
Component.
If the Component has not been assigned a specific
GraphicsConfiguration,
the GraphicsConfiguration of the
Component object's top-level container is
returned.
If the Component has been created, but not yet added
to a Container, this method returns null.component.getBounds().height, or
component.getSize().height because it doesn't cause any
heap allocations.InputMap that is used when the
component has focus.
This is convenience method for getInputMap(WHEN_FOCUSED).InputMap that is used during
condition.InputMethodRequests instance.
At the same time, it also has to handle input method events.super.getInsets.Insets object containing this component's inset
values. The passed-in Insets object will be reused
if possible.
Calling methods cannot assume that the same object will be returned,
however. All existing values within this object are overwritten.
If insets is null, this will allocate a new one.FooListeners
upon this JComponent.
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
JComponent c
for its mouse listeners with the following code:
MouseListener[] mls = (MouseListener[])(c.getListeners(MouseListener.class));If no such listeners exist, this method returns an empty array.
Due to the asynchronous nature of native event handling, this
method can return outdated values (for instance, after several calls
of setLocation() in rapid succession). For this
reason, the recommended method of obtaining a component's position is
within java.awt.event.ComponentListener.componentMoved(),
which is called after the operating system has finished moving the
component.
rv and returns rv.
If rv is null a new Point
is allocated. This version of getLocation is useful
if the caller wants to avoid allocating a new Point
object on the heap.null value
just returns it. If the UI delegate's getMaximumSize
method returns a non-null value then return that;
otherwise defer to the component's layout manager.null value
just returns it. If the UI delegate's getMinimumSize
method returns a non-null value then return that; otherwise
defer to the component's layout manager.TableModel that provides the data displayed by this
JTable.Component's
coordinate space if the Component is directly under the mouse
pointer, otherwise returns null.
If the Component is not showing on the screen, this method
returns null even if the mouse pointer is above the area
where the Component would be displayed.
If the Component is partially or fully obscured by other
Components or native windows, this method returns a non-null
value only if the mouse pointer is located above the unobscured part of the
Component.
For Containers it returns a non-null value if the mouse is
above the Container itself or above any of its descendants.
Use
if you need to exclude children.
Sometimes the exact mouse coordinates are not important, and the only thing
that matters is whether a specific Component is under the mouse
pointer. If the return value of this method is null, mouse
pointer is not directly above the Component.
Container's
coordinate space if the Container is under the mouse pointer,
otherwise returns null.
This method is similar to
with the exception
that it can take the Container's children into account.
If allowChildren is false, this method will return
a non-null value only if the mouse pointer is above the Container
directly, not above the part obscured by children.
If allowChildren is true, this method returns
a non-null value if the mouse pointer is above Container or any
of its descendants.
Returns the Component set by a prior call to
setNextFocusableComponent(Component) on this
JComponent.
null
is truend the look and feel will choose a suitable location.JList component
is the size required to accommodate all of the cells in its list.
However, the value of preferredScrollableViewportSize
is the size required for JList.getVisibleRowCount rows.
A component without any properties that would affect the viewport
size should just return getPreferredSize here.preferredSize has been set to a
non-null value just returns it.
If the UI delegate's getPreferredSize
method returns a non null value then return that;
otherwise defer to the component's layout manager.Printable for use in printing this JTable.
The Printable can be requested in one of two printing modes.
In both modes, it spreads table rows naturally in sequence across
multiple pages, fitting as many rows as possible per page.
PrintMode.NORMAL specifies that the table be
printed at its current size. In this mode, there may be a need to spread
columns across pages in a similar manner to that of the rows. When the
need arises, columns are distributed in an order consistent with the
table's ComponentOrientation.
PrintMode.FIT_WIDTH specifies that the output be
scaled smaller, if necessary, to fit the table's entire width
(and thereby all columns) on each page. Width and height are scaled
equally, maintaining the aspect ratio of the output.
The Printable heads the portion of table on each page
with the appropriate section from the table's JTableHeader,
if it has one.
Header and footer text can be added to the output by providing
MessageFormat arguments. The printing code requests
Strings from the formats, providing a single item which may be included
in the formatted string: an Integer representing the current
page number.
You are encouraged to read the documentation for
MessageFormat as some characters, such as single-quote,
are special and need to be escaped.
Here's an example of creating a MessageFormat that can be
used to print "Duke's Table: Page - " and the current page number:
// notice the escaping of the single quote
// notice how the page number is included with "{0}"
MessageFormat format = new MessageFormat("Duke''s Table: Page - {0}");
The Printable constrains what it draws to the printable
area of each page that it prints. Under certain circumstances, it may
find it impossible to fit all of a page's content into that area. In
these cases the output may be clipped, but the implementation
makes an effort to do something reasonable. Here are a few situations
where this is known to occur, and how they may be handled by this
particular implementation:
ComponentOrientation.
PrintMode.NORMAL when a column
is too wide to fit in the printable area -- print the center
portion of the column and leave the left and right borders
off the table.
It is entirely valid for this Printable to be wrapped
inside another in order to create complex reports and documents. You may
even request that different pages be rendered into different sized
printable areas. The implementation must be prepared to handle this
(possibly by doing its layout calculations on the fly). However,
providing different heights to each page will likely not work well
with PrintMode.NORMAL when it has to spread columns
across pages.
It is important to note that this Printable prints the
table at its current visual state, using the table's existing renderers.
Before calling this method, you may wish to first modify
the state of the table (such as to change the renderers, cancel editing,
or hide the selection).
You must not, however, modify the table in any way after
this Printable is fetched (invalid modifications include
changes in: size, renderers, or underlying data). The behavior of the
returned Printable is undefined once the table has been
changed.
Here's a simple example that calls this method to fetch a
Printable, shows a cross-platform print dialog, and then
prints the Printable unless the user cancels the dialog:
// prepare the table for printing here first (for example, hide selection)
// wrap in a try/finally so table can be restored even if something fails
try {
// fetch the printable
Printable printable = table.getPrintable(JTable.PrintMode.FIT_WIDTH,
new MessageFormat("My Table"),
new MessageFormat("Page - {0}"));
// fetch a PrinterJob
PrinterJob job = PrinterJob.getPrinterJob();
// set the Printable on the PrinterJob
job.setPrintable(printable);
// create an attribute set to store attributes from the print dialog
PrintRequestAttributeSet attr = new HashPrintRequestAttributeSet();
// display a print dialog and record whether or not the user cancels it
boolean printAccepted = job.printDialog(attr);
// if the user didn't cancel the dialog
if (printAccepted) {
// do the printing (may need to handle PrinterException)
job.print(attr);
}
} finally {
// restore the original table state here (for example, restore selection)
}
KeyStrokes that will initiate
registered actions.JRootPane ancestor for this component.row.getIntercellSpacing().height.Scrolling containers, like JScrollPane, will use this method each time the user requests a block scroll.
Scrolling containers, like JViewport, will use this method each time they are validated.
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 Scrollable
whose ancestor is a JScrollPane effectively disables horizontal
scrolling.
Scrolling containers, like JViewport, will use this method each time they are validated.
Scrolling containers, like JScrollPane, will use this method each time the user requests a unit scroll.
ListSelectionModel that is used to maintain row
selection state.Dimension object. The height
field of the Dimension object contains
this component's height, and the width
field of the Dimension object contains
this component's width.rv and returns rv.
If rv is null a new Dimension
object is allocated. This version of getSize
is useful if the caller wants to avoid allocating a new
Dimension object on the heap.tableHeader used by this JTable.null is returned, Swing will choose a location.
The default implementation returns null.setToolTipText.JComponent's getToolTipText
method in order to allow the renderer's tips to be used
if it has text set.
JTable to properly display
tooltips of its renderers
JTable must be a registered component with the
ToolTipManager.
This is done automatically in initializeLocalVars,
but if at a later point JTable is told
setToolTipText(null) it will unregister the table
component, and no tips from renderers will display anymore.
Window or Applet),
or null if this component has not
been added to any container.transferHandler property.row and column.
Note: The column is specified in the table view's display
order, and not in the TableModel's column
order. This is an important distinction because as the
user rearranges the columns in the table,
the column at a given index in the view will change.
Meanwhile the user's actions never affect the model's
column ordering.
Component's "visible rectangle" - the
intersection of this component's visible rectangle,
new Rectangle(0, 0, getWidth(), getHeight()),
and all of its ancestors' visible rectangles.component.getBounds().width, or
component.getSize().width because it doesn't cause any
heap allocations.component.getBounds().x, or
component.getLocation().x because it doesn't cause any
heap allocations.component.getBounds().y, or
component.getLocation().y because it doesn't cause any
heap allocations.
This method is intended for use by focus implementations. Client code
should not use this method; instead, it should use
requestFocusInWindow().
true if this Component is the
focus owner. This method is obsolete, and has been replaced by
isFocusOwner().java.util.Hashtable.
The general contract of hashCode is:
hashCode method on each of
the two objects must produce the same integer result.
As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the JavaTM programming language.)
imageUpdate method of an ImageObserver
is called when more information about an
image which had been previously requested using an asynchronous
routine such as the drawImage method of
Graphics becomes available.
See the definition of imageUpdate for
more information on this method and its arguments.
The imageUpdate method of Component
incrementally draws an image on the component as more of the bits
of the image are available.
If the system property awt.image.incrementaldraw
is missing or has the value true, the image is
incrementally drawn. If the system property has any other value,
then the image is not drawn until it has been completely loaded.
Also, if incremental drawing is in effect, the value of the
system property awt.image.redrawrate is interpreted
as an integer to give the maximum redraw rate, in milliseconds. If
the system property is missing or cannot be interpreted as an
integer, the redraw rate is once every 100ms.
The interpretation of the x, y,
width, and height arguments depends on
the value of the infoflags argument.
false, this Component is
inheriting its background color from an ancestor.row and column
is editable. Otherwise, invoking setValueAt on the cell
will have no effect.
Note: The column is specified in the table view's display
order, and not in the TableModel's column
order. This is an important distinction because as the
user rearranges the columns in the table,
the column at a given index in the view will change.
Meanwhile the user's actions never affect the model's
column ordering.
false, this Component is inheriting
its cursor from an ancestor.A component is made displayable either when it is added to a displayable containment hierarchy or when its containment hierarchy is made displayable. A containment hierarchy is made displayable when its ancestor window is either packed or made visible.
A component is made undisplayable either when it is removed from a displayable containment hierarchy or when its containment hierarchy is made undisplayable. A containment hierarchy is made undisplayable when its ancestor window is disposed.
setEnabled method.true for both such
Containers in this case.true if this Component is the
focus owner.Component can become the focus
owner.true then when
keyboard focus manager searches container hierarchy for focus
traversal policy and encounters this container before any other
container with this property as true or focus cycle roots then
its focus traversal policy will be used instead of focus cycle
root's policy.false, this
Container will inherit its focus traversal policy from an ancestor.false, this Component is inheriting its
font from an ancestor.false, this Component is
inheriting its foreground color from an ancestor.Component and Container,
other than the ones defined in this package like Button
or Scrollbar, are lightweight.
All of the Swing components are lightweights.
This method will always return false if this component
is not displayable because it is impossible to determine the
weight of an undisplayable component.
Changes this JComponent's focus traversal keys to
CTRL+TAB and CTRL+SHIFT+TAB. Also prevents
SortingFocusTraversalPolicy from considering descendants
of this JComponent when computing a focus traversal cycle.
null
value otherwise returns false.setMinimumSize has been
invoked with a non-null value.An opaque component paints every pixel within its rectangular bounds. A non-opaque component paints only a subset of its pixels or none at all, allowing the pixels underneath it to "show through". Therefore, a component that does not fully paint its pixels provides a degree of transparency.
Subclasses that guarantee to always completely paint their contents should override this method and return true.
JComponent subclasses that can't make this
guarantee, such as JLayeredPane,
should override this method to return false.null value otherwise returns false.true if this JComponent should
get focus; otherwise returns false.
Please see How to Use the Focus Subsystem, a section in The Java Tutorial, for more information.
revalidate calls by
descendants of this component will cause the entire tree
beginning with this root to be validated.
Returns false by default. JScrollPane overrides
this method and returns true.Frame objects.System.out.
The immediate children of the container are printed with
an indentation of indent+1. The children
of those children are printed at indent+2
and so on.
The immediate children of the container are printed with
an indentation of indent+1. The children
of those children are printed at indent+2
and so on.
column to the position currently
occupied by the column targetColumn in the view.
The old column at targetColumn is
shifted left or right to make room.wait methods.
The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object. The awakened thread will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.
This method should only be called by a thread that is the owner of this object's monitor. A thread becomes the owner of the object's monitor in one of three ways:
synchronized statement
that synchronizes on the object.
Class, by executing a
synchronized static method of that class.
Only one thread at a time can own an object's monitor.
wait methods.
The awakened threads will not be able to proceed until the current thread relinquishes the lock on this object. The awakened threads will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened threads enjoy no reliable privilege or disadvantage in being the next thread to lock this object.
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.
paint directly,
but should instead use the repaint method to
schedule the component for redrawing.
This method actually delegates the work of painting to three
protected methods: paintComponent,
paintBorder,
and paintChildren. They're called in the order
listed to ensure that children appear on top of component itself.
Generally speaking, the component and its children should not
paint in the insets area allocated to the border. Subclasses can
just override this method, as always. A subclass that just
wants to specialize the UI (look and feel) delegate's
paint method should just override
paintComponent.
The origin of the graphics context, its
(0, 0) coordinate point, is the
top-left corner of this component. The clipping region of the
graphics context is the bounding rectangle of this component.
It's rarely necessary to call this method. In most cases it's more efficient to call repaint, which defers the actual painting and can collapse redundant requests into a single paint call. This method is useful if one needs to update the display while the current event is being dispatched.
row, column.
Note: Throughout the table package, the internal implementations always use this method to prepare editors so that this default behavior can be safely overridden by a subclass.
The image data is downloaded asynchronously in another thread, and an appropriately scaled screen representation of the image is generated.
row, column.
Returns the component (may be a Component
or a JComponent) under the event location.
Note: Throughout the table package, the internal implementations always use this method to prepare renderers so that this default behavior can be safely overridden by a subclass.
JTable in mode PrintMode.FIT_WIDTH,
with no header or footer text. A modal progress dialog, with an abort
option, will be shown for the duration of printing.
Note: In headless mode, no dialogs will be shown.
printComponent,
printBorder and printChildren. It is
not recommended that you override this method, instead override
one of the previously mentioned methods. This method sets the
component's state such that the double buffer will not be used, eg
painting will be done directly on the passed in Graphics.JTable in the given printing mode,
with no header or footer text. A modal progress dialog, with an abort
option, will be shown for the duration of printing.
Note: In headless mode, no dialogs will be shown.
JTable in the given printing mode,
with the specified header and footer text. A modal progress dialog,
with an abort option, will be shown for the duration of printing.
Note: In headless mode, no dialogs will be shown.
JTable. Takes steps that the majority of
developers would take in order to print a JTable.
In short, it prepares the table, calls getPrintable to
fetch an appropriate Printable, and then sends it to the
printer.
A boolean parameter allows you to specify whether or not
a printing dialog is displayed to the user. When it is, the user may
use the dialog to change printing attributes or even cancel the print.
Another parameter allows for printing attributes to be specified
directly. This can be used either to provide the initial values for the
print dialog, or to supply any needed attributes when the dialog is not
shown.
A second boolean parameter allows you to specify whether
or not to perform printing in an interactive mode. If true,
a modal progress dialog, with an abort option, is displayed for the
duration of printing . This dialog also prevents any user action which
may affect the table. However, it can not prevent the table from being
modified by code (for example, another thread that posts updates using
SwingUtilities.invokeLater). It is therefore the
responsibility of the developer to ensure that no other code modifies
the table in any way during printing (invalid modifications include
changes in: size, renderers, or underlying data). Printing behavior is
undefined when the table is changed during printing.
If false is specified for this parameter, no dialog will
be displayed and printing will begin immediately on the event-dispatch
thread. This blocks any other events, including repaints, from being
processed until printing is complete. Although this effectively prevents
the table from being changed, it doesn't provide a good user experience.
For this reason, specifying false is only recommended when
printing from an application with no visible GUI.
Note: Attempting to show the printing dialog or run interactively, while
in headless mode, will result in a HeadlessException.
Before fetching the printable, this method prepares the table in order to get the most desirable printed result. If the table is currently in an editing mode, it terminates the editing as gracefully as possible. It also ensures that the the table's current selection and focused cell are not indicated in the printed output. This is handled on the view level, and only for the duration of the printing, thus no notification needs to be sent to the selection models.
See #getPrintable for further description on how the table is printed.
print on the component.
The get/putClientProperty methods provide access to
a small per-instance hashtable. Callers can use get/putClientProperty
to annotate components that were created by another module.
For example, a
layout manager might store per child constraints this way. For example:
componentA.putClientProperty("to the left of", componentB);
If value is null this method will remove the property.
Changes to client properties are reported with
PropertyChange events.
The name of the property (for the sake of PropertyChange
events) is key.toString().
The clientProperty dictionary is not intended to
support large
scale extensions to JComponent nor should be it considered an
alternative to subclassing when designing a new component.
getActionMap() and getInputMap() for
similiar behavior.getActionMap() and getInputMap() for
similiar behavior. For example, to bind the KeyStroke
aKeyStroke to the Action anAction
now use:
component.getInputMap().put(aKeyStroke, aCommand); component.getActionMap().put(aCommmand, anAction);The above assumes you want the binding to be applicable for
WHEN_FOCUSED. To register bindings for other focus
states use the getInputMap method that takes an integer.
Register a new keyboard action.
anAction will be invoked if a key event matching
aKeyStroke occurs and aCondition is verified.
The KeyStroke object defines a
particular combination of a keyboard key and one or more modifiers
(alt, shift, ctrl, meta).
The aCommand will be set in the delivered event if
specified.
The aCondition can be one of:
- WHEN_FOCUSED
- The action will be invoked only when the keystroke occurs while the component has the focus.
- WHEN_IN_FOCUSED_WINDOW
- The action will be invoked when the keystroke occurs while the component has the focus or if the component is in the window that has the focus. Note that the component need not be an immediate descendent of the window -- it can be anywhere in the window's containment hierarchy. In other words, whenever any component in the window has the focus, the action registered with this component is invoked.
- WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
- The action will be invoked when the keystroke occurs while the component has the focus or if the component is an ancestor of the component that has the focus.
The combination of keystrokes and conditions lets you define high level (semantic) action events for a specified keystroke+modifier combination (using the KeyStroke class) and direct to a parent or child of a component that has the focus, or to the component itself. In other words, in any hierarchical structure of components, an arbitrary key-combination can be immediately directed to the appropriate component in the hierarchy, and cause a specific method to be invoked (usually by way of adapter objects).
If an action has already been registered for the receiving
container, with the same charCode and the same modifiers,
anAction will replace the action.
removeLayoutComponent method.index,
from this container.
This method also notifies the layout manager to remove the
component from this container's layout via the
removeLayoutComponent method.removeLayoutComponent method.listener so that it will no longer receive
AncestorEvents.aColumn from this JTable's
array of columns. Note: this method does not remove the column
of data from the model; it just removes the TableColumn
that was responsible for displaying it.index0 to index1, inclusive.l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.l is null,
no exception is thrown and no action is performed.unconfigureEnclosingScrollPane method.If listener is null, no exception is thrown and no action is performed.
PropertyChangeListener from the listener
list for a specific property. This method should be used to remove
PropertyChangeListeners
that were registered for a specific bound property.
If propertyName or listener is null,
no exception is thrown and no action is taken.
index0 to index1, inclusive.VetoableChangeListener from the listener list.
This removes a VetoableChangeListener that was registered
for all properties.
If this component is a lightweight component, this method
causes a call to this component's paint
method as soon as possible. Otherwise, this method causes
a call to this component's update method as soon
as possible.
Note: For more information on the paint mechanisms utilitized by AWT and Swing, including information on how to write the most efficient painting code, see Painting in AWT and Swing.
If this component is a lightweight component, this method
causes a call to this component's paint method
as soon as possible. Otherwise, this method causes a call to
this component's update method as soon as possible.
Note: For more information on the paint mechanisms utilitized by AWT and Swing, including information on how to write the most efficient painting code, see Painting in AWT and Swing.
paint
within tm milliseconds.
Note: For more information on the paint mechanisms utilitized by AWT and Swing, including information on how to write the most efficient painting code, see Painting in AWT and Swing.
Requests focus on this JComponent's
FocusTraversalPolicy's default Component.
If this JComponent is a focus cycle root, then its
FocusTraversalPolicy is used. Otherwise, the
FocusTraversalPolicy of this JComponent's
focus-cycle-root ancestor is used.
Component gets the input focus.
Refer to Component.requestFocus()
for a complete description of
this method.
Note that the use of this method is discouraged because its behavior is platform dependent. Instead we recommend the use of requestFocusInWindow() . If you would like more information on focus, see
Component gets the input focus.
Refer to Component.requestFocus(boolean)
for a complete description of
this method.
Note that the use of this method is discouraged because its behavior is platform dependent. Instead we recommend the use of requestFocusInWindow(boolean) . If you would like more information on focus, see How to Use the Focus Subsystem, a section in The Java Tutorial.
Component gets the input focus.
Refer to Component.requestFocusInWindow()
for a complete description of
this method.
If you would like more information on focus, see How to Use the Focus Subsystem, a section in The Java Tutorial.
InputMaps
and ActionMap. This has the effect of removing any
local bindings, and allowing the bindings defined in parent
InputMap/ActionMaps
(the UI is usually defined in the second tier) to persist.
Calls invalidate and then adds this component's
validateRoot to a list of components that need to be
validated. Validation will occur after all currently pending
events have been dispatched. In other words after this method
is called, the first validateRoot (if any) found when walking
up the containment hierarchy of this component will be validated.
By default, JRootPane, JScrollPane,
and JTextField return true
from isValidateRoot.
This method will automatically be called on this component
when a property value changes such that size, location, or
internal layout of this component has been affected. This automatic
updating differs from the AWT because programs generally no
longer need to invoke validate to get the contents of the
GUI to update.
point lies in,
or -1 if the result is not in the range
[0, getRowCount()-1].scrollRectToVisible() message to the
JComponent's parent. Components that can service
the request, such as JViewport,
override this method and perform the scrolling.ActionMap to am. This does not set
the parent of the am to be the ActionMap
from the UI (if there was one), it is up to the caller to have done this.autoCreateColumnsFromModel flag.
This method calls createDefaultColumnsFromModel if
autoCreateColumnsFromModel changes from false to true.autoscrolls property.
If true mouse dragged events will be
synthetically generated when the mouse is dragged
outside of the component's bounds and mouse motion
has paused (while the button continues to be held
down). The synthetic events make it appear that the
drag gesture has resumed in the direction established when
the component's boundary was crossed. Components that
support autoscrolling must handle mouseDragged
events by calling scrollRectToVisible with a
rectangle that contains the mouse event's location. All of
the Swing components that support item selection and are
typically displayed in a JScrollPane
(JTable, JList, JTree,
JTextArea, and JEditorPane)
already handle mouse dragged events in this way. To enable
autoscrolling in any other component, add a mouse motion
listener that calls scrollRectToVisible.
For example, given a JPanel, myPanel:
MouseMotionListener doScrollRectToVisible = new MouseMotionAdapter() {
public void mouseDragged(MouseEvent e) {
Rectangle r = new Rectangle(e.getX(), e.getY(), 1, 1);
((JPanel)e.getSource()).scrollRectToVisible(r);
}
};
myPanel.addMouseMotionListener(doScrollRectToVisible);
The default value of the autoScrolls
property is false.Border object is
responsible for defining the insets for the component
(overriding any insets set directly on the component) and
for optionally rendering any border decorations within the
bounds of those insets. Borders should be used (rather
than insets) for creating both decorative and non-decorative
(such as margins and padding) regions for a swing component.
Compound borders can be used to nest multiple borders within a
single component.
Although technically you can set the border on any object
that inherits from
This is a bound property.JComponent, the look and
feel implementation of many standard Swing components
doesn't work well with user-set borders. In general,
when you want to set a border on a standard Swing
component other than JPanel or JLabel,
we recommend that you put the component in a JPanel
and set the border on the JPanel.
x and y, and the
new size is specified by width and height.r. This component's new
position is specified by r.x and r.y,
and its new size is specified by r.width and
r.heightcellEditor variable.isCellSelected to
change this default behavior. This method is equivalent to setting
both the rowSelectionAllowed property and
columnSelectionAllowed property of the
columnModel to the supplied value.newModel and registers
for listener notifications from the new column model. Also sets
the column model of the JTableHeader to columnModel.index0 to index1,
inclusive.LayoutManager and Component
subclasses will use this property to
determine how to lay out and draw components.
At construction time, a component's orientation is set to
ComponentOrientation.UNKNOWN,
indicating that it has not been specified
explicitly. The UNKNOWN orientation behaves the same as
ComponentOrientation.LEFT_TO_RIGHT.
To set the orientation of a single component, use this method. To set the orientation of an entire component hierarchy, use applyComponentOrientation .
JPopupMenu for this JComponent.
The UI is responsible for registering bindings and adding the necessary
listeners such that the JPopupMenu will be shown at
the appropriate time. When the JPopupMenu is shown
depends upon the look and feel: some may show it on a mouse event,
some may enable a key binding.
If popup is null, and getInheritsPopupMenu
returns true, then getComponentPopupMenu will be delegated
to the parent. This provides for a way to make all child components
inherit the popupmenu of the parent.
This is a bound property.
If the component is a child of some other container, it is
removed from that container before being added to this container.
The important difference between this method and
java.awt.Container.add(Component, int) is that this method
doesn't call removeNotify on the component while
removing it from its previous container unless necessary and when
allowed by the underlying native windowing system. This way, if the
component has the keyboard focus, it maintains the focus when
moved to the new position.
This property is guaranteed to apply only to lightweight
non-Container components.
Note: Not all platforms support changing the z-order of
heavyweight components from one container into another without
the call to removeNotify. There is no way to detect
whether a platform supports this, so developers shouldn't make
any assumptions.
contains method for
this component returns true for the current cursor location, and
this Component is visible, displayable, and enabled. Setting the
cursor of a Container causes that cursor to be displayed
within all of the container's subcomponents, except for those
that have a non-null cursor.TableColumn. If no editing is required in a table, or a
particular column in a table, uses the isCellEditable
method in the TableModel interface to ensure that this
JTable will not start an editor in these columns.
If editor is null, removes the default editor for this
column class.TableColumn. If renderer is null,
removes the default renderer for this column class.Component is buffered and one of its ancestor
is also buffered, the ancestor buffer will be used.dragEnabled property,
which must be true to enable
automatic drag handling (the first part of drag and drop)
on this component.
The transferHandler property needs to be set
to a non-null value for the drag to do
anything. The default value of the dragEnabledfalse.
When automatic drag handling is enabled,
most look and feels begin a drag-and-drop operation
whenever the user presses the mouse button over a selection
and then moves the mouse a few pixels.
Setting this property to true
can therefore have a subtle effect on
how selections behave.
Some look and feels might not support automatic drag and drop;
they will ignore this property. You can work around such
look and feels by modifying the component
to directly call the exportAsDrag method of a
TransferHandler.
DropTarget with this component.
The Component will receive drops only if it
is enabled.editingColumn variable.editingRow variable.Note: Disabling a component does not disable it's children.
Note: Disabling a lightweight component does not prevent it from receiving MouseEvents.
The alternative way to specify the traversal order of this Container's children is to make this Container a focus traversal policy provider.
If this Container is not a focus cycle root, the policy will be remembered, but will not be used or inherited by this or any other Containers until this Container is made a focus cycle root.
true will be used to acquire focus traversal policy
instead of closest focus cycle root ancestor.gridColor and redisplays.
The default color is look and feel dependent.This is useful, for example, if running under full-screen mode and better performance is desired, or if page-flipping is used as the buffer strategy.
getComponentPopupMenu should delegate
to the parent if this component does not have a JPopupMenu
assigned to it.
The default value for this is false, but some JComponent
subclasses that are implemented as a number of JComponents
may set this to true.
This is a bound property.
InputMap to use under the condition
condition to
map. A null value implies you
do not want any bindings to be used, even from the UI. This will
not reinstall the UI InputMap (if there was one).
condition has one of the following values:
WHEN_IN_FOCUSED_WINDOW
WHEN_FOCUSED
WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
condition is WHEN_IN_FOCUSED_WINDOW
and map is not a ComponentInputMap, an
IllegalArgumentException will be thrown.
Similarly, if condition is not one of the values
listed, an IllegalArgumentException will be thrown.rowMargin and the columnMargin --
the height and width of the space between cells -- to
intercellSpacing.x and y
parameters in the coordinate space of this component's parent.p. Point
p is given in the parent's coordinate space.getMaximumSize will always
return this value; the component's UI will not be asked
to compute it. Setting the maximum size to null
restores the default behavior.getMinimumSize will always
return this value; the component's UI will not be asked
to compute it. Setting the minimum size to null
restores the default behavior.newModel and registers
with it for listener notifications from the new data model.
Overrides the default FocusTraversalPolicy for this
JComponent's focus traversal cycle by unconditionally
setting the specified Component as the next
Component in the cycle, and this JComponent
as the specified Component's previous
Component in the cycle.
The default value of this property is false for JComponent.
However, the default value for this property on most standard
JComponent subclasses (such as JButton and
JTree) is look-and-feel dependent.
preferredSize is null, the UI will
be asked for the preferred size.JComponent
should get focus. This is only a hint, and it is up to consumers that
are requesting focus to honor this property. This is typically honored
for mouse operations, but not keyboard operations. For example, look
and feels could verify this property is true before requesting focus
during a mouse operation. This would often times be used if you did
not want a mouse press on a JComponent to steal focus,
but did want the JComponent to be traversable via the
keyboard. If you do not want this JComponent focusable at
all, use the setFocusable method instead.
Please see How to Use the Focus Subsystem, a section in The Java Tutorial, for more information.
rowHeight,
revalidates, and repaints.
The height of the cells will be equal to the row height minus
the row margin.row to rowHeight,
revalidates, and repaints. The height of the cells in this row
will be equal to the row height minus the row margin.index0 to index1,
inclusive.The default value of this property is defined by the look and feel implementation.
This is a JavaBeans bound property.
The default value of this property is defined by the look and feel implementation.
This is a JavaBeans bound property.
JTable provides all the methods for handling
column and row selection. When setting states,
such as setSelectionMode, it not only
updates the mode for the row selection model but also sets similar
values in the selection model of the columnModel.
If you want to have the row and column selection models operating
in different modes, set them both directly.
Both the row and column selection models for JTable
default to using a DefaultListSelectionModel
so that JTable works the same way as the
JList. See the setSelectionMode method
in JList for details about the modes.
newModel
and registers for listener notifications from the new selection model.showGrid is true it does; if it is false it doesn't.
There is no getShowGrid method as this state is held
in two variables -- showHorizontalLines and showVerticalLines --
each of which can be queried independently.showHorizontalLines is true it does; if it is false it doesn't.showVerticalLines is true it does; if it is false it doesn't.d.width
and height d.height.width
and height height.tableHeader working with this JTable to newHeader.
It is legal to have a null tableHeader.See How to Use Tool Tips in The Java Tutorial for further documentation.
transferHandler property,
which is null if the component does
not support data transfer operations.
If newHandler is not null,
and the system property
suppressSwingDropSupport is not true, this will
install a DropTarget on the JComponent.
The default for the system property is false, so that a
DropTarget will be added.
Please see How to Use Drag and Drop and Data Transfer, a section in The Java Tutorial, for more information.
row
and column.
Note: The column is specified in the table view's display
order, and not in the TableModel's column
order. This is an important distinction because as the
user rearranges the columns in the table,
the column at a given index in the view will change.
Meanwhile the user's actions never affect the model's
column ordering.
aValue is the new value.
Component.setVisible.doLayout() method instead.ActionMap/InputMap, or place a dummy binding the
InputMap. Removing the binding from the
InputMap allows bindings in parent InputMaps
to be active, whereas putting a dummy binding in the
InputMap effectively disables
the binding from ever happening.
Unregisters a keyboard action.
This will remove the binding from the ActionMap
(if it exists) as well as the InputMaps.
paint. Doesn't clear the background but see
ComponentUI.update, which is called by
paintComponent.UIManager that the L&F has changed.
Replaces the current UI object with the latest version from the
UIManager.
The validate method is used to cause a container
to lay out its subcomponents again. It should be invoked when
this container's subcomponents are modified (added to or
removed from the container, or layout-related information
changed) after the container has been displayed.
The current thread must own this object's monitor. The thread
releases ownership of this monitor and waits until another thread
notifies threads waiting on this object's monitor to wake up
either through a call to the notify method or the
notifyAll method. The thread then waits until it can
re-obtain ownership of the monitor and resumes execution.
As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:
synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
}
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.The current thread must own this object's monitor.
This method causes the current thread (call it T) to place itself in the wait set for this object and then to relinquish any and all synchronization claims on this object. Thread T becomes disabled for thread scheduling purposes and lies dormant until one of four things happens:
A thread can also wake up without being notified, interrupted, or timing out, a so-called spurious wakeup. While this will rarely occur in practice, applications must guard against it by testing for the condition that should have caused the thread to be awakened, and continuing to wait if the condition is not satisfied. In other words, waits should always occur in loops, like this one:
synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout);
... // Perform action appropriate to condition
}
(For more information on this topic, see Section 3.2.3 in Doug Lea's
"Concurrent Programming in Java (Second Edition)" (Addison-Wesley,
2000), or Item 50 in Joshua Bloch's "Effective Java Programming
Language Guide" (Addison-Wesley, 2001).
If the current thread is interrupted by another thread while it is waiting, then an InterruptedException is thrown. This exception is not thrown until the lock status of this object has been restored as described above.
Note that the wait method, as it places the current thread into the wait set for this object, unlocks only this object; any other objects on which the current thread may be synchronized remain locked while the thread waits.
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.
This method is similar to the wait method of one
argument, but it allows finer control over the amount of time to
wait for a notification before giving up. The amount of real time,
measured in nanoseconds, is given by:
1000000*timeout+nanos
In all other respects, this method does the same thing as the method of one argument. In particular, wait(0, 0) means the same thing as wait(0).
The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until either of the following two conditions has occurred:
notify method
or the notifyAll method.
timeout
milliseconds plus nanos nanoseconds arguments, has
elapsed.
The thread then waits until it can re-obtain ownership of the monitor and resumes execution.
As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:
synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout, nanos);
... // Perform action appropriate to condition
}
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.