Cell (JavaFX 2.2)

java.lang.Object
- javafx.scene.Node
- - javafx.scene.Parent
  - - javafx.scene.control.Control
    - - javafx.scene.control.Labeled
      - javafx.scene.control.Cell<T>

Type Parameters:
T - The type of the item contained within the Cell.

All Implemented Interfaces:

EventTarget, Skinnable

Direct Known Subclasses:

IndexedCell
```
public class Cell<T>
extends Labeled
```
The Cell API is used for virtualized controls such as ListView, TreeView, and TableView. A Cell is a Labeled Control, and is used to render a single "row" inside a ListView, TreeView or TableView. Cells are also used for each individual 'cell' inside a TableView (i.e. each row/column intersection). See the JavaDoc for each control separately for more detail.
Every Cell is associated with a single data item (represented by the item property). The Cell is responsible for rendering that item and, where appropriate, for editing the item. An item within a Cell may be represented by text or some other control such as a CheckBox, ChoiceBox or any other Node such as a HBox, GridPane, or even a Rectangle.
Because TreeView, ListView, TableView and other such controls can potentially be used for displaying incredibly large amounts of data, it is not feasible to create an actual Cell for every single item in the control. We represent extremely large data sets using only very few Cells. Each Cell is "recycled", or reused. This is what we mean when we say that these controls are virtualized.
Since Cell is a Control, it is essentially a "model". Its Skin is responsible for defining the look and layout, while the Behavior is responsible for handling all input events and using that information to modify the Control state. Also, the Cell is styled from CSS just like any other Control. However, it is not necessary to implement a Skin for most uses of a Cell. This is because a cell factory can be set - this is detailed more shortly.
Because by far the most common use case for cells is to show text to a user, this use case is specially optimized for within Cell. This is done by Cell extending from Labeled. This means that subclasses of Cell need only set the text property, rather than create a separate Label and set that within the Cell. However, for situations where something more than just plain text is called for, it is possible to place any Node in the Cell graphic property. Despite the term, a graphic can be any Node, and will be fully interactive. For example, a ListCell might be configured with a Button as its graphic. The Button text could then be bound to the cells item property. In this way, whenever the item in the Cell changes, the Button text is automatically updated.
Cell sets focusTraversable to false.

Cell Factories
The default representation of the Cell item is up to the various virtualized container's skins to render. For example, the ListView by default will convert the item to a String and call Labeled.setText(java.lang.String) with this value. If you want to specialize the Cell used for the ListView (for example), then you must provide an implementation of the cellFactory callback function defined on the ListView. Similar API exists on most controls that use Cells (for example, TreeView, TableView, TableColumn and ListView.
The cell factory is called by the platform whenever it determines that a new cell needs to be created. For example, perhaps your ListView has 10 million items. Creating all 10 million cells would be prohibitively expensive. So instead the ListView skin implementation might only create just enough cells to fit the visual space. If the ListView is resized to be larger, the system will determine that it needs to create some additional cells. In this case it will call the cellFactory callback function (if one is provided) to create the Cell implementation that should be used. If no cell factory is provided, the built-in default implementation will be used.
The implementation of the cell factory is then responsible not just for creating a Cell instance, but also configuring that Cell such that it reacts to changes in its state. For example, if I were to create a custom Cell which formatted Numbers such that they would appear as currency types, I might do so like this:
```
 public class MoneyFormatCell extends ListCell<Number> {

     public MoneyFormatCell() {    }
       
     @Override protected void updateItem(Number item, boolean empty) {
         // calling super here is very important - don't skip this!
         super.updateItem(item, empty);
           
         // format the number as if it were a monetary value using the 
         // formatting relevant to the current locale. This would format
         // 43.68 as "$43.68", and -23.67 as "-$23.67"
         setText(item == null ? "" : NumberFormat.getCurrencyInstance().format(item));

         // change the text fill based on whether it is positive (green)
         // or negative (red). If the cell is selected, the text will 
         // always be white (so that it can be read against the blue 
         // background), and if the value is zero, we'll make it black.
         if (item != null) {
             double value = item.doubleValue();
             setTextFill(isSelected() ? Color.WHITE :
                 value == 0 ? Color.BLACK :
                 value < 0 ? Color.RED : Color.GREEN);
         }
     }
 }
```
This class could then be used inside a ListView as such:
```
 ObservableList<Number> money = ...;
 final ListView<Number> listView = new ListView<Number>(money);
 listView.setCellFactory(new Callback<ListView<Number>, ListCell<Number>>() {
     @Override public ListCell<Number> call(ListView<Number> list) {
         return new MoneyFormatCell();
     }
 });
```
In this example an anonymous inner class is created, that simply returns instances of MoneyFormatCell whenever it is called. The MoneyFormatCell class extends ListCell, overriding the updateItem method. This method is called whenever the item in the cell changes, for example when the user scrolls the ListView or the content of the underlying data model changes (and the cell is reused to represent some different item in the ListView). Because of this, there is no need to manage bindings - simply react to the change in items when this method occurs. In the example above, whenever the item changes, we update the cell text property, and also modify the text fill to ensure that we get the correct visuals. In addition, if the cell is "empty" (meaning it is used to fill out space in the ListView but doesn't have any data associated with it), then we just use the empty String.
Note that there are additional methods prefixed with 'update' that may be of interest, so be sure to read the API documentation for Cell, and subclasses of Cell, closely.
Of course, we can also use the binding API rather than overriding the 'update' methods. Shown below is a very trivial example of how this could be achieved.
```
 public class BoundLabelCell extends ListCell<String> {

     public TextFieldCell() {
         textProperty().bind(itemProperty());
     }
 }
 
```
Key Design Goals
- Both time and memory efficient for large data sets
- Easy to build and use libraries for custom cells
- Easy to customize cell visuals
- Easy to customize display formatting (12.34 as $12.34 or 1234% etc)
- Easy to extend for custom visuals
- Easy to have "panels" of data for the visuals
- Easy to animate the cell size or other properties
Key Use Cases
Following are a number of key use cases used to drive the Cell API design, along with code examples showing how those use cases are satisfied by this API. This is by no means to be considered the definitive list of capabilities or features supported, but rather, to provide some guidance as to how to use the Cell API. The examples below are focused on the ListView, but the same philosophy applies to TreeCells or other kinds of cells.
Changing the Cell's Colors
This should be extraordinarily simple in JavaFX. Each Cell can be styled directly from CSS. So for example, if you wanted to change the default background of every cell in a ListView to be WHITE you could do the following CSS:
```
 .list-cell {
   -fx-padding: 3 3 3 3;
   -fx-background-color: white;
 }
```
If you wanted to set the color of selected ListView cells to be blue, you could add this to your CSS file:
```
 .list-cell:selected {
   -fx-background-color: blue;
 }
```
Most Cell implementations extend from IndexedCell rather than Cell. IndexedCell adds two other pseudoclass states: "odd" and "even". Using this you can get alternate row striping by doing something like this in your CSS file:
```
 .list-cell:odd {
   -fx-background-color: grey;
 }
```
Each of these examples require no code changes. Simply update your CSS file to alter the colors. You can also use the "hover" and other pseudoclasses in CSS the same as with other controls.
Another approach to the first example above (formatting a list of numbers) would be to use style classes. Suppose you had an ObservableList of Numbers to display in a ListView and wanted to color all of the negative values red and all positive or 0 values black. One way to achieve this is with a custom cellFactory which changes the styleClass of the Cell based on whether the value is negative or positive. This is as simple as adding code to test if the number in the cell is negative, and adding a "negative" styleClass. If the number is not negative, the "negative" string should be removed. This approach allows for the colors to be defined from CSS, allowing for simple customization. The CSS file would then include something like the following:
```
 .list-cell {
   -fx-text-fill: black;
 }
 
 .list-cell .negative {
   -fx-text-fill: red;
 }
```

Property Summary

Properties
Type	Property and Description
`BooleanProperty`	`editable` A property representing whether this cell is allowed to be put into an editing state.
`ReadOnlyBooleanProperty`	`editing` Property representing whether this cell is currently in its editing state.
`ReadOnlyBooleanProperty`	`empty` A property used to represent whether the cell has any contents.
`ObjectProperty<T>`	`item` The data value associated with this Cell.
`ReadOnlyBooleanProperty`	`selected` Indicates whether or not this cell has been selected.

Properties inherited from class javafx.scene.control.Labeled
alignment, contentDisplay, ellipsisString, font, graphic, graphicTextGap, labelPadding, mnemonicParsing, textAlignment, textFill, textOverrun, text, underline, wrapText

Properties inherited from class javafx.scene.control.Control
contextMenu, height, maxHeight, maxWidth, minHeight, minWidth, prefHeight, prefWidth, skinClassName, skin, tooltip, width

Properties inherited from class javafx.scene.Parent
needsLayout

Properties inherited from class javafx.scene.Node
blendMode, boundsInLocal, boundsInParent, cacheHint, cache, clip, cursor, depthTest, disabled, disable, effect, eventDispatcher, focused, focusTraversable, hover, id, inputMethodRequests, layoutBounds, layoutX, layoutY, localToParentTransform, localToSceneTransform, managed, mouseTransparent, onContextMenuRequested, onDragDetected, onDragDone, onDragDropped, onDragEntered, onDragExited, onDragOver, onInputMethodTextChanged, onKeyPressed, onKeyReleased, onKeyTyped, onMouseClicked, onMouseDragEntered, onMouseDragExited, onMouseDragged, onMouseDragOver, onMouseDragReleased, onMouseEntered, onMouseExited, onMouseMoved, onMousePressed, onMouseReleased, onRotate, onRotationFinished, onRotationStarted, onScrollFinished, onScroll, onScrollStarted, onSwipeDown, onSwipeLeft, onSwipeRight, onSwipeUp, onTouchMoved, onTouchPressed, onTouchReleased, onTouchStationary, onZoomFinished, onZoom, onZoomStarted, opacity, parent, pickOnBounds, pressed, rotate, rotationAxis, scaleX, scaleY, scaleZ, scene, style, translateX, translateY, translateZ, visible

Field Summary
- Fields inherited from class javafx.scene.control.Control
  USE_COMPUTED_SIZE, USE_PREF_SIZE

Constructor Summary

Constructors
Constructor and Description

Cell()
Creates a default Cell with the default style class of 'cell'.

Constructors
Constructor and Description
`Cell()` Creates a default Cell with the default style class of 'cell'.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`cancelEdit()` Call this function to transition from an editing state into a non-editing state, without saving any user input.
`void`	`commitEdit(T newValue)` Call this function to transition from an editing state into a non-editing state, and in the process saving any user input.
`BooleanProperty`	`editableProperty()` A property representing whether this cell is allowed to be put into an editing state.
`ReadOnlyBooleanProperty`	`editingProperty()` Property representing whether this cell is currently in its editing state.
`ReadOnlyBooleanProperty`	`emptyProperty()` A property used to represent whether the cell has any contents.
`T`	`getItem()` Returns the data value associated with this Cell.
`boolean`	`isEditable()` Returns whether this cell is allowed to be put into an editing state.
`boolean`	`isEditing()` Represents whether the cell is currently in its editing state or not.
`boolean`	`isEmpty()` Returns a boolean representing whether the cell is considered to be empty or not.
`boolean`	`isSelected()` Returns whether this cell is currently selected or not.
`ObjectProperty<T>`	`itemProperty()` The data value associated with this Cell.
`ReadOnlyBooleanProperty`	`selectedProperty()` Indicates whether or not this cell has been selected.
`void`	`setEditable(boolean value)` Allows for certain cells to not be able to be edited.
`void`	`setItem(T value)` Sets the item to the given value - should not be called directly as the item is managed by the virtualized control.
`void`	`startEdit()` Call this function to transition from a non-editing state into an editing state, if the cell is editable.
`protected void`	`updateItem(T item, boolean empty)` Updates the item associated with this Cell.
`void`	`updateSelected(boolean selected)` Updates whether this cell is in a selected state or not.

Methods inherited from class javafx.scene.control.Control
computeMaxHeight, computeMaxWidth, computeMinHeight, computeMinWidth, computePrefHeight, computePrefWidth, contextMenuProperty, getBaselineOffset, getContextMenu, getHeight, getMaxHeight, getMaxWidth, getMinHeight, getMinWidth, getPrefHeight, getPrefWidth, getSkin, getTooltip, getUserAgentStylesheet, getWidth, heightProperty, intersects, isResizable, layoutChildren, maxHeight, maxHeightProperty, maxWidth, maxWidthProperty, minHeight, minHeightProperty, minWidth, minWidthProperty, prefHeight, prefHeightProperty, prefWidth, prefWidthProperty, resize, setContextMenu, setHeight, setMaxHeight, setMaxSize, setMaxWidth, setMinHeight, setMinSize, setMinWidth, setPrefHeight, setPrefSize, setPrefWidth, setSkin, setSkinClassName, setTooltip, setWidth, skinClassNameProperty, skinProperty, tooltipProperty, widthProperty

Methods inherited from class javafx.scene.Parent
getChildren, getChildrenUnmodifiable, getManagedChildren, getStylesheets, isNeedsLayout, layout, lookup, needsLayoutProperty, requestLayout, setNeedsLayout

Methods inherited from class javafx.scene.Node
addEventFilter, addEventHandler, autosize, blendModeProperty, boundsInLocalProperty, boundsInParentProperty, buildEventDispatchChain, cacheHintProperty, cacheProperty, clipProperty, contains, contains, cursorProperty, depthTestProperty, disabledProperty, disableProperty, effectProperty, eventDispatcherProperty, fireEvent, focusedProperty, focusTraversableProperty, getBlendMode, getBoundsInLocal, getBoundsInParent, getCacheHint, getClip, getCursor, getDepthTest, getEffect, getEventDispatcher, getId, getInputMethodRequests, getLayoutBounds, getLayoutX, getLayoutY, getLocalToParentTransform, getLocalToSceneTransform, getOnContextMenuRequested, getOnDragDetected, getOnDragDone, getOnDragDropped, getOnDragEntered, getOnDragExited, getOnDragOver, getOnInputMethodTextChanged, getOnKeyPressed, getOnKeyReleased, getOnKeyTyped, getOnMouseClicked, getOnMouseDragEntered, getOnMouseDragExited, getOnMouseDragged, getOnMouseDragOver, getOnMouseDragReleased, getOnMouseEntered, getOnMouseExited, getOnMouseMoved, getOnMousePressed, getOnMouseReleased, getOnRotate, getOnRotationFinished, getOnRotationStarted, getOnScroll, getOnScrollFinished, getOnScrollStarted, getOnSwipeDown, getOnSwipeLeft, getOnSwipeRight, getOnSwipeUp, getOnTouchMoved, getOnTouchPressed, getOnTouchReleased, getOnTouchStationary, getOnZoom, getOnZoomFinished, getOnZoomStarted, getOpacity, getParent, getProperties, getRotate, getRotationAxis, getScaleX, getScaleY, getScaleZ, getScene, getStyle, getStyleClass, getTransforms, getTranslateX, getTranslateY, getTranslateZ, getUserData, hasProperties, hoverProperty, idProperty, inputMethodRequestsProperty, intersects, isCache, isDisable, isDisabled, isFocused, isFocusTraversable, isHover, isManaged, isMouseTransparent, isPickOnBounds, isPressed, isVisible, layoutBoundsProperty, layoutXProperty, layoutYProperty, localToParent, localToParent, localToParent, localToParentTransformProperty, localToScene, localToScene, localToScene, localToSceneTransformProperty, lookupAll, managedProperty, mouseTransparentProperty, onContextMenuRequestedProperty, onDragDetectedProperty, onDragDoneProperty, onDragDroppedProperty, onDragEnteredProperty, onDragExitedProperty, onDragOverProperty, onInputMethodTextChangedProperty, onKeyPressedProperty, onKeyReleasedProperty, onKeyTypedProperty, onMouseClickedProperty, onMouseDragEnteredProperty, onMouseDragExitedProperty, onMouseDraggedProperty, onMouseDragOverProperty, onMouseDragReleasedProperty, onMouseEnteredProperty, onMouseExitedProperty, onMouseMovedProperty, onMousePressedProperty, onMouseReleasedProperty, onRotateProperty, onRotationFinishedProperty, onRotationStartedProperty, onScrollFinishedProperty, onScrollProperty, onScrollStartedProperty, onSwipeDownProperty, onSwipeLeftProperty, onSwipeRightProperty, onSwipeUpProperty, onTouchMovedProperty, onTouchPressedProperty, onTouchReleasedProperty, onTouchStationaryProperty, onZoomFinishedProperty, onZoomProperty, onZoomStartedProperty, opacityProperty, parentProperty, parentToLocal, parentToLocal, parentToLocal, pickOnBoundsProperty, pressedProperty, relocate, removeEventFilter, removeEventHandler, requestFocus, resizeRelocate, rotateProperty, rotationAxisProperty, scaleXProperty, scaleYProperty, scaleZProperty, sceneProperty, sceneToLocal, sceneToLocal, sceneToLocal, setBlendMode, setCache, setCacheHint, setClip, setCursor, setDepthTest, setDisable, setDisabled, setEffect, setEventDispatcher, setEventHandler, setFocused, setFocusTraversable, setHover, setId, setInputMethodRequests, setLayoutX, setLayoutY, setManaged, setMouseTransparent, setOnContextMenuRequested, setOnDragDetected, setOnDragDone, setOnDragDropped, setOnDragEntered, setOnDragExited, setOnDragOver, setOnInputMethodTextChanged, setOnKeyPressed, setOnKeyReleased, setOnKeyTyped, setOnMouseClicked, setOnMouseDragEntered, setOnMouseDragExited, setOnMouseDragged, setOnMouseDragOver, setOnMouseDragReleased, setOnMouseEntered, setOnMouseExited, setOnMouseMoved, setOnMousePressed, setOnMouseReleased, setOnRotate, setOnRotationFinished, setOnRotationStarted, setOnScroll, setOnScrollFinished, setOnScrollStarted, setOnSwipeDown, setOnSwipeLeft, setOnSwipeRight, setOnSwipeUp, setOnTouchMoved, setOnTouchPressed, setOnTouchReleased, setOnTouchStationary, setOnZoom, setOnZoomFinished, setOnZoomStarted, setOpacity, setPickOnBounds, setPressed, setRotate, setRotationAxis, setScaleX, setScaleY, setScaleZ, setStyle, setTranslateX, setTranslateY, setTranslateZ, setUserData, setVisible, snapshot, snapshot, startDragAndDrop, startFullDrag, styleProperty, toBack, toFront, toString, translateXProperty, translateYProperty, translateZProperty, visibleProperty

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Property Detail
  - item
```
public final ObjectProperty<T> itemProperty
```
    The data value associated with this Cell. This value is set by the virtualized Control when the Cell is created or updated. This represents the raw data value.
    This value should only be set in subclasses of Cell by the virtualised user interface controls that know how to properly work with the Cell class.
    
    See Also:
    getItem(), setItem(T)
  - empty
```
public final ReadOnlyBooleanProperty emptyProperty
```
    A property used to represent whether the cell has any contents. If true, then the Cell contains no data and is not associated with any data item in the virtualized Control.
    When a cell is empty, it can be styled differently via the 'empty' CSS pseudo class state. For example, it may not receive any alternate row highlighting, or it may not receive hover background fill when hovered.
    
    See Also:
    isEmpty()
  - selected
```
public final ReadOnlyBooleanProperty selectedProperty
```
    Indicates whether or not this cell has been selected. For example, a ListView defines zero or more cells as being the "selected" cells.
    
    See Also:
    isSelected()
  - editing
```
public final ReadOnlyBooleanProperty editingProperty
```
    Property representing whether this cell is currently in its editing state.
    
    See Also:
    isEditing()
  - editable
```
public final BooleanProperty editableProperty
```
    A property representing whether this cell is allowed to be put into an editing state. By default editable is set to true in Cells (although for a subclass of Cell to be allowed to enter its editing state, it may have to satisfy additional criteria. For example, ListCell requires that the ListView editable property is also true.
    
    See Also:
    isEditable(), setEditable(boolean)
- Constructor Detail
  - Cell
```
public Cell()
```
    Creates a default Cell with the default style class of 'cell'.
- Method Detail
  - itemProperty
```
public final ObjectProperty<T> itemProperty()
```
    The data value associated with this Cell. This value is set by the virtualized Control when the Cell is created or updated. This represents the raw data value.
    This value should only be set in subclasses of Cell by the virtualised user interface controls that know how to properly work with the Cell class.
    
    See Also:
    getItem(), setItem(T)
  - setItem
```
public final void setItem(T value)
```
    Sets the item to the given value - should not be called directly as the item is managed by the virtualized control.
  - getItem
```
public final T getItem()
```
    Returns the data value associated with this Cell.
  - emptyProperty
```
public final ReadOnlyBooleanProperty emptyProperty()
```
    A property used to represent whether the cell has any contents. If true, then the Cell contains no data and is not associated with any data item in the virtualized Control.
    When a cell is empty, it can be styled differently via the 'empty' CSS pseudo class state. For example, it may not receive any alternate row highlighting, or it may not receive hover background fill when hovered.
    
    See Also:
    isEmpty()
  - isEmpty
```
public final boolean isEmpty()
```
    Returns a boolean representing whether the cell is considered to be empty or not.
  - selectedProperty
```
public final ReadOnlyBooleanProperty selectedProperty()
```
    Indicates whether or not this cell has been selected. For example, a ListView defines zero or more cells as being the "selected" cells.
    
    See Also:
    isSelected()
  - isSelected
```
public final boolean isSelected()
```
    Returns whether this cell is currently selected or not.
    
    Returns:
    True if the cell is selected, false otherwise.
  - isEditing
```
public final boolean isEditing()
```
    Represents whether the cell is currently in its editing state or not.
  - editingProperty
```
public final ReadOnlyBooleanProperty editingProperty()
```
    Property representing whether this cell is currently in its editing state.
    
    See Also:
    isEditing()
  - setEditable
```
public final void setEditable(boolean value)
```
    Allows for certain cells to not be able to be edited. This is useful in cases where, say, a List has 'header rows' - it does not make sense for the header rows to be editable, so they should have editable set to false.
    
    Parameters:
    value - A boolean representing whether the cell is editable or not. If true, the cell is editable, and if it is false, the cell can not be edited.
  - isEditable
```
public final boolean isEditable()
```
    Returns whether this cell is allowed to be put into an editing state.
  - editableProperty
```
public final BooleanProperty editableProperty()
```
    A property representing whether this cell is allowed to be put into an editing state. By default editable is set to true in Cells (although for a subclass of Cell to be allowed to enter its editing state, it may have to satisfy additional criteria. For example, ListCell requires that the ListView editable property is also true.
    
    See Also:
    isEditable(), setEditable(boolean)
  - startEdit
```
public void startEdit()
```
    Call this function to transition from a non-editing state into an editing state, if the cell is editable. If this cell is already in an editing state, it will stay in it.
  - cancelEdit
```
public void cancelEdit()
```
    Call this function to transition from an editing state into a non-editing state, without saving any user input.
  - commitEdit
```
public void commitEdit(T newValue)
```
    Call this function to transition from an editing state into a non-editing state, and in the process saving any user input.
    
    Parameters:
    newValue - The value as input by the end user, which should be persisted in the relevant way given the data source underpinning the user interface.
  - updateItem
```
protected void updateItem(T item,
              boolean empty)
```
    Updates the item associated with this Cell. This method should only be called by Skin implementations of ListView, TableView, TreeView, or other controls using Cells. It is not intended to be called by application developers.
    
    Because null is a perfectly valid value in the application domain, Cell needs some way to distinguish whether or not the cell actually holds a value. The empty flag indicates this. It is an error to supply a non-null item but a true value for empty.
    
    Parameters:
    item - The new item for the cell
    empty - whether or not this cell represents data from the list. If it is empty, then it does not represent any domain data, but is a cell being used to render an "empty" row.
  - updateSelected
```
public void updateSelected(boolean selected)
```
    Updates whether this cell is in a selected state or not.
    
    Parameters:
    selected - whether or not to select this cell.

Class Cell<T>

Key Design Goals

Key Use Cases

Property Summary

Properties inherited from class javafx.scene.control.Labeled

Properties inherited from class javafx.scene.control.Control

Properties inherited from class javafx.scene.Parent

Properties inherited from class javafx.scene.Node

Field Summary

Fields inherited from class javafx.scene.control.Control

Constructor Summary

Method Summary

Methods inherited from class javafx.scene.control.Labeled

Methods inherited from class javafx.scene.control.Control

Methods inherited from class javafx.scene.Parent

Methods inherited from class javafx.scene.Node

Methods inherited from class java.lang.Object

Property Detail

item

empty

selected

editing

editable

Constructor Detail

Cell

Method Detail

itemProperty

setItem

getItem

emptyProperty

isEmpty

selectedProperty

isSelected

isEditing

editingProperty

setEditable

isEditable

editableProperty

startEdit

cancelEdit

commitEdit

updateItem

updateSelected