scalafx.scene.control.TreeTableView.scala Maven / Gradle / Ivy
The newest version!
/*
* Copyright (c) 2011-2016, ScalaFX Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the ScalaFX Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE SCALAFX PROJECT OR ITS CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package scalafx.scene.control
import javafx.scene.{control => jfxsc}
import javafx.{css => jfxcss, event => jfxe, scene => jfxs, util => jfxu}
import scala.collection.JavaConversions._
import scala.collection.mutable
import scala.language.implicitConversions
import scalafx.Includes._
import scalafx.beans.property._
import scalafx.collections.ObservableBuffer
import scalafx.delegate.SFXDelegate
import scalafx.event.EventIncludes.jfxEventType2sfx
import scalafx.event.{Event, EventType}
import scalafx.scene.Node
/**
* Object companion for [[scalafx.scene.control.TreeTableView]]
*/
object TreeTableView {
/**
* Converts a ScalaFX TreeTableView instance to its JavaFX counterpart.
*
* @param v ScalaFX TreeTableView
* @return JavaFX TreeTableView
*/
implicit def sfxTreeTableView2jfx[T](v: TreeTableView[T]): jfxsc.TreeTableView[T] =
if (v != null) v.delegate else null
/**
* Object companion for [[scalafx.scene.control.TreeTableView.ResizeFeatures]]
*/
object ResizeFeatures {
/**
* Converts a ScalaFX ResizeFeatures instance to its JavaFX counterpart.
*
* @param rf ScalaFX TreeTableView.ResizeFeatures
* @return JavaFX TreeTableView.ResizeFeatures
*/
implicit def sfxTreeTableViewResizeFeatures2jfx[S](rf: ResizeFeatures[S]): jfxsc.TreeTableView.ResizeFeatures[S] =
if (rf != null) rf.delegate else null
}
/**
* An immutable wrapper class for use in the TableView column resize functionality.
*
* Wraps a JavaFX [[http://docs.oracle.com/javase/8/javafx/api/javafx/scene/control/TreeTableView.ResizeFeatures.html]]
*
* @constructor Creates a new ScalaFX ResizeFeatures from its JavaFX counterpart.
* @param delegate JavaFX ResizeFeatures to be wrapped.
*/
class ResizeFeatures[S](override val delegate: jfxsc.TreeTableView.ResizeFeatures[S])
extends ResizeFeaturesBase[jfxsc.TreeItem[S]](delegate)
with SFXDelegate[jfxsc.TreeTableView.ResizeFeatures[S]] {
type Delegate = jfxsc.TreeTableView.ResizeFeatures[S]
/**
* Creates an instance of this class, with the provided TreeTableView, TreeTableColumn and delta values
* being set and stored in this immutable instance.
*
* @param table The TreeTableView upon which the resize operation is occurring.
* @param column The column upon which the resize is occurring, or null if this ResizeFeatures instance is being
* created as a result of a TreeTableView resize operation.
* @param delta The amount of horizontal space added or removed in the resize operation.
*/
def this(table: TreeTableView[S], column: TreeTableColumn[S, _], delta: Double) =
this(new jfxsc.TreeTableView.ResizeFeatures(table, column, delta))
/**
* Returns the TreeTableView upon which the resize operation is occurring.
*/
def table: TreeTableView[S] = delegate.getTable
/**
* Returns the column upon which the resize is occurring, or null if this ResizeFeatures
* instance was created as a result of a TreeTableView resize operation.
*/
override def column: TreeTableColumn[S, _] = delegate.getColumn
}
/**
* Object companion for [[scalafx.scene.control.TreeTableView.EditEvent]]
*/
object EditEvent {
/**
* Converts a ScalaFX EditEvent instance to its JavaFX counterpart.
*
* @param v ScalaFX TreeTableView EditEvent
* @return JavaFX TreeTableView EditEvent
*/
implicit def sfxTreeTableViewEditEvent2jfx[T](v: EditEvent[T]): jfxsc.TreeTableView.EditEvent[T] =
if (v != null) v.delegate else null
/**
* Common supertype for all edit event types.
*/
val Any = jfxsc.TreeTableView.EditEvent.ANY
}
/**
* An Event subclass used specifically in TreeTableView for representing edit-related events.
* It provides additional API to easily access the TreeItem that the edit event took place on,
* as well as the input provided by the end user.
*
* Wraps a JavaFX [[http://docs.oracle.com/javase/8/javafx/api/javafx/scene/control/TreeTableView.EditEvent.html]]
*
* @constructor Creates a new ScalaFX EditEvent from its JavaFX counterpart.
* @param delegate JavaFX EditEvent to be wrapped.
*/
class EditEvent[T](override val delegate: jfxsc.TreeTableView.EditEvent[T])
extends Event(delegate)
with SFXDelegate[jfxsc.TreeTableView.EditEvent[T]] {
type Delegate = jfxsc.TreeTableView.EditEvent[T]
/**
* Creates a new EditEvent instance to represent an edit event. This event is used for
* TreeTableView.EDIT_START_EVENT, TreeTableView.EDIT_COMMIT_EVENT and
* TreeTableView.EDIT_CANCEL_EVENT types.
*/
def this(source: TreeTableView[T],
eventType: jfxe.EventType[_ <: jfxsc.TreeTableView.EditEvent[T]],
treeTableItem: TreeItem[T], oldValue: T, newValue: T) =
this(new jfxsc.TreeTableView.EditEvent[T](source, eventType, treeTableItem, oldValue, newValue))
/**
* Returns the new value input into the TreeItem by the end user.
*/
def newValue: T = delegate.getNewValue
/**
* Returns the old value that existed in the TreeItem prior to the current edit event.
*/
def oldValue: T = delegate.getOldValue
/**
* Returns the TreeView upon which the edit took place.
*/
override def source: TreeTableView[T] = delegate.getSource
/**
* Returns the `TreeItem` upon which the edit took place.
*/
def treeItem: TreeItem[T] = delegate.getTreeItem
}
/**
* Object companion for [[scalafx.scene.control.TreeTableView.TreeTableViewFocusModel]]
*/
object TreeTableViewFocusModel {
/**
* Converts a ScalaFX TableViewFocusModel instance to its JavaFX counterpart.
*
* @param tvfm ScalaFX TableViewFocusModel
* @return JavaFX TableViewFocusModel
*/
implicit def sfxTableViewFocusModel2jfx[S](tvfm: TreeTableViewFocusModel[S]): jfxsc.TreeTableView.TreeTableViewFocusModel[S] =
if (tvfm != null) tvfm.delegate else null
}
/**
* A FocusModel with additional functionality to support the requirements of a TableView control.
*
* Wraps a JavaFX [[http://docs.oracle.com/javase/8/javafx/api/javafx/scene/control/TreeTableView.TreeTableViewFocusModel.html]]
*
* @constructor Creates a new ScalaFX TreeTableViewFocusModel from its JavaFX counterpart.
* @param delegate JavaFX TreeTableViewFocusModel to be wrapped.
*/
class TreeTableViewFocusModel[S](override val delegate: jfxsc.TreeTableView.TreeTableViewFocusModel[S])
extends TableFocusModel[jfxsc.TreeItem[S], jfxsc.TreeTableColumn[S, _]](delegate)
with SFXDelegate[jfxsc.TreeTableView.TreeTableViewFocusModel[S]] {
type Delegate = jfxsc.TreeTableView.TreeTableViewFocusModel[S]
/**
* Creates a default TableViewFocusModel instance that will be used to manage focus of the provided TableView control.
*
* @param treeTableView The tableView upon which this focus model operates.
*/
def this(treeTableView: TreeTableView[S]) = this(new jfxsc.TreeTableView.TreeTableViewFocusModel(treeTableView))
/**
* The position of the current item in the TableView which has the focus.
*/
def focusedCell: ReadOnlyObjectProperty[jfxsc.TreeTablePosition[S, _]] = delegate.focusedCellProperty
/**
* Causes the item at the given index to receive the focus.
*
* @param index The row index of the item to give focus to.
* @param column The column of the item to give focus to. Can be null.
*/
def focus(index: Int, column: TreeTableColumn[S, _]): Unit = {
delegate.focus(index, column)
}
/**
* Convenience method for setting focus on a particular row or cell using a
* [[scalafx.scene.control.TablePosition]].
*
* @param pos The table position where focus should be set.
*/
def focus(pos: TreeTablePosition[S, _]): Unit = {
delegate.focus(pos)
}
/**
* Causes the item at the given index to receive the focus. This does not cause the current selection to change.
* Updates the focusedItem and focusedIndex properties such that focusedIndex = -1 unless
* 0 <= index < model size
* .
*
* @param index The index of the item to get focus.
*/
override def focus(index: Int): Unit = {
delegate.focus(index)
}
/**
* Tests whether the row / cell at the given location currently has the focus within the TableView.
*
* @param row The row index of the item to be checked.
* @param column The column index of the item to be checked.
*/
def isFocused(row: Int, column: TreeTableColumn[S, _]): Boolean = delegate.isFocused(row, column)
}
/**
* Object companion for [[scalafx.scene.control.TreeTableView.TreeTableViewFocusModel]]
*/
object TreeTableViewSelectionModel {
/**
* Converts a ScalaFX TreeTableViewSelectionModel instance to its JavaFX counterpart.
*
* @param v ScalaFX TreeTableViewSelectionModel
* @return JavaFX TreeTableViewSelectionModel
*/
implicit def sfxTreeTableViewSelectionModel2jfx[S](v: TreeTableView.TreeTableViewSelectionModel[S]): jfxsc.TreeTableView.TreeTableViewSelectionModel[S] = v.delegate
}
/**
* A simple extension of the SelectionModel abstract class to allow for special support for TreeTableView controls.
*
* Wraps a JavaFX [[http://docs.oracle.com/javase/8/javafx/api/javafx/scene/control/TreeTableView.TreeTableViewSelectionModel.html]]
*
* @constructor Creates a new TreeTableViewSelectionModel from a JavaFX one.
* @param delegate A JavaFX TreeTableViewSelectionModel to be wrapped. Its default value is a new JavaFX TreeTableViewSelectionModel.
* @since 8.0
*
*/
abstract class TreeTableViewSelectionModel[S](override val delegate: jfxsc.TreeTableView.TreeTableViewSelectionModel[S])
extends SFXDelegate[jfxsc.TreeTableView.TreeTableViewSelectionModel[S]] {
type Delegate = jfxsc.TreeTableView.TreeTableViewSelectionModel[S]
/**
* A read-only ObservableBuffer representing the currently selected cells in this TreeTableView. Rather than directly
* modify this list, please use the other methods provided in the TreeTableViewSelectionModel.
*/
def selectedCells: ObservableBuffer[TreeTablePosition[S, _]] =
ObservableBuffer(delegate.getSelectedCells.map(ttp => new TreeTablePosition(ttp)))
/**
* Returns the TreeTableView instance that this selection model is installed in.
*/
def treeTableView: TreeTableView[S] = delegate.getTreeTableView
/**
* Returns the item at the given index. An example using ListView would be listView.getItems().get(index).
*
* @param index The index of the item that is requested from the underlying data model.
* @return Returns null if the index is out of bounds, or an element of type TreeItem[S] that is related to the given index.
*/
def modelItem(index: Int): TreeItem[S] = delegate.getModelItem(index)
def focus(row: Int): Unit = { delegate.focus(row) }
def focusedIndex: Int = delegate.getFocusedIndex
/**
* Selects the cells in the range (minRow, minColumn) to (maxRow, maxColumn), inclusive.
*/
def selectRange(minRow: Int, minColumn: TableColumnBase[jfxsc.TreeItem[S], _], maxRow: Int, maxColumn: TableColumnBase[jfxsc.TreeItem[S], _]) {
delegate.selectRange(minRow, minColumn.delegate, maxRow, maxColumn.delegate)
}
/**
* Returns a read-only ObservableList of all selected indices. The ObservableList will be updated by the selection
* model to always reflect changes in selection. This can be observed by adding a ListChangeListener to the returned
* ObservableList.
*/
def selectedIndices: ObservableBuffer[java.lang.Integer] = delegate.getSelectedIndices
/**
* Returns a read-only ObservableList of all selected items. The ObservableList will be updated further by the
* selection model to always reflect changes in selection. This can be observed by adding a ListChangeListener to
* the returned ObservableList.
*/
def selectedItems: ObservableBuffer[jfxsc.TreeItem[S]] = delegate.getSelectedItems
/**
* A method that clears any selection prior to setting the selection to the given index. The purpose of this method
* is to avoid having to call SelectionModel.clearSelection() first, meaning that observers that are listening to
* the selected index property will not see the selected index being temporarily set to -1.
*
* @param row The index that should be the only selected index in this selection model.
*/
def clearAndSelect(row: Int): Unit = {
delegate.clearAndSelect(row)
}
/**
* This will select the given index in the selection model, assuming the index is within the valid range (i.e.
* greater than or equal to zero, and less than the total number of items in the underlying data model).
*
* If there is already one or more indices selected in this model, calling this method will not clear these selections -
* to do so it is necessary to first call SelectionModel.clearSelection().
*
* If the index is already selected, it will not be selected again, or unselected. However, if multiple selection is
* implemented, then calling select on an already selected index will have the effect of making the index the new
* selected index (as returned by SelectionModel.getSelectedIndex().
*
* @param row The position of the item to select in the selection model.
*/
def select(row: Int): Unit = {
delegate.select(row)
}
/**
* This method will attempt to select the index that contains the given object. It will iterate through the
* underlying data model until it finds an item whose value is equal to the given object. At this point it will stop
* iterating - this means that this method will not select multiple indices.
*
* @param obj The object to attempt to select in the underlying data model.
*/
def select(obj: TreeItem[S]): Unit = {
delegate.select(obj)
}
/**
* This method allows for one or more selections to be set at the same time. It will ignore any value that is not
* within the valid range (i.e. greater than or equal to zero, and less than the total number of items in the
* underlying data model). Any duplication of indices will be ignored.
*
* If there is already one or more indices selected in this model, calling this method will not clear these
* selections - to do so it is necessary to first call clearSelection.
*
* The last valid value given will become the selected index / selected item.
*/
def selectIndices(row: Int, rows: Int*): Unit = {
delegate.selectIndices(row, rows: _*)
}
/**
* Convenience method to select all available indices.
*/
def selectAll(): Unit = {
delegate.selectAll()
}
/**
* This method will attempt to select the first index in the control. If clearSelection is not called first, this
* method will have the result of selecting the first index, whilst retaining the selection of any other currently
* selected indices.
*
* If the first index is already selected, calling this method will have no result, and no selection event will
* take place.
*/
def selectFirst(): Unit = {
delegate.selectFirst()
}
/**
* This method will attempt to select the last index in the control. If clearSelection is not called first, this
* method will have the result of selecting the last index, whilst retaining the selection of any other currently
* selected indices.
*
* If the last index is already selected, calling this method will have no result, and no selection event will
* take place.
*/
def selectLast(): Unit = {
delegate.selectLast()
}
/**
* Clears the selection model of all selected indices.
*/
def clearSelection(): Unit = {
delegate.clearSelection()
}
/**
* This method will clear the selection of the item in the given index. If the given index is not selected,
* nothing will happen.
*
* @param index The selected item to deselect.
*/
def clearSelection(index: Int): Unit = {
delegate.clearSelection(index)
}
/**
* Convenience method to inform if the given index is currently selected in this SelectionModel. Is functionally
* equivalent to calling getSelectedIndices().contains(index).
*
* @param index The index to check as to whether it is currently selected or not.
* @return True if the given index is selected, false otherwise.
*/
def isSelected(index: Int): Boolean = delegate.isSelected(index)
/**
* This method is available to test whether there are any selected indices/items. It will return true if there are
* no selected items, and false if there are.
*
* @return Will return true if there are no selected items, and false if there are.
*/
def isEmpty: Boolean = delegate.isEmpty
/**
* This method will attempt to select the index directly before the current focused index. If clearSelection is not
* called first, this method will have the result of selecting the previous index, whilst retaining the selection of
* any other currently selected indices.
*
* Calling this method will only succeed if:
* - There is currently a lead/focused index.
* - The lead/focus index is not the first index in the control.
* - The previous index is not already selected.
*
* If any of these conditions is false, no selection event will take place.
*/
def selectPrevious(): Unit = {
delegate.selectPrevious()
}
/**
* This method will attempt to select the index directly after the current focused index. If clearSelection is not
* called first, this method will have the result of selecting the next index, whilst retaining the selection of any
* other currently selected indices.
*
* Calling this method will only succeed if:
* - There is currently a lead/focused index.
* - The lead/focus index is not the last index in the control.
* - The next index is not already selected.
*
* If any of these conditions is false, no selection event will take place.
*/
def selectNext(): Unit = {
delegate.selectNext()
}
}
/**
* 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.
*/
val UnconstrainedResizePolicy: TreeTableView.ResizeFeatures[_] => Boolean =
tvrf => jfxsc.TreeTableView.UNCONSTRAINED_RESIZE_POLICY(tvrf)
/**
* 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.
*/
val ConstrainedResizePolicy: TreeTableView.ResizeFeatures[_] => Boolean =
tvrf => jfxsc.TreeTableView.CONSTRAINED_RESIZE_POLICY(tvrf)
/**
* The default sort policy that this TreeTableView will use if no other policy is specified. The sort policy is a
* simple Callback that accepts a TreeTableView 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.
*/
val DefaultSortPolicy: TreeTableView[_] => Boolean =
ttv => jfxsc.TreeTableView.DEFAULT_SORT_POLICY(ttv)
/**
* An EventType that indicates some edit event has occurred.
*/
def editAnyEvent[T]: EventType[jfxsc.TreeTableView.EditEvent[T]] = jfxsc.TreeTableView.editAnyEvent[T]()
/**
* An EventType used to indicate that an edit event has just been canceled
* within the TreeTableView upon which the event was fired.
*/
def editCancelEvent[T]: EventType[jfxsc.TreeTableView.EditEvent[T]] = jfxsc.TreeTableView.editCancelEvent[T]()
/**
* An EventType that is used to indicate that an edit in a TreeTableView has been
* committed.
*/
def editCommitEvent[T]: EventType[jfxsc.TreeTableView.EditEvent[T]] = jfxsc.TreeTableView.editCommitEvent[T]()
/**
* An EventType used to indicate that an edit event has started within the
* TreeTableView upon which the event was fired.
*/
def editStartEvent[T]: EventType[jfxsc.TreeTableView.EditEvent[T]] = jfxsc.TreeTableView.editStartEvent[T]()
/**
* The CssMetaData associated with this class, which may include the CssMetaData of its super
* classes.
*
* @since 8.0
*/
def classCssMetaData: mutable.Buffer[jfxcss.CssMetaData[_ <: jfxcss.Styleable, _]] =
jfxsc.PopupControl.getClassCssMetaData
}
/**
* The `TreeTableView` control is designed to visualize an unlimited number of rows of data, broken out into columns.
* The `TreeTableView` control is conceptually very similar to the `TreeView` and `TableView` controls,
* and as you read on you'll come to see the APIs are largely the same. However, to give a high-level overview,
* you'll note that the `TreeTableView` uses the same `TreeItem` API as `TreeView`, and that you therefore are required
* to simply set the root node in the `TreeTableView`. Similarly, the `TreeTableView` control makes use of the same
* `TableColumn`-based approach that the `TableView` control uses, except instead of using the `TableView`-specific
* `TableColumn` class, you should instead use the `TreeTableView`-specific `TreeTableColumn` class instead.
*
* Wraps a JavaFX [[http://docs.oracle.com/javase/8/javafx/api/javafx/scene/control/TreeTableView.TreeTableView.html]]
*
* @constructor Creates a new TreeTableView from a JavaFX one.
* @param delegate A JavaFX TreeTableView to be wrapped. Its default value is a new JavaFX TreeTableView.
* @tparam S The type of the TreeItem instances used in this TreeTableView.
* @since 8.0
*
*/
class TreeTableView[S](override val delegate: jfxsc.TreeTableView[S] = new jfxsc.TreeTableView[S])
extends Control(delegate)
with SFXDelegate[jfxsc.TreeTableView[S]] {
type Delegate = jfxsc.TreeTableView[S]
/**
* Returns the number of levels of 'indentation' of the given TreeItem,
* based on how many times getParent() can be recursively called.
* DEPRECATED:
*
* @param node The ScalaFX TreeItem for which the level is needed.
* @return An integer representing the number of parents above the given node,
* or -1 if the given TreeItem is null.
*/
@deprecated("use [[treeItemLevel(TreeItem)]] instead", "8.0_20")
def nodeLevel(node: TreeItem[S]) = jfxsc.TreeTableView.getNodeLevel(node: TreeItem[S])
/**
* Creates a TreeTableView with the provided root node.
*
* Refer to the [[TreeTableView]] class documentation for details on the default state of other properties.
*
* @param rootItem The node to be the root in this TreeTableView.
*/
def this(rootItem: TreeItem[S]) = this(new jfxsc.TreeTableView[S](rootItem))
/**
* Property representing the root node of the TreeView.
*/
def root: ObjectProperty[jfxsc.TreeItem[S]] = delegate.rootProperty
def root_=(v: TreeItem[S]) {
root() = v
}
/**
* Property that represents whether or not the TreeView root node is visible.
*/
def showRoot: BooleanProperty = delegate.showRootProperty
def showRoot_=(v: Boolean): Unit = {
showRoot() = v
}
/**
* Property that represents which column should have the disclosure node shown in it (that is, the column with the
* arrow). By default this will be the left-most column if this property is null, otherwise it will be the specified
* column assuming it is non-null and contained within the visible leaf columns list.
*/
def treeColumn: ObjectProperty[jfxsc.TreeTableColumn[S, _]] = delegate.treeColumnProperty
def treeColumn_=(v: TreeTableColumn[S, _]): Unit = {
treeColumn() = v
}
/**
* The SelectionModel provides the API through which it is possible to select single or multiple items within a
* TreeTableView, as well as inspect which rows have been selected by the user. Note that it has a generic type that
* must match the type of the TreeTableView itself.
*/
def selectionModel: ObjectProperty[jfxsc.TreeTableView.TreeTableViewSelectionModel[S]] = delegate.selectionModelProperty
def selectionModel_=(v: TreeTableView.TreeTableViewSelectionModel[S]): Unit = {
selectionModel() = v
}
/**
* The FocusModel provides the API through which it is possible to control focus on zero or one rows of the
* TreeTableView. Generally the default implementation should be more than sufficient.
*/
def focusModel: ObjectProperty[jfxsc.TreeTableView.TreeTableViewFocusModel[S]] = delegate.focusModelProperty
def focusModel_=(v: TreeTableView.TreeTableViewFocusModel[S]): Unit = {
focusModel() = v
}
/**
* Represents the number of tree nodes presently able to be visible in the TreeTableView. This is essentially the
* count of all expanded tree items, and their children.
*
* For example, if just the root node is visible, the expandedItemCount will be one. If the root had three children
* and the root was expanded, the value will be four.
*/
def expandedItemCount: ReadOnlyIntegerProperty = delegate.expandedItemCountProperty
/**
* Specifies whether this TreeTableView is editable - only if the TreeTableView and the TreeCells within it are both
* editable will a TreeCell be able to go into their editing state.
*/
def editable: BooleanProperty = delegate.editableProperty
def editable_=(v: Boolean): Unit = {
editable() = v
}
/**
* Represents the current cell being edited, or null if there is no cell being edited.
*/
def editingCell: ReadOnlyObjectProperty[jfxsc.TreeTablePosition[S, _]] = delegate.editingCellProperty
/**
* 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 TreeTableColumn in this table. This menu allows for the user to show
* and hide all TreeTableColumns easily.
*/
def tableMenuButtonVisible: BooleanProperty = delegate.tableMenuButtonVisibleProperty
def tableMenuButtonVisible_=(v: Boolean): Unit = {
tableMenuButtonVisible() = v
}
/**
* This is the function called when the user completes a column-resize operation. The two most common policies are
* available as static functions in the TableView class: [[TreeTableView#UNCONSTRAINED_RESIZE_POLICY]] and
* [[TreeTableView#CONSTRAINED_RESIZE_POLICY]].
*/
def columnResizePolicy: ObjectProperty[TreeTableView.ResizeFeatures[S] => Boolean] =
ObjectProperty((features: TreeTableView.ResizeFeatures[S]) => delegate.columnResizePolicyProperty.value.call(features))
def columnResizePolicy_=(p: TreeTableView.ResizeFeatures[_] => Boolean): Unit = {
delegate.columnResizePolicyProperty().setValue(new jfxu.Callback[jfxsc.TreeTableView.ResizeFeatures[_], java.lang.Boolean] {
def call(v: jfxsc.TreeTableView.ResizeFeatures[_]): java.lang.Boolean = {
p(v)
}
})
}
def columnResizePolicy_=(p: jfxu.Callback[jfxsc.TreeTableView.ResizeFeatures[_], java.lang.Boolean]): Unit = {
delegate.columnResizePolicyProperty().setValue(p)
}
/**
* A function which produces a TreeTableRow. The system is responsible for reusing TreeTableRows. Return from this
* function a TreeTableRow which might be usable for representing a single row in a TableView.
*
* Note that a TreeTableRow is not a TableCell. A TreeTableRow 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 TreeTableRows. The
* primary use case for creating custom TreeTableRow 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 TreeTableColumn class.
*/
def rowFactory: ObjectProperty[jfxu.Callback[jfxsc.TreeTableView[S], jfxsc.TreeTableRow[S]]] = delegate.rowFactoryProperty
def rowFactory_=(v: (TreeTableView[S] => TreeTableRow[S])): Unit = {
rowFactory() = new jfxu.Callback[jfxsc.TreeTableView[S], jfxsc.TreeTableRow[S]] {
def call(tv: jfxsc.TreeTableView[S]): jfxsc.TreeTableRow[S] = {
v(tv)
}
}
}
/**
* This Node is shown to the user when the table has no content to show. This may be the case because the table model
* has no data in the first place, that a filter has been applied to the table model, resulting in there being nothing
* to show the user, or that there are no currently visible columns.
*/
def placeholder: ObjectProperty[jfxs.Node] = delegate.placeholderProperty
def placeholder_=(v: Node): Unit = {
placeholder() = v
}
/**
* Specifies whether this control has cells that are a fixed height (of the specified value). If this value is less
* than or equal to zero, then all cells are individually sized and positioned. This is a slow operation. Therefore,
* when performance matters and developers are not dependent on variable cell sizes it is a good idea to set the fixed
* cell size value. Generally cells are around 24px, so setting a fixed cell size of 24 is likely to result in very
* little difference in visuals, but a improvement to performance.
*
* 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.
*/
def fixedCellSize: DoubleProperty = delegate.fixedCellSizeProperty
def fixedCellSize_=(v: Double): Unit = {
fixedCellSize() = v
}
/**
* Specifies the sort mode to use when sorting the contents of this TreeTableView, should any columns be specified
* in the sort order list.
*/
def sortMode: ObjectProperty[jfxsc.TreeSortMode] = delegate.sortModeProperty
def sortMode_=(v: TreeSortMode): Unit = {
sortMode() = v
}
/**
* The comparator property is a read-only property that is representative of the current state of the 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.
*/
def comparator: ReadOnlyObjectProperty[java.util.Comparator[jfxsc.TreeItem[S]]] = delegate.comparatorProperty
/** The sort policy specifies how sorting in this TreeTableView should be performed. For example, a basic sort policy
* may just recursively sort the children of the root tree item, whereas a more advanced sort policy may call to a
* database to perform the necessary sorting on the server-side.
*
* TreeTableView ships with a default sort policy that does precisely as mentioned above: it simply attempts to sort
* the tree hierarchy in-place.
*
* It is recommended that rather than override the sort method that a different sort policy be provided instead.
*/
def sortPolicy: ObjectProperty[TreeTableView[S] => Boolean] =
ObjectProperty((ttv: TreeTableView[S]) => delegate.sortPolicyProperty.get().call(ttv))
def sortPolicy_=(v: TreeTableView[S] => Boolean): Unit = {
ObjectProperty.fillProperty[TreeTableView[S] => Boolean](sortPolicy, v)
}
/*
def sortPolicy: ObjectProperty[jfxu.Callback[jfxsc.TreeTableView[T], java.lang.Boolean]] = delegate.sortPolicyProperty
def sortPolicy_=(v: jfxu.Callback[jfxsc.TreeTableView[T], java.lang.Boolean]) {
ObjectProperty.fillProperty[jfxu.Callback[jfxsc.TreeTableView[T], java.lang.Boolean]](sortPolicy, v)
}
*/
/**
* Called when there's a request to sort the control.
*/
def onSort: ObjectProperty[jfxe.EventHandler[jfxsc.SortEvent[jfxsc.TreeTableView[S]]]] = delegate.onSortProperty
def onSort_=(v: jfxe.EventHandler[jfxsc.SortEvent[jfxsc.TreeTableView[S]]]): Unit = {
onSort() = v
}
/**
* Scrolls the TreeTableView such that the item in the given index is visible to the end user.
*
* @param index The index that should be made visible to the user, assuming of course that it is greater than, or
* equal to 0, and less than the number of the visible items in the TreeTableView.
*/
def scrollTo(index: Int): Unit = { delegate.scrollTo(index) }
/**
* Called when there's a request to scroll an index into view using [[scrollTo(int)]]
*/
def onScrollTo = delegate.onScrollToProperty
def onScrollTo_=(v: jfxe.EventHandler[jfxsc.ScrollToEvent[Integer]]): Unit = {
onScrollTo() = v
}
/**
* Scrolls the TreeTableView so that the given column is visible within the viewport.
*
* @param column The column that should be visible to the user.
*/
def scrollToColumn(column: TreeTableColumn[S, _]): Unit = { delegate.scrollToColumn(column) }
/**
* Scrolls the TreeTableView so that the given index is visible within the viewport.
*
* @param index The index of a column that should be visible to the user.
*/
def scrollToColumnIndex(index: Int): Unit = { delegate.scrollToColumnIndex(index) }
/**
* Called when there's a request to scroll a column into view using scrollToColumn(TreeTableColumn) or scrollToColumnIndex(int)
*/
def onScrollToColumn: ObjectProperty[jfxe.EventHandler[jfxsc.ScrollToEvent[jfxsc.TreeTableColumn[S, _]]]] = delegate.onScrollToColumnProperty
def onScrollToColumn_=(v: jfxe.EventHandler[jfxsc.ScrollToEvent[jfxsc.TreeTableColumn[S, _]]]): Unit = {
ObjectProperty.fillProperty[jfxe.EventHandler[jfxsc.ScrollToEvent[jfxsc.TreeTableColumn[S, _]]]](onScrollToColumn, v)
}
/**
* Returns the index position of the given TreeItem, taking into account the
* current state of each TreeItem (i.e. whether or not it is expanded).
*/
def row(item: TreeItem[S]): Int = delegate.getRow(item)
/**
* Returns the TreeItem in the given index, or null if it is out of bounds.
*
* @param row The index of the TreeItem being sought.
* @return The TreeItem in the given index, or null if it is out of bounds.
*/
def treeItem(row: Int): TreeItem[S] = delegate.getTreeItem(row)
/**
* Returns the number of levels of 'indentation' of the given TreeItem,
* based on how many times getParent() can be recursively called.
* If the given TreeItem is the root node of this TreeTableView, or if the TreeItem does not have any parent set,
* the returned value will be zero. For each time getParent() is recursively called,
* the returned value is incremented by one.
*
* @param node The TreeItem for which the level is needed.
* @return An integer representing the number of parents above the given node, or -1 if the given TreeItem is null.
*/
def treeItemLevel(node: TreeItem[_]): Int = delegate.getTreeItemLevel(node)
/**
* The TreeTableColumns that are part of this TableView. As the user reorders the TableView columns, this list will
* be updated to reflect the current visual ordering.
*
* Note: to display any data in a TableView, there must be at least one TreeTableColumn in this ObservableList.
*/
def columns: ObservableBuffer[jfxsc.TreeTableColumn[S, _]] = delegate.getColumns
/**
* The sortOrder list defines the order in which TreeTableColumn instances are sorted. An empty sortOrder list means
* that no sorting is being applied on the TableView. If the sortOrder list has one TreeTableColumn within it, the
* TableView will be sorted using the sortType and comparator properties of this TreeTableColumn (assuming
* TreeTableColumn.sortable is true). If the sortOrder list contains multiple TreeTableColumn instances, then the
* TableView is firstly sorted based on the properties of the first TreeTableColumn. If two elements are considered
* equal, then the second TreeTableColumn in the list is used to determine ordering. This repeats until the results
* from all TreeTableColumn comparators are considered, if necessary.
*/
def sortOrder: ObservableBuffer[jfxsc.TreeTableColumn[S, _]] = delegate.getSortOrder
/**
* Applies the currently installed resize policy against the given column, resizing it based on the delta value provided.
*
*/
def resizeColumn(column: TreeTableColumn[S, _], delta: Double): Boolean = { delegate.resizeColumn(column, delta) }
/**
* 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.
*/
def edit(row: Int, item: TreeTableColumn[S, _]): Unit = delegate.edit(row, item)
/**
* Returns an unmodifiable list containing the currently visible leaf columns.
*/
def visibleLeafColumns: ObservableBuffer[jfxsc.TreeTableColumn[S, _]] = delegate.getVisibleLeafColumns
/**
* Returns the position of the given column, relative to all other visible leaf columns.
*/
def visibleLeafIndex(column: TreeTableColumn[S, _]) = delegate.getVisibleLeafIndex(column)
/**
* Returns the TreeTableColumn in the given column index, relative to all other visible leaf columns.
*/
def visibleLeafColumn(column: Int): TreeTableColumn[S, _] = delegate.getVisibleLeafColumn(column)
/**
* The sort method forces the TreeTableView to re-run its sorting algorithm. More often than not it is not necessary
* to call this method directly, as it is automatically called when the sort order, sort policy, or the state of the
* TreeTableColumn sort type properties change. In other words, this method should only be called directly when
* something external changes and a sort is required.
*/
def sort(): Unit = { delegate.sort() }
/**
* Returns the CssMetaData associated with this class, which may include the CssMetaData of its super classes.
*/
def controlCssMetaData: Seq[jfxcss.CssMetaData[_ <: jfxcss.Styleable, _]] = delegate.getControlCssMetaData
}© 2015 - 2024 Weber Informatics LLC | Privacy Policy