S - The type of the objects contained within the TableView items list.public class TableView<S> extends Control
ListView control, with the addition of support for columns. For an
example on how to create a TableView, refer to the 'Creating a TableView'
control section below.
The TableView control has a number of features, including:
TableColumn API:
cell factories to
easily customize cell contents in both rendering and editing
states.
minWidth/
prefWidth/
maxWidth,
and also fixed width columns.
column nesting
resizing policies to
dictate what happens when the user resizes columns.
multiple column sorting by clicking
the column header (hold down Shift keyboard key whilst clicking on a
header to sort by multiple columns).
Note that TableView is intended to be used to visualize data - it is not
intended to be used for laying out your user interface. If you want to lay
your user interface out in a grid-like fashion, consider the
javafx.scene.layout.GridPane layout instead.
Creating a TableView is a multi-step process, and also depends on the
underlying data model needing to be represented. For this example we'll use
an ObservableList<Person>, as it is the simplest way of showing data in a
TableView. The Person class will consist of a first
name and last name properties. That is:
public class Person {
private StringProperty firstName;
public void setFirstName(String value) { firstNameProperty().set(value); }
public String getFirstName() { return firstNameProperty().get(); }
public StringProperty firstNameProperty() {
if (firstName == null) firstName = new SimpleStringProperty(this, "firstName");
return firstName;
}
private StringProperty lastName;
public void setLastName(String value) { lastNameProperty().set(value); }
public String getLastName() { return lastNameProperty().get(); }
public StringProperty lastNameProperty() {
if (lastName == null) lastName = new SimpleStringProperty(this, "lastName");
return lastName;
}
}
Firstly, a TableView instance needs to be defined, as such:
TableView<Person> table = new TableView<>();
With the basic table defined, we next focus on the data model. As mentioned, for this example, we'll be using an ObservableList<Person>. We can immediately set such a list directly in to the TableView, as such:
ObservableList<Person> teamMembers = getTeamMembers();
table.setItems(teamMembers);
With the items set as such, TableView will automatically update whenever
the teamMembers list changes. If the items list is available
before the TableView is instantiated, it is possible to pass it directly into
the constructor.
At this point we now have a TableView hooked up to observe the
teamMembers observableList. The missing ingredient
now is the means of splitting out the data contained within the model and
representing it in one or more TableColumn instances. To
create a two-column TableView to show the firstName and lastName properties,
we extend the last code sample as follows:
ObservableList<Person> teamMembers = ...;
table.setItems(teamMembers);
TableColumn<Person,String> firstNameCol = new TableColumn<>("First Name");
firstNameCol.setCellValueFactory(new PropertyValueFactory<>("firstName"));
TableColumn<Person,String> lastNameCol = new TableColumn<>("Last Name");
lastNameCol.setCellValueFactory(new PropertyValueFactory<>("lastName"));
table.getColumns().setAll(firstNameCol, lastNameCol);
With the code shown above we have fully defined the minimum properties required to create a TableView instance. Running this code (assuming the people ObservableList is appropriately created) will result in a TableView being shown with two columns for firstName and lastName. Any other properties of the Person class will not be shown, as no TableColumns are defined.
The code shown above is the shortest possible code for creating a TableView
when the domain objects are designed with JavaFX properties in mind
(additionally, javafx.scene.control.cell.PropertyValueFactory supports
normal JavaBean properties too, although there is a caveat to this, so refer
to the class documentation for more information). When this is not the case,
it is necessary to provide a custom cell value factory. More information
about cell value factories can be found in the TableColumn API
documentation, but briefly, here is how a TableColumn could be specified:
firstNameCol.setCellValueFactory(new Callback<CellDataFeatures<Person, String>, ObservableValue<String>>() {
public ObservableValue<String> call(CellDataFeatures<Person, String> p) {
// p.getValue() returns the Person instance for a particular TableView row
return p.getValue().firstNameProperty();
}
});
// or with a lambda expression:
firstNameCol.setCellValueFactory(p -> p.getValue().firstNameProperty());
To track selection and focus, it is necessary to become familiar with the
SelectionModel and FocusModel classes. A TableView has at most
one instance of each of these classes, available from
selectionModel and
focusModel properties respectively.
Whilst it is possible to use this API to set a new selection model, in
most circumstances this is not necessary - the default selection and focus
models should work in most circumstances.
The default SelectionModel used when instantiating a TableView is
an implementation of the MultipleSelectionModel abstract class.
However, as noted in the API documentation for
the selectionMode
property, the default value is SelectionMode.SINGLE. To enable
multiple selection in a default TableView instance, it is therefore necessary
to do the following:
tableView.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
The visuals of the TableView can be entirely customized by replacing the
default row factory. A row factory is used to
generate TableRow instances, which are used to represent an entire
row in the TableView.
In many cases, this is not what is desired however, as it is more commonly
the case that cells be customized on a per-column basis, not a per-row basis.
It is therefore important to note that a TableRow is not a
TableCell. A TableRow is simply a container for zero or more
TableCell, and in most circumstances it is more likely that you'll
want to create custom TableCells, rather than TableRows. The primary use case
for creating custom TableRow instances would most probably be to introduce
some form of column spanning support.
You can create custom TableCell instances per column by assigning
the appropriate function to the TableColumn
cell factory property.
See the Cell class documentation for a more complete
description of how to write custom Cells.
Prior to JavaFX 8.0, the TableView control would treat the
items list as the view model, meaning that any changes to
the list would be immediately reflected visually. TableView would also modify
the order of this list directly when a user initiated a sort. This meant that
(again, prior to JavaFX 8.0) it was not possible to have the TableView return
to an unsorted state (after iterating through ascending and descending
orders).
Starting with JavaFX 8.0 (and the introduction of SortedList), it
is now possible to have the collection return to the unsorted state when
there are no columns as part of the TableView
sort order. To do this, you must create a SortedList
instance, and bind its
comparator
property to the TableView comparator property,
list so:
// create a SortedList based on the provided ObservableList
SortedList sortedList = new SortedList(FXCollections.observableArrayList(2, 1, 3));
// create a TableView with the sorted list set as the items it will show
final TableView<Integer> tableView = new TableView<>(sortedList);
// bind the sortedList comparator to the TableView comparator
sortedList.comparatorProperty().bind(tableView.comparatorProperty());
// Don't forget to define columns!
This control supports inline editing of values, and this section attempts to give an overview of the available APIs and how you should use them.
Firstly, cell editing most commonly requires a different user interface
than when a cell is not being edited. This is the responsibility of the
Cell implementation being used. For TableView, it is highly
recommended that editing be
per-TableColumn,
rather than per row, as more often than not
you want users to edit each column value differently, and this approach allows
for editors specific to each column. It is your choice whether the cell is
permanently in an editing state (e.g. this is common for CheckBox cells),
or to switch to a different UI when editing begins (e.g. when a double-click
is received on a cell).
To know when editing has been requested on a cell,
simply override the Cell.startEdit() method, and
update the cell text and
graphic properties as
appropriate (e.g. set the text to null and set the graphic to be a
TextField). Additionally, you should also override
Cell.cancelEdit() to reset the UI back to its original visual state
when the editing concludes. In both cases it is important that you also
ensure that you call the super method to have the cell perform all duties it
must do to enter or exit its editing mode.
Once your cell is in an editing state, the next thing you are most probably
interested in is how to commit or cancel the editing that is taking place. This is your
responsibility as the cell factory provider. Your cell implementation will know
when the editing is over, based on the user input (e.g. when the user presses
the Enter or ESC keys on their keyboard). When this happens, it is your
responsibility to call Cell.commitEdit(Object) or
Cell.cancelEdit(), as appropriate.
When you call Cell.commitEdit(Object) an event is fired to the
TableView, which you can observe by adding an EventHandler via
TableColumn#setOnEditCommit(javafx.event.EventHandler). Similarly,
you can also observe edit events for
edit start
and edit cancel.
By default the TableColumn edit commit handler is non-null, with a default
handler that attempts to overwrite the property value for the
item in the currently-being-edited row. It is able to do this as the
Cell.commitEdit(Object) method is passed in the new value, and this
is passed along to the edit commit handler via the
CellEditEvent that is
fired. It is simply a matter of calling
TableColumn.CellEditEvent.getNewValue() to
retrieve this value.
It is very important to note that if you call
TableColumn#setOnEditCommit(javafx.event.EventHandler) with your own
EventHandler, then you will be removing the default handler. Unless
you then handle the writeback to the property (or the relevant data source),
nothing will happen. You can work around this by using the
TableColumn#addEventHandler(javafx.event.EventType, javafx.event.EventHandler)
method to add a TableColumn.editCommitEvent() EventType with
your desired EventHandler as the second argument. Using this method,
you will not replace the default implementation, but you will be notified when
an edit commit has occurred.
Hopefully this summary answers some of the commonly asked questions. Fortunately, JavaFX ships with a number of pre-built cell factories that handle all the editing requirements on your behalf. You can find these pre-built cell factories in the javafx.scene.control.cell package.
TableColumn,
TablePosition| Type | Property and Description |
|---|---|
<any> |
columnResizePolicy
This is the function called when the user completes a column-resize
operation.
|
<any> |
comparator
The comparator property is a read-only property that is representative of the
current state of the
sort order list. |
BooleanProperty |
editable
Specifies whether this TableView is editable - only if the TableView, the
TableColumn (if applicable) and the TableCells within it are both
editable will a TableCell be able to go into their editing state.
|
<any> |
editingCell
Represents the current cell being edited, or null if
there is no cell being edited.
|
DoubleProperty |
fixedCellSize
Specifies whether this control has cells that are a fixed height (of the
specified value).
|
<any> |
focusModel
Represents the currently-installed
TableView.TableViewFocusModel for this
TableView. |
<any> |
items
The underlying data model for the TableView.
|
<any> |
onScrollToColumn
Called when there's a request to scroll a column into view using
scrollToColumn(TableColumn)
or scrollToColumnIndex(int) |
<any> |
onScrollTo
Called when there's a request to scroll an index into view using
scrollTo(int)
or scrollTo(Object) |
<any> |
onSort
Called when there's a request to sort the control.
|
<any> |
placeholder
This Node is shown to the user when the table has no content to show.
|
<any> |
rowFactory
A function which produces a TableRow.
|
<any> |
selectionModel
The SelectionModel provides the API through which it is possible
to select single or multiple items within a TableView, as well as inspect
which items have been selected by the user.
|
<any> |
sortPolicy
The sort policy specifies how sorting in this TableView should be performed.
|
BooleanProperty |
tableMenuButtonVisible
This controls whether a menu button is available when the user clicks
in a designated space within the TableView, within which is a radio menu
item for each TableColumn in this table.
|
contextMenuProperty, skinClassNameProperty, skinProperty, tooltipProperty| Modifier and Type | Class and Description |
|---|---|
static class |
TableView.ResizeFeatures<S>
An immutable wrapper class for use in the TableView
column resize functionality. |
private static class |
TableView.StyleableProperties |
(package private) static class |
TableView.TableViewArrayListSelectionModel<S>
A primitive selection model implementation, using a List
|
static class |
TableView.TableViewFocusModel<S>
A
FocusModel with additional functionality to support the requirements
of a TableView control. |
static class |
TableView.TableViewSelectionModel<S>
A simple extension of the
SelectionModel abstract class to
allow for special support for TableView controls. |
| Modifier and Type | Field and Description |
|---|---|
private InvalidationListener |
cellSelectionModelInvalidationListener |
private InvalidationListener |
columnComparatorObserver |
private <any> |
columnResizePolicy |
private <any> |
columns
*
Instance Variables *
*
|
private <any> |
columnsObserver
*
Callbacks and Events *
*
|
private InvalidationListener |
columnSortableObserver |
private InvalidationListener |
columnSortTypeObserver |
private InvalidationListener |
columnVisibleObserver |
private <any> |
comparator
The comparator property is a read-only property that is representative of the
current state of the
sort order list. |
static <any> |
CONSTRAINED_RESIZE_POLICY
Simple policy that ensures the width of all visible leaf columns in
this table sum up to equal the width of the table itself.
|
private double |
contentWidth |
static <any> |
DEFAULT_SORT_POLICY
The default
sort policy that this TableView
will use if no other policy is specified. |
private static java.lang.String |
DEFAULT_STYLE_CLASS
*
Stylesheet Handling *
*
|
private BooleanProperty |
editable |
private <any> |
editingCell |
private DoubleProperty |
fixedCellSize |
private <any> |
focusModel |
private boolean |
isInited |
private <any> |
items |
private java.util.WeakHashMap<TableColumn<S,?>,java.lang.Integer> |
lastKnownColumnIndex |
private java.lang.Object[] |
lastSortEventSupportInfo |
private TableUtil.SortEventType |
lastSortEventType |
private <any> |
onScrollTo
Called when there's a request to scroll an index into view using
scrollTo(int)
or scrollTo(Object) |
private <any> |
onScrollToColumn
Called when there's a request to scroll a column into view using
scrollToColumn(TableColumn)
or scrollToColumnIndex(int) |
private <any> |
onSort
Called when there's a request to sort the control.
|
private <any> |
placeholder |
private static PseudoClass |
PSEUDO_CLASS_CELL_SELECTION |
private static PseudoClass |
PSEUDO_CLASS_ROW_SELECTION |
private <any> |
rowFactory |
private <any> |
selectionModel |
(package private) static java.lang.String |
SET_CONTENT_WIDTH
*
Static properties and methods *
*
|
private boolean |
sortLock
*
Private Implementation *
*
|
private <any> |
sortOrder |
private <any> |
sortPolicy
The sort policy specifies how sorting in this TableView should be performed.
|
private BooleanProperty |
tableMenuButtonVisible |
static <any> |
UNCONSTRAINED_RESIZE_POLICY
Very simple resize policy that just resizes the specified column by the
provided delta and shifts all other columns (to the right of the given column)
further to the right (when the delta is positive) or to the left (when the
delta is negative).
|
private <any> |
unmodifiableVisibleLeafColumns |
private <any> |
visibleLeafColumns |
private WeakInvalidationListener |
weakCellSelectionModelInvalidationListener |
private WeakInvalidationListener |
weakColumnComparatorObserver |
private <any> |
weakColumnsObserver |
private WeakInvalidationListener |
weakColumnSortableObserver |
private WeakInvalidationListener |
weakColumnSortTypeObserver |
private WeakInvalidationListener |
weakColumnVisibleObserver |
| Constructor and Description |
|---|
TableView()
Creates a default TableView control with no content.
|
TableView(<any> items)
Creates a TableView with the content provided in the items ObservableList.
|
| Modifier and Type | Method and Description |
|---|---|
private void |
buildVisibleLeafColumns(java.util.List<TableColumn<S,?>> cols,
java.util.List<TableColumn<S,?>> vlc) |
<any> |
columnResizePolicyProperty()
This is the function called when the user completes a column-resize
operation.
|
<any> |
comparatorProperty()
The comparator property is a read-only property that is representative of the
current state of the
sort order list. |
private <any> |
comparatorPropertyImpl() |
protected Skin<?> |
createDefaultSkin()
Create a new instance of the default skin for this control.
|
private void |
doSort(TableUtil.SortEventType sortEventType,
java.lang.Object... supportInfo) |
void |
edit(int row,
TableColumn<S,?> column)
Causes the cell at the given row/column view indexes to switch into
its editing state, if it is not already in it, and assuming that the
TableView and column are also editable.
|
BooleanProperty |
editableProperty()
Specifies whether this TableView is editable - only if the TableView, the
TableColumn (if applicable) and the TableCells within it are both
editable will a TableCell be able to go into their editing state.
|
<any> |
editingCellProperty()
Represents the current cell being edited, or null if
there is no cell being edited.
|
private <any> |
editingCellPropertyImpl() |
DoubleProperty |
fixedCellSizeProperty()
Specifies whether this control has cells that are a fixed height (of the
specified value).
|
<any> |
focusModelProperty()
Represents the currently-installed
TableView.TableViewFocusModel for this
TableView. |
static java.util.List<<any>> |
getClassCssMetaData() |
<any> |
getColumnResizePolicy()
Gets the value of the property columnResizePolicy.
|
<any> |
getColumns()
The TableColumns that are part of this TableView.
|
java.util.Comparator<S> |
getComparator()
Gets the value of the property comparator.
|
java.util.List<<any>> |
getControlCssMetaData() |
TablePosition<S,?> |
getEditingCell()
Gets the value of the property editingCell.
|
double |
getFixedCellSize()
Returns the fixed cell size value.
|
TableView.TableViewFocusModel<S> |
getFocusModel()
Gets the value of the property focusModel.
|
<any> |
getItems()
Gets the value of the property items.
|
<any> |
getOnScrollTo()
Gets the value of the property onScrollTo.
|
<any> |
getOnScrollToColumn()
Gets the value of the property onScrollToColumn.
|
<any> |
getOnSort()
Gets the value of the property onSort.
|
Node |
getPlaceholder()
Gets the value of the property placeholder.
|
<any> |
getRowFactory()
Gets the value of the property rowFactory.
|
TableView.TableViewSelectionModel<S> |
getSelectionModel()
Gets the value of the property selectionModel.
|
<any> |
getSortOrder()
The sortOrder list defines the order in which
TableColumn instances
are sorted. |
<any> |
getSortPolicy()
Gets the value of the property sortPolicy.
|
TableColumn<S,?> |
getVisibleLeafColumn(int column)
Returns the TableColumn in the given column index, relative to all other
visible leaf columns.
|
<any> |
getVisibleLeafColumns()
Returns an unmodifiable list containing the currently visible leaf columns.
|
int |
getVisibleLeafIndex(TableColumn<S,?> column)
Returns the position of the given column, relative to all other
visible leaf columns.
|
boolean |
isEditable()
Gets the value of the property editable.
|
boolean |
isTableMenuButtonVisible()
Gets the value of the property tableMenuButtonVisible.
|
<any> |
itemsProperty()
The underlying data model for the TableView.
|
<any> |
onScrollToColumnProperty()
Called when there's a request to scroll a column into view using
scrollToColumn(TableColumn)
or scrollToColumnIndex(int) |
<any> |
onScrollToProperty()
Called when there's a request to scroll an index into view using
scrollTo(int)
or scrollTo(Object) |
<any> |
onSortProperty()
Called when there's a request to sort the control.
|
<any> |
placeholderProperty()
This Node is shown to the user when the table has no content to show.
|
java.lang.Object |
queryAccessibleAttribute(AccessibleAttribute attribute,
java.lang.Object... parameters) |
void |
refresh()
Calling
refresh() forces the TableView control to recreate and
repopulate the cells necessary to populate the visual bounds of the control. |
boolean |
resizeColumn(TableColumn<S,?> column,
double delta)
Applies the currently installed resize policy against the given column,
resizing it based on the delta value provided.
|
<any> |
rowFactoryProperty()
A function which produces a TableRow.
|
void |
scrollTo(int index)
Scrolls the TableView so that the given index is visible within the viewport.
|
void |
scrollTo(S object)
Scrolls the TableView so that the given object is visible within the viewport.
|
void |
scrollToColumn(TableColumn<S,?> column)
Scrolls the TableView so that the given column is visible within the viewport.
|
void |
scrollToColumnIndex(int columnIndex)
Scrolls the TableView so that the given index is visible within the viewport.
|
<any> |
selectionModelProperty()
The SelectionModel provides the API through which it is possible
to select single or multiple items within a TableView, as well as inspect
which items have been selected by the user.
|
void |
setColumnResizePolicy(<any> callback)
Sets the value of the property columnResizePolicy.
|
private void |
setComparator(java.util.Comparator<S> value) |
private void |
setContentWidth(double contentWidth) |
void |
setEditable(boolean value)
Sets the value of the property editable.
|
private void |
setEditingCell(TablePosition<S,?> value) |
void |
setFixedCellSize(double value)
Sets the new fixed cell size for this control.
|
void |
setFocusModel(TableView.TableViewFocusModel<S> value)
Sets the value of the property focusModel.
|
void |
setItems(<any> value)
Sets the value of the property items.
|
void |
setOnScrollTo(<any> value)
Sets the value of the property onScrollTo.
|
void |
setOnScrollToColumn(<any> value)
Sets the value of the property onScrollToColumn.
|
void |
setOnSort(<any> value)
Sets the value of the property onSort.
|
void |
setPlaceholder(Node value)
Sets the value of the property placeholder.
|
void |
setRowFactory(<any> value)
Sets the value of the property rowFactory.
|
void |
setSelectionModel(TableView.TableViewSelectionModel<S> value)
Sets the value of the property selectionModel.
|
void |
setSortPolicy(<any> callback)
Sets the value of the property sortPolicy.
|
void |
setTableMenuButtonVisible(boolean value)
Sets the value of the property tableMenuButtonVisible.
|
void |
sort()
The sort method forces the TableView to re-run its sorting algorithm.
|
<any> |
sortPolicyProperty()
The sort policy specifies how sorting in this TableView should be performed.
|
BooleanProperty |
tableMenuButtonVisibleProperty()
This controls whether a menu button is available when the user clicks
in a designated space within the TableView, within which is a radio menu
item for each TableColumn in this table.
|
private void |
updateVisibleLeafColumns()
Recomputes the currently visible leaf columns in this TableView.
|
computeMaxHeight, computeMaxWidth, computeMinHeight, computeMinWidth, computePrefHeight, computePrefWidth, contextMenuProperty, executeAccessibleAction, getBaselineOffset, getContextMenu, getControlChildren, getCssMetaData, getInitialFocusTraversable, getSkin, getTooltip, isResizable, layoutChildren, loadSkinClass, setContextMenu, setSkin, setTooltip, skinClassNameProperty, skinProperty, tooltipPropertypublic final <any> itemsProperty
getItems(),
#setItems()public final BooleanProperty tableMenuButtonVisibleProperty
public final <any> columnResizePolicyProperty
UNCONSTRAINED_RESIZE_POLICY and
CONSTRAINED_RESIZE_POLICY.getColumnResizePolicy(),
#setColumnResizePolicy()public final <any> rowFactoryProperty
Note that a TableRow is not a TableCell. A TableRow is simply a container for a TableCell, and in most circumstances it is more likely that you'll want to create custom TableCells, rather than TableRows. The primary use case for creating custom TableRow instances would most probably be to introduce some form of column spanning support.
You can create custom TableCell instances per column by assigning the appropriate function to the cellFactory property in the TableColumn class.
getRowFactory(),
#setRowFactory()public final <any> placeholderProperty
getPlaceholder(),
setPlaceholder(Node)public final <any> selectionModelProperty
public final <any> focusModelProperty
TableView.TableViewFocusModel for this
TableView. Under almost all circumstances leaving this as the default
focus model will suffice.public final BooleanProperty editableProperty
isEditable(),
setEditable(boolean)public final DoubleProperty fixedCellSizeProperty
To set this property via CSS, use the -fx-fixed-cell-size property. This should not be confused with the -fx-cell-size property. The difference between these two CSS properties is that -fx-cell-size will size all cells to the specified size, but it will not enforce that this is the only size (thus allowing for variable cell sizes, and preventing the performance gains from being possible). Therefore, when performance matters use -fx-fixed-cell-size, instead of -fx-cell-size. If both properties are specified in CSS, -fx-fixed-cell-size takes precedence.
getFixedCellSize(),
setFixedCellSize(double)public final <any> editingCellProperty
getEditingCell()public final <any> comparatorProperty
sort order list. The sort
order list contains the columns that have been added to it either programmatically
or via a user clicking on the headers themselves.getComparator()public final <any> sortPolicyProperty
FXCollections.sort(tableView.getItems()), whereas a more advanced
sort policy may call to a database to perform the necessary sorting on the
server-side.
TableView ships with a default
sort policy that does precisely as mentioned above: it simply attempts
to sort the items list in-place.
It is recommended that rather than override the sort
method that a different sort policy be provided instead.
getSortPolicy(),
#setSortPolicy()public <any> onSortProperty
getOnSort(),
#setOnSort()public <any> onScrollToProperty
scrollTo(int)
or scrollTo(Object)getOnScrollTo(),
#setOnScrollTo()public <any> onScrollToColumnProperty
scrollToColumn(TableColumn)
or scrollToColumnIndex(int)getOnScrollToColumn(),
#setOnScrollToColumn()static final java.lang.String SET_CONTENT_WIDTH
public static final <any> UNCONSTRAINED_RESIZE_POLICY
Very simple resize policy that just resizes the specified column by the provided delta and shifts all other columns (to the right of the given column) further to the right (when the delta is positive) or to the left (when the delta is negative).
It also handles the case where we have nested columns by sharing the new space, or subtracting the removed space, evenly between all immediate children columns. Of course, the immediate children may themselves be nested, and they would then use this policy on their children.
public static final <any> CONSTRAINED_RESIZE_POLICY
Simple policy that ensures the width of all visible leaf columns in this table sum up to equal the width of the table itself.
When the user resizes a column width with this policy, the table automatically adjusts the width of the right hand side columns. When the user increases a column width, the table decreases the width of the rightmost column until it reaches its minimum width. Then it decreases the width of the second rightmost column until it reaches minimum width and so on. When all right hand side columns reach minimum size, the user cannot increase the size of resized column any more.
public static final <any> DEFAULT_SORT_POLICY
sort policy that this TableView
will use if no other policy is specified. The sort policy is a simple
Callback that accepts a TableView as the sole argument and expects
a Boolean response representing whether the sort succeeded or not. A Boolean
response of true represents success, and a response of false (or null) will
be considered to represent failure.private final <any> columns
private final <any> visibleLeafColumns
private final <any> unmodifiableVisibleLeafColumns
private <any> sortOrder
private double contentWidth
private boolean isInited
private final <any> columnsObserver
private final java.util.WeakHashMap<TableColumn<S,?>,java.lang.Integer> lastKnownColumnIndex
private final InvalidationListener columnVisibleObserver
private final InvalidationListener columnSortableObserver
private final InvalidationListener columnSortTypeObserver
private final InvalidationListener columnComparatorObserver
private final InvalidationListener cellSelectionModelInvalidationListener
private final WeakInvalidationListener weakColumnVisibleObserver
private final WeakInvalidationListener weakColumnSortableObserver
private final WeakInvalidationListener weakColumnSortTypeObserver
private final WeakInvalidationListener weakColumnComparatorObserver
private final <any> weakColumnsObserver
private final WeakInvalidationListener weakCellSelectionModelInvalidationListener
private <any> items
private BooleanProperty tableMenuButtonVisible
private <any> columnResizePolicy
private <any> rowFactory
private <any> placeholder
private <any> selectionModel
private <any> focusModel
private BooleanProperty editable
private DoubleProperty fixedCellSize
private <any> editingCell
private <any> comparator
sort order list. The sort
order list contains the columns that have been added to it either programmatically
or via a user clicking on the headers themselves.private <any> sortPolicy
FXCollections.sort(tableView.getItems()), whereas a more advanced
sort policy may call to a database to perform the necessary sorting on the
server-side.
TableView ships with a default
sort policy that does precisely as mentioned above: it simply attempts
to sort the items list in-place.
It is recommended that rather than override the sort
method that a different sort policy be provided instead.
private <any> onSort
private <any> onScrollTo
scrollTo(int)
or scrollTo(Object)private <any> onScrollToColumn
scrollToColumn(TableColumn)
or scrollToColumnIndex(int)private boolean sortLock
private TableUtil.SortEventType lastSortEventType
private java.lang.Object[] lastSortEventSupportInfo
private static final java.lang.String DEFAULT_STYLE_CLASS
private static final PseudoClass PSEUDO_CLASS_CELL_SELECTION
private static final PseudoClass PSEUDO_CLASS_ROW_SELECTION
public TableView()
Refer to the TableView class documentation for details on the
default state of other properties.
public TableView(<any> items)
Refer to the TableView class documentation for details on the
default state of other properties.
items - The items to insert into the TableView, and the list to watch
for changes (to automatically show in the TableView).public final <any> itemsProperty()
getItems(),
#setItems()public final void setItems(<any> value)
public final <any> getItems()
public final BooleanProperty tableMenuButtonVisibleProperty()
public final void setTableMenuButtonVisible(boolean value)
public final boolean isTableMenuButtonVisible()
public final void setColumnResizePolicy(<any> callback)
public final <any> getColumnResizePolicy()
public final <any> columnResizePolicyProperty()
UNCONSTRAINED_RESIZE_POLICY and
CONSTRAINED_RESIZE_POLICY.getColumnResizePolicy(),
#setColumnResizePolicy()public final <any> rowFactoryProperty()
Note that a TableRow is not a TableCell. A TableRow is simply a container for a TableCell, and in most circumstances it is more likely that you'll want to create custom TableCells, rather than TableRows. The primary use case for creating custom TableRow instances would most probably be to introduce some form of column spanning support.
You can create custom TableCell instances per column by assigning the appropriate function to the cellFactory property in the TableColumn class.
getRowFactory(),
#setRowFactory()public final void setRowFactory(<any> value)
public final <any> getRowFactory()
public final <any> placeholderProperty()
getPlaceholder(),
setPlaceholder(Node)public final void setPlaceholder(Node value)
public final Node getPlaceholder()
public final <any> selectionModelProperty()
public final void setSelectionModel(TableView.TableViewSelectionModel<S> value)
public final TableView.TableViewSelectionModel<S> getSelectionModel()
public final void setFocusModel(TableView.TableViewFocusModel<S> value)
public final TableView.TableViewFocusModel<S> getFocusModel()
public final <any> focusModelProperty()
TableView.TableViewFocusModel for this
TableView. Under almost all circumstances leaving this as the default
focus model will suffice.public final void setEditable(boolean value)
public final boolean isEditable()
public final BooleanProperty editableProperty()
isEditable(),
setEditable(boolean)public final void setFixedCellSize(double value)
value - The new fixed cell size value, or a value less than or equal
to zero (or Region.USE_COMPUTED_SIZE) to disable.public final double getFixedCellSize()
public final DoubleProperty fixedCellSizeProperty()
To set this property via CSS, use the -fx-fixed-cell-size property. This should not be confused with the -fx-cell-size property. The difference between these two CSS properties is that -fx-cell-size will size all cells to the specified size, but it will not enforce that this is the only size (thus allowing for variable cell sizes, and preventing the performance gains from being possible). Therefore, when performance matters use -fx-fixed-cell-size, instead of -fx-cell-size. If both properties are specified in CSS, -fx-fixed-cell-size takes precedence.
getFixedCellSize(),
setFixedCellSize(double)private void setEditingCell(TablePosition<S,?> value)
public final TablePosition<S,?> getEditingCell()
public final <any> editingCellProperty()
getEditingCell()private <any> editingCellPropertyImpl()
private void setComparator(java.util.Comparator<S> value)
public final java.util.Comparator<S> getComparator()
public final <any> comparatorProperty()
sort order list. The sort
order list contains the columns that have been added to it either programmatically
or via a user clicking on the headers themselves.getComparator()private <any> comparatorPropertyImpl()
public final void setSortPolicy(<any> callback)
public final <any> getSortPolicy()
public final <any> sortPolicyProperty()
FXCollections.sort(tableView.getItems()), whereas a more advanced
sort policy may call to a database to perform the necessary sorting on the
server-side.
TableView ships with a default
sort policy that does precisely as mentioned above: it simply attempts
to sort the items list in-place.
It is recommended that rather than override the sort
method that a different sort policy be provided instead.
getSortPolicy(),
#setSortPolicy()public void setOnSort(<any> value)
public <any> getOnSort()
public <any> onSortProperty()
getOnSort(),
#setOnSort()public final <any> getColumns()
Note: to display any data in a TableView, there must be at least one TableColumn in this ObservableList.
public final <any> getSortOrder()
TableColumn instances
are sorted. An empty sortOrder list means that no sorting is being applied
on the TableView. If the sortOrder list has one TableColumn within it,
the TableView will be sorted using the
sortType and
comparator properties of this
TableColumn (assuming
TableColumn.sortable is true).
If the sortOrder list contains multiple TableColumn instances, then
the TableView is firstly sorted based on the properties of the first
TableColumn. If two elements are considered equal, then the second
TableColumn in the list is used to determine ordering. This repeats until
the results from all TableColumn comparators are considered, if necessary.public void scrollTo(int index)
index - The index of an item that should be visible to the user.public void scrollTo(S object)
object - The object that should be visible to the user.public void setOnScrollTo(<any> value)
public <any> getOnScrollTo()
public <any> onScrollToProperty()
scrollTo(int)
or scrollTo(Object)getOnScrollTo(),
#setOnScrollTo()public void scrollToColumn(TableColumn<S,?> column)
column - The column that should be visible to the user.public void scrollToColumnIndex(int columnIndex)
columnIndex - The index of a column that should be visible to the user.public void setOnScrollToColumn(<any> value)
public <any> getOnScrollToColumn()
public <any> onScrollToColumnProperty()
scrollToColumn(TableColumn)
or scrollToColumnIndex(int)getOnScrollToColumn(),
#setOnScrollToColumn()public boolean resizeColumn(TableColumn<S,?> column, double delta)
column - the columndelta - the deltapublic void edit(int row,
TableColumn<S,?> column)
Note: This method will cancel editing if the given row value is less than zero and the given column is null.
row - the rowcolumn - the columnpublic <any> getVisibleLeafColumns()
public int getVisibleLeafIndex(TableColumn<S,?> column)
column - the columnpublic TableColumn<S,?> getVisibleLeafColumn(int column)
column - the columnprotected Skin<?> createDefaultSkin()
-fx-skin or set explicitly in a sub-class with setSkin(...).createDefaultSkin in class Controlpublic void sort()
sort order,
sort policy, or the state of the
TableColumn sort type properties
change. In other words, this method should only be called directly when
something external changes and a sort is required.public void refresh()
refresh() forces the TableView control to recreate and
repopulate the cells necessary to populate the visual bounds of the control.
In other words, this forces the TableView to update what it is showing to
the user. This is useful in cases where the underlying data source has
changed in a way that is not observed by the TableView itself.private void doSort(TableUtil.SortEventType sortEventType, java.lang.Object... supportInfo)
private void setContentWidth(double contentWidth)
private void updateVisibleLeafColumns()
private void buildVisibleLeafColumns(java.util.List<TableColumn<S,?>> cols, java.util.List<TableColumn<S,?>> vlc)
public static java.util.List<<any>> getClassCssMetaData()
public java.util.List<<any>> getControlCssMetaData()
getControlCssMetaData in class Controlpublic java.lang.Object queryAccessibleAttribute(AccessibleAttribute attribute,
java.lang.Object... parameters)
queryAccessibleAttribute in class Control