TreeTableView

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object FilterMagnet

Companion object implementing Magnet Pattern Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"

object HandlerMagnet

Companion object implementing Magnet Pattern Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"

def accessibleHelp: ObjectProperty[String]

The accessible help text for this Node.

def accessibleHelp_=(v: String): Unit

def accessibleRole: ObjectProperty[javafx.scene.AccessibleRole]

The accessible role for this Node.

def accessibleRoleDescription: ObjectProperty[String]

The role description of this Node.

def accessibleRoleDescription_=(v: String): Unit

def accessibleRole_=(v: AccessibleRole): Unit

def accessibleText: ObjectProperty[String]

The accessible text for this Node.

def accessibleText_=(v: String): Unit

def addEventFilter[E <: Event](eventType: EventType[E], eventHandler: EventHandler[_ >: E]): Unit

Registers an event filter to this task.

def addEventHandler[E <: Event](eventType: EventType[E], eventHandler: EventHandler[_ >: E]): Unit

Registers an event handler to this task.

def alignmentInParent: Pos

Pseudo-property that indicates this Node position inside its respective parent.

def alignmentInParent_=(p: Pos): Unit

Sets this Node's alignment constraint inside its Parent.

final def asInstanceOf[T0]: T0

def autosize(): Unit

If the node is resizable, will set its layout bounds to its current preferred width and height.

def background: ObjectProperty[Background]

The background of the Region, which is made up of zero or more BackgroundFills, and zero or more BackgroundImages.

def background_=(v: Background): Unit

def baselineOffset: Double

The 'alphabetic' (or 'roman') baseline offset from the node's layoutBounds.

def blendMode: ObjectProperty[BlendMode]

The BlendMode used to blend this individual node into the scene behind it.

def blendMode_=(v: BlendMode): Unit

def border: ObjectProperty[Border]

The border of the Region, which is made up of zero or more BorderStrokes, and zero or more BorderImages.

def border_=(v: Border): Unit

def boundsInLocal: ReadOnlyObjectProperty[Bounds]

The rectangular bounds of this Node in the node's untransformed local coordinate space.

def boundsInParent: ReadOnlyObjectProperty[Bounds]

The rectangular bounds of this Node which include its transforms.

def buildEventDispatchChain(chain: EventDispatchChain): EventDispatchChain

Construct an event dispatch chain for this target.

def cache: BooleanProperty

A performance hint to the system to indicate that this Node should be cached as a bitmap.

def cacheHint: ObjectProperty[javafx.scene.CacheHint]

Additional hint for controlling bitmap caching.

def cacheHint_=(v: CacheHint): Unit

def cacheShape: BooleanProperty

Defines a hint to the system indicating that the Shape used to define the region's background is stable and would benefit from caching.

def cacheShape_=(v: Boolean): Unit

def cache_=(v: Boolean): Unit

def centerShape: BooleanProperty

Defines whether the shape is centered within the Region's width or height.

def centerShape_=(v: Boolean): Unit

def clip: ObjectProperty[javafx.scene.Node]

Specifies a Node to use to define the the clipping shape for this Node.

def clip_=(v: Node): Unit

def clone(): AnyRef

def columnResizePolicy: ObjectProperty[(ResizeFeatures[S]) ⇒ Boolean]

This is the function called when the user completes a column-resize operation.

def columnResizePolicy_=(p: Callback[ResizeFeatures[_], Boolean]): Unit

def columnResizePolicy_=(p: (ResizeFeatures[_]) ⇒ Boolean): Unit

def columns: ObservableBuffer[javafx.scene.control.TreeTableColumn[S, _]]

The TreeTableColumns that are part of this TableView.

def comparator: ReadOnlyObjectProperty[Comparator[javafx.scene.control.TreeItem[S]]]

The comparator property is a read-only property that is representative of the current state of the sort order list.

def contains(localPoint: Point2D): Boolean

Returns true if the given point (specified in the local coordinate space of this Node) is contained within the shape of this Node.

def contains(localX: Double, localY: Double): Boolean

Returns true if the given point (specified in the local coordinate space of this Node) is contained within the shape of this Node.

def contentBias: Orientation

Returns the orientation of a node's resizing bias for layout purposes.

def contextMenu: ObjectProperty[javafx.scene.control.ContextMenu]

The ContextMenu to show for this control.

def contextMenu_=(v: ContextMenu): Unit

def controlCssMetaData: Seq[CssMetaData[_ <: Styleable, _]]

Returns the CssMetaData associated with this class, which may include the CssMetaData of its super classes.

def cssMetaData: Seq[CssMetaData[_ <: Styleable, _]]

The CssMetaData of this Styleable.

def cursor: ObjectProperty[javafx.scene.Cursor]

Defines the mouse cursor for this Node and subnodes.

def cursor_=(v: Cursor): Unit

val delegate: javafx.scene.control.TreeTableView[S]

A JavaFX TreeTableView to be wrapped.

def depthTest: ObjectProperty[javafx.scene.DepthTest]

Indicates whether depth testing is used when rendering this node.

def depthTest_=(v: DepthTest): Unit

def disable: BooleanProperty

Sets the individual disabled state of this Node.

def disable_=(v: Boolean): Unit

def disabled: ReadOnlyBooleanProperty

Indicates whether or not this Node is disabled.

def edit(row: Int, item: TreeTableColumn[S, _]): Unit

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 editable: BooleanProperty

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_=(v: Boolean): Unit

def editingCell: ReadOnlyObjectProperty[javafx.scene.control.TreeTablePosition[S, _]]

Represents the current cell being edited, or null if there is no cell being edited.

def effect: ObjectProperty[Effect]

Specifies an effect to apply to this Node.

def effect_=(v: Effect): Unit

def effectiveNodeOrientation: ReadOnlyObjectProperty[NodeOrientation]

The effective orientation of a node resolves the inheritance of node orientation, returning either left-to-right or right-to-left.

final def eq(arg0: AnyRef): Boolean

def equals(ref: Any): Boolean

Verifies if a object is equals to this delegate.

def eventDispatcher: ObjectProperty[EventDispatcher]

Specifies the event dispatcher for this node.

def eventDispatcher_=(v: EventDispatcher): Unit

def eventHandlerDelegate: EventHandled

Returns a object that implements scalafx.event.EventHandlerDelegate.EventHandled.

def expandedItemCount: ReadOnlyIntegerProperty

Represents the number of tree nodes presently able to be visible in the TreeTableView.

def filterEvent[J <: Event, S <: Event with SFXDelegate[J]](eventType: EventType[J])(filter: FilterMagnet[J, S]): Subscription

Registers an event filter.

pane.filterEvent(MouseEvent.Any) {
me: MouseEvent => {
  me.eventType match {
    case MouseEvent.MousePressed => {
      ...
    }
    case MouseEvent.MouseDragged => {
      ...
    }
    case _ => {
      ...
    }
  }
}
}

pane.filterEvent(MouseEvent.Any) { () => println("Some mouse event handled") }

def finalize(): Unit

def fireEvent(event: Event): Unit

Fires the specified event.

def fixedCellSize: DoubleProperty

Specifies whether this control has cells that are a fixed height (of the specified value).

def fixedCellSize_=(v: Double): Unit

def focusModel: ObjectProperty[TreeTableViewFocusModel[S]]

The FocusModel provides the API through which it is possible to control focus on zero or one rows of the TreeTableView.

def focusModel_=(v: TreeTableViewFocusModel[S]): Unit

def focusTraversable: BooleanProperty

Specifies whether this Node should be a part of focus traversal cycle.

def focusTraversable_=(v: Boolean): Unit

def focused: ReadOnlyBooleanProperty

Indicates whether this Node currently has the input focus.

final def getClass(): Class[_]

def getId: String

The id of this Styleable.

def getStyle: String

A string representation of the CSS style associated with this specific Node.

def handleEvent[J <: Event, S <: Event with SFXDelegate[J]](eventType: EventType[J])(handler: HandlerMagnet[J, S]): Subscription

Registers an event handler.

pane.handleEvent(MouseEvent.Any) {
me: MouseEvent => {
  me.eventType match {
    case MouseEvent.MousePressed => ...
    case MouseEvent.MouseDragged => ...
    case _                       => {}
  }
}
}

pane.handleEvent(MouseEvent.Any) { () => println("Some mouse event handled") }

def hashCode(): Int

def height: ReadOnlyDoubleProperty

The height of this resizable node.

def hgrow: Priority

Pseudo-property that returns this Node's hgrow constraint if set.

def hgrow_=(p: Priority): Unit

Sets the horizontal grow priority for this Node inside its parent.

def hover: ReadOnlyBooleanProperty

Whether or not this Node is being hovered over.

def id: StringProperty

The id of this Node.

def id_=(v: String): Unit

def inputMethodRequests: ObjectProperty[InputMethodRequests]

Property holding InputMethodRequests.

def inputMethodRequests_=(v: InputMethodRequests): Unit

def insets: Insets

Gets the space around content, which will include any borders plus padding if set.

def intersects(localX: Double, localY: Double, localWidth: Double, localHeight: Double): Boolean

Returns true if the given rectangle (specified in the local coordinate space of this Node) intersects the shape of this Node.

def intersects(localBounds: Bounds): Boolean

Returns true if the given bounds (specified in the local coordinate space of this Node) intersects the shape of this Node.

final def isInstanceOf[T0]: Boolean

def layoutBounds: ReadOnlyObjectProperty[Bounds]

The rectangular bounds that should be used for layout calculations for this node.

def layoutX: DoubleProperty

Defines the x coordinate of the translation that is added to this Node's transform for the purpose of layout.

def layoutX_=(v: Double): Unit

def layoutY: DoubleProperty

Defines the y coordinate of the translation that is added to this Node's transform for the purpose of layout.

def layoutY_=(v: Double): Unit

def localToParent(localPoint: Point2D): Point2D

Transforms a point from the local coordinate space of this Node into the coordinate space of its parent.

def localToParent(localX: Double, localY: Double): Point2D

Transforms a point from the local coordinate space of this Node into the coordinate space of its parent.

def localToParent(localBounds: Bounds): Bounds

Transforms a bounds from the local coordinate space of this Node into the coordinate space of its parent.

def localToParentTransform: Transform

An affine transform that holds the computed local-to-parent transform.

def localToScene(localPoint: Point2D): Point2D

Transforms a point from the local coordinate space of this Node into the coordinate space of its Scene.

def localToScene(localX: Double, localY: Double): Point2D

Transforms a point from the local coordinate space of this Node into the coordinate space of its Scene.

def localToScene(localBounds: Bounds): Bounds

Transforms a bounds from the local coordinate space of this Node into the coordinate space of its Scene.

def localToSceneTransform: Transform

An affine transform that holds the computed local-to-scene transform.

def lookup(selector: String): Node

Finds this Node, or the first sub-node, based on the given CSS selector.

def lookupAll(selector: String): Set[javafx.scene.Node]

Finds all Nodes, including this one and any children, which match the given CSS selector.

def managed: BooleanProperty

Defines whether or not this node's layout will be managed by it's parent.

def managed_=(v: Boolean): Unit

def margin: Insets

Pseudo-property that returns this Node's margin constraint inside its Parent if set.

def margin_=(i: Insets): Unit

Sets this Node's margin constraint inside its Parent if set.

def maxHeight: DoubleProperty

Property for overriding the region's computed maximum height.

def maxHeight(width: Double): Double

Returns the node's maximum height for use in layout calculations.

def maxHeight_=(v: Double): Unit

def maxWidth: DoubleProperty

Property for overriding the region's computed maximum width.

def maxWidth(height: Double): Double

Returns the node's maximum width for use in layout calculations.

def maxWidth_=(v: Double): Unit

def minHeight: DoubleProperty

Property for overriding the region's computed minimum height.

def minHeight(width: Double): Double

Returns the node's minimum height for use in layout calculations.

def minHeight_=(v: Double): Unit

def minWidth: DoubleProperty

Property for overriding the region's computed minimum width.

def minWidth(height: Double): Double

Returns the node's minimum width for use in layout calculations.

def minWidth_=(v: Double): Unit

def mouseTransparent: BooleanProperty

If true, this node (together with all its children) is completely transparent to mouse events.

def mouseTransparent_=(v: Boolean): Unit

final def ne(arg0: AnyRef): Boolean

def needsLayout: ReadOnlyBooleanProperty

Indicates that this Node and its subnodes requires a layout pass on the next pulse.

def nodeOrientation: ObjectProperty[NodeOrientation]

Node orientation describes the flow of visual data within a node.

def nodeOrientation_=(v: NodeOrientation): Unit

final def notify(): Unit

final def notifyAll(): Unit

def onContextMenuRequested: ObjectProperty[EventHandler[_ >: ContextMenuEvent]]

Defines a function to be called when a context menu has been requested on this Node.

def onContextMenuRequested_=(v: EventHandler[_ >: ContextMenuEvent]): Unit

def onDragDetected: ObjectProperty[EventHandler[_ >: MouseEvent]]

Defines a function to be called when drag gesture has been detected.

def onDragDetected_=(v: EventHandler[_ >: MouseEvent]): Unit

def onDragDone: ObjectProperty[EventHandler[_ >: DragEvent]]

Defines a function to be called when this Node is a drag and drop gesture source after its data has been dropped on a drop target.

def onDragDone_=(v: EventHandler[_ >: DragEvent]): Unit

def onDragDropped: ObjectProperty[EventHandler[_ >: DragEvent]]

Defines a function to be called when the mouse button is released on this Node during drag and drop gesture.

def onDragDropped_=(v: EventHandler[_ >: DragEvent]): Unit

def onDragEntered: ObjectProperty[EventHandler[_ >: DragEvent]]

Defines a function to be called when drag gesture enters this Node.

def onDragEntered_=(v: EventHandler[_ >: DragEvent]): Unit

def onDragExited: ObjectProperty[EventHandler[_ >: DragEvent]]

Defines a function to be called when drag gesture exits this Node.

def onDragExited_=(v: EventHandler[_ >: DragEvent]): Unit

def onDragOver: ObjectProperty[EventHandler[_ >: DragEvent]]

Defines a function to be called when drag gesture progresses within this Node.

def onDragOver_=(v: EventHandler[_ >: DragEvent]): Unit

def onInputMethodTextChanged: ObjectProperty[EventHandler[_ >: InputMethodEvent]]

Defines a function to be called when this Node has input focus and the input method text has changed.

def onInputMethodTextChanged_=(v: EventHandler[_ >: InputMethodEvent]): Unit

def onKeyPressed: ObjectProperty[EventHandler[_ >: KeyEvent]]

Defines a function to be called when this Node or its child Node has input focus and a key has been pressed.

def onKeyPressed_=(v: EventHandler[_ >: KeyEvent]): Unit

def onKeyReleased: ObjectProperty[EventHandler[_ >: KeyEvent]]

Defines a function to be called when this Node or its child Node has input focus and a key has been released.

def onKeyReleased_=(v: EventHandler[_ >: KeyEvent]): Unit

def onKeyTyped: ObjectProperty[EventHandler[_ >: KeyEvent]]

Defines a function to be called when this Node or its child Node has input focus and a key has been typed.

def onKeyTyped_=(v: EventHandler[_ >: KeyEvent]): Unit

def onMouseClicked: ObjectProperty[EventHandler[_ >: MouseEvent]]

Defines a function to be called when a mouse button has been clicked (pressed and released) on this Node.

def onMouseClicked_=(v: EventHandler[_ >: MouseEvent]): Unit

def onMouseDragEntered: ObjectProperty[EventHandler[_ >: MouseDragEvent]]

Defines a function to be called when a full press-drag-release gesture enters this Node.

def onMouseDragEntered_=(v: EventHandler[_ >: MouseDragEvent]): Unit

def onMouseDragExited: ObjectProperty[EventHandler[_ >: MouseDragEvent]]

Defines a function to be called when a full press-drag-release gesture leaves this Node.

def onMouseDragExited_=(v: EventHandler[_ >: MouseDragEvent]): Unit

def onMouseDragOver: ObjectProperty[EventHandler[_ >: MouseDragEvent]]

Defines a function to be called when a full press-drag-release gesture progresses within this Node.

def onMouseDragOver_=(v: EventHandler[_ >: MouseDragEvent]): Unit

def onMouseDragReleased: ObjectProperty[EventHandler[_ >: MouseDragEvent]]

Defines a function to be called when a full press-drag-release gesture ends (by releasing mouse button) within this Node.

def onMouseDragReleased_=(v: EventHandler[_ >: MouseDragEvent]): Unit

def onMouseDragged: ObjectProperty[EventHandler[_ >: MouseEvent]]

Defines a function to be called when a mouse button is pressed on this Node and then dragged.

def onMouseDragged_=(v: EventHandler[_ >: MouseEvent]): Unit

def onMouseEntered: ObjectProperty[EventHandler[_ >: MouseEvent]]

Defines a function to be called when the mouse enters this Node.

def onMouseEntered_=(v: EventHandler[_ >: MouseEvent]): Unit

def onMouseExited: ObjectProperty[EventHandler[_ >: MouseEvent]]

Defines a function to be called when the mouse exits this Node.

def onMouseExited_=(v: EventHandler[_ >: MouseEvent]): Unit

def onMouseMoved: ObjectProperty[EventHandler[_ >: MouseEvent]]

def onMouseMoved_=(v: EventHandler[_ >: MouseEvent]): Unit

def onMousePressed: ObjectProperty[EventHandler[_ >: MouseEvent]]

Defines a function to be called when a mouse button has been pressed on this Node.

def onMousePressed_=(v: EventHandler[_ >: MouseEvent]): Unit

def onMouseReleased: ObjectProperty[EventHandler[_ >: MouseEvent]]

Defines a function to be called when a mouse button has been released on this Node.

def onMouseReleased_=(v: EventHandler[_ >: MouseEvent]): Unit

def onRotate: ObjectProperty[EventHandler[_ >: RotateEvent]]

Defines a function to be called when user performs a rotation action.

def onRotate_=(v: EventHandler[_ >: RotateEvent]): Unit

def onRotationFinished: ObjectProperty[EventHandler[_ >: RotateEvent]]

Defines a function to be called when a rotation gesture ends.

def onRotationFinished_=(v: EventHandler[_ >: RotateEvent]): Unit

def onRotationStarted: ObjectProperty[EventHandler[_ >: RotateEvent]]

Defines a function to be called when a rotation gesture starts.

def onRotationStarted_=(v: EventHandler[_ >: RotateEvent]): Unit

def onScroll: ObjectProperty[EventHandler[_ >: ScrollEvent]]

Defines a function to be called when user performs a scrolling action.

def onScrollFinished: ObjectProperty[EventHandler[_ >: ScrollEvent]]

Defines a function to be called when a Scroll gesture ends.

def onScrollFinished_=(v: EventHandler[_ >: ScrollEvent]): Unit

def onScrollStarted: ObjectProperty[EventHandler[_ >: ScrollEvent]]

Defines a function to be called when a Scroll gesture starts.

def onScrollStarted_=(v: EventHandler[_ >: ScrollEvent]): Unit

def onScrollTo: ObjectProperty[EventHandler[javafx.scene.control.ScrollToEvent[Integer]]]

Called when there's a request to scroll an index into view using scrollTo(int)

def onScrollToColumn: ObjectProperty[EventHandler[javafx.scene.control.ScrollToEvent[javafx.scene.control.TreeTableColumn[S, _]]]]

Called when there's a request to scroll a column into view using scrollToColumn(TreeTableColumn) or scrollToColumnIndex(int)

def onScrollToColumn_=(v: EventHandler[javafx.scene.control.ScrollToEvent[javafx.scene.control.TreeTableColumn[S, _]]]): Unit

def onScrollTo_=(v: EventHandler[javafx.scene.control.ScrollToEvent[Integer]]): Unit

def onScroll_=(v: EventHandler[_ >: ScrollEvent]): Unit

def onSort: ObjectProperty[EventHandler[javafx.scene.control.SortEvent[javafx.scene.control.TreeTableView[S]]]]

Called when there's a request to sort the control.

def onSort_=(v: EventHandler[javafx.scene.control.SortEvent[javafx.scene.control.TreeTableView[S]]]): Unit

def onSwipeDown: ObjectProperty[EventHandler[_ >: SwipeEvent]]

Defines a function to be called when a Swipe Down gesture starts.

def onSwipeDown_=(v: EventHandler[_ >: SwipeEvent]): Unit

def onSwipeLeft: ObjectProperty[EventHandler[_ >: SwipeEvent]]

Defines a function to be called when a Swipe Down gesture starts.

def onSwipeLeft_=(v: EventHandler[_ >: SwipeEvent]): Unit

def onSwipeRight: ObjectProperty[EventHandler[_ >: SwipeEvent]]

Defines a function to be called when a Swipe Right gesture starts.

def onSwipeRight_=(v: EventHandler[_ >: SwipeEvent]): Unit

def onSwipeUp: ObjectProperty[EventHandler[_ >: SwipeEvent]]

Defines a function to be called when a Swipe Up gesture starts.

def onSwipeUp_=(v: EventHandler[_ >: SwipeEvent]): Unit

def onTouchMoved: ObjectProperty[EventHandler[_ >: TouchEvent]]

Defines a function to be called when user performs a Touch Moved action.

def onTouchMoved_=(v: EventHandler[_ >: TouchEvent]): Unit

def onTouchPressed: ObjectProperty[EventHandler[_ >: TouchEvent]]

Defines a function to be called when user performs a Touch Pressed action.

def onTouchPressed_=(v: EventHandler[_ >: TouchEvent]): Unit

def onTouchReleased: ObjectProperty[EventHandler[_ >: TouchEvent]]

Defines a function to be called when user performs a Touch Released action.

def onTouchReleased_=(v: EventHandler[_ >: TouchEvent]): Unit

def onTouchStationary: ObjectProperty[EventHandler[_ >: TouchEvent]]

Defines a function to be called when user performs a Touch Stationary action.

def onTouchStationary_=(v: EventHandler[_ >: TouchEvent]): Unit

def onZoom: ObjectProperty[EventHandler[_ >: ZoomEvent]]

Defines a function to be called when user performs a Touch action.

def onZoomFinished: ObjectProperty[EventHandler[_ >: ZoomEvent]]

Defines a function to be called when a Zoom gesture ends.

def onZoomFinished_=(v: EventHandler[_ >: ZoomEvent]): Unit

def onZoomStarted: ObjectProperty[EventHandler[_ >: ZoomEvent]]

Defines a function to be called when a Zoom gesture starts.

def onZoomStarted_=(v: EventHandler[_ >: ZoomEvent]): Unit

def onZoom_=(v: EventHandler[_ >: ZoomEvent]): Unit

def opacity: DoubleProperty

Specifies how opaque (that is, solid) the Node appears.

def opacity_=(v: Double): Unit

def opaqueInsets: ObjectProperty[Insets]

Defines the area of the region within which completely opaque pixels are drawn.

def opaqueInsets_=(v: Insets): Unit

def padding: ObjectProperty[Insets]

The top,right,bottom,left padding around the region's content.

def padding_=(v: Insets): Unit

def parent: ReadOnlyObjectProperty[javafx.scene.Parent]

The parent of this Node.

def parentToLocal(parentPoint: Point2D): Point2D

Transforms a point from the coordinate space of the parent into the local coordinate space of this Node.

def parentToLocal(parentX: Double, parentY: Double): Point2D

Transforms a point from the coordinate space of the parent into the local coordinate space of this Node.

def parentToLocal(parentBounds: Bounds): Bounds

Transforms a rectangle from the coordinate space of the parent into the local coordinate space of this Node.

def pickOnBounds: BooleanProperty

Defines how the picking computation is done for this node when triggered by a MouseEvent or a contains function call.

def pickOnBounds_=(v: Boolean): Unit

def placeholder: ObjectProperty[javafx.scene.Node]

This Node is shown to the user when the table has no content to show.

def placeholder_=(v: Node): Unit

def prefHeight: DoubleProperty

Property for overriding the region's computed preferred height.

def prefHeight_=(v: Double): Unit

def prefWidth: DoubleProperty

Property for overriding the region's computed preferred width.

def prefWidth_=(v: Double): Unit

def pressed: ReadOnlyBooleanProperty

Whether or not the Node is pressed.

def pseudoClassStates: ObservableSet[PseudoClass]

The pseudo-class state of this Styleable.

def relocate(x: Double, y: Double): Unit

Sets the node's layoutX and layoutY translation properties in order to relocate this node to the x,y location in the parent.

def removeEventFilter[E <: Event](eventType: EventType[E], eventHandler: EventHandler[_ >: E]): Unit

Unregisters a previously registered event filter from this task.

def removeEventHandler[E <: Event](eventType: EventType[E], eventHandler: EventHandler[_ >: E]): Unit

Unregisters a previously registered event handler from this task.

def requestFocus(): Unit

Requests that this Node get the input focus, and that this Node's top-level ancestor become the focused window.

def resize(width: Double, height: Double): Unit

Invoked by the region's parent during layout to set the region's width and height.

def resize: Boolean

Returns true since all Regions are resizable.

def resizeColumn(column: TreeTableColumn[S, _], delta: Double): Boolean

Applies the currently installed resize policy against the given column, resizing it based on the delta value provided.

def resizeRelocate(x: Double, y: Double, width: Double, height: Double): Unit

If the node is resizable, will set its layout bounds to the specified width and height.

def root: ObjectProperty[javafx.scene.control.TreeItem[S]]

Property representing the root node of the TreeView.

def root_=(v: TreeItem[S]): Unit

def rotate: DoubleProperty

Defines the angle of rotation about the Node's center, measured in degrees.

def rotate_=(v: Double): Unit

def rotationAxis: ObjectProperty[Point3D]

Defines the axis of rotation of this Node.

def rotationAxis_=(v: Point3D): Unit

def row(item: TreeItem[S]): Int

Returns the index position of the given TreeItem, taking into account the current state of each TreeItem (i.

def rowFactory: ObjectProperty[Callback[javafx.scene.control.TreeTableView[S], javafx.scene.control.TreeTableRow[S]]]

A function which produces a TreeTableRow.

def rowFactory_=(v: (TreeTableView[S]) ⇒ TreeTableRow[S]): Unit

def scaleShape: BooleanProperty

Specifies whether the shape, if defined, is scaled to match the size of the Region.

def scaleShape_=(v: Boolean): Unit

def scaleX: DoubleProperty

Defines the factor by which coordinates are scaled about the center of the object along the X axis of this Node.

def scaleX_=(v: Double): Unit

def scaleY: DoubleProperty

Defines the factor by which coordinates are scaled about the center of the object along the Y axis of this Node.

def scaleY_=(v: Double): Unit

def scaleZ: DoubleProperty

Defines the factor by which coordinates are scaled about the center of the object along the Z axis of this Node.

def scaleZ_=(v: Double): Unit

def scene: ReadOnlyObjectProperty[javafx.scene.Scene]

The Scene that this Node is part of.

def sceneToLocal(scenePoint: Point2D): Point2D

Transforms a point from the coordinate space of the Scene into the local coordinate space of this Node.

def sceneToLocal(sceneX: Double, sceneY: Double): Point2D

Transforms a point from the coordinate space of the Scene into the local coordinate space of this Node.

def sceneToLocal(sceneBounds: Bounds): Bounds

Transforms a rectangle from the coordinate space of the Scene into the local coordinate space of this Node.

def scrollTo(index: Int): Unit

Scrolls the TreeTableView such that the item in the given index is visible to the end user.

def scrollToColumn(column: TreeTableColumn[S, _]): Unit

Scrolls the TreeTableView so that the given column is visible within the viewport.

def scrollToColumnIndex(index: Int): Unit

Scrolls the TreeTableView so that the given index is visible within the viewport.

def selectionModel: ObjectProperty[TreeTableViewSelectionModel[S]]

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.

def selectionModel_=(v: TreeTableViewSelectionModel[S]): Unit

def shape: ObjectProperty[Shape]

When specified, the shape will cause the region to be rendered as the specified shape rather than as a rounded rectangle.

def shape_=(v: Shape): Unit

def showRoot: BooleanProperty

Property that represents whether or not the TreeView root node is visible.

def showRoot_=(v: Boolean): Unit

def skin: ObjectProperty[javafx.scene.control.Skin[_]]

Skin is responsible for rendering this Control.

def skin_=(v: Skin[_]): Unit

def snapToPixel: BooleanProperty

Defines whether this region rounds position/spacing and cell size values to pixel boundaries when laying out its children.

def snapToPixel_=(v: Boolean): Unit

def snapshot(callback: (SnapshotResult) ⇒ Unit, params: SnapshotParameters, image: WritableImage): Unit

Takes a snapshot of this node at the next frame and calls the specified callback method when the image is ready.

def snapshot(params: SnapshotParameters, image: WritableImage): WritableImage

Takes a snapshot of this node and returns the rendered image when it is ready.

def sort(): Unit

The sort method forces the TreeTableView to re-run its sorting algorithm.

def sortMode: ObjectProperty[javafx.scene.control.TreeSortMode]

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_=(v: TreeSortMode): Unit

def sortOrder: ObservableBuffer[javafx.scene.control.TreeTableColumn[S, _]]

The sortOrder list defines the order in which TreeTableColumn instances are sorted.

def sortPolicy: ObjectProperty[(TreeTableView[S]) ⇒ Boolean]

The sort policy specifies how sorting in this TreeTableView should be performed.

def sortPolicy_=(v: (TreeTableView[S]) ⇒ Boolean): Unit

def startDragAndDrop(transferModes: TransferMode*): Dragboard

Confirms a potential drag and drop gesture that is recognized over this Node.

def startFullDrag(): Unit

Starts a full press-drag-release gesture with this node as gesture source.

def style: StringProperty

A string representation of the CSS style associated with this specific Node.

def styleClass: ObservableBuffer[String]

A list of String identifiers which can be used to logically group Nodes, specifically for an external style engine.

def styleClass_=(c: Iterable[String]): Unit

Sets the list of CSS styles classes, replacing the prior content.

def style_=(v: String): Unit

def styleableParent: Styleable

The parent of this Styleable, or null if there is no parent.

def stylesheets: ObservableList[String]

Gets an observable list of string URLs linking to the stylesheets to use with this Parent's contents.

def stylesheets_=(c: Iterable[String]): Unit

Sets the list of stylesheets URLs, replacing the prior content.

final def synchronized[T0](arg0: ⇒ T0): T0

def tableMenuButtonVisible: BooleanProperty

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.

def tableMenuButtonVisible_=(v: Boolean): Unit

def toBack(): Unit

Moves this Node to the back of its sibling nodes in terms of z-order.

def toFront(): Unit

Moves this Node to the front of its sibling nodes in terms of z-order.

def toString(): String

def tooltip: ObjectProperty[javafx.scene.control.Tooltip]

The ToolTip for this control.

def tooltip_=(v: Tooltip): Unit

def transforms: ObservableList[Transform]

Defines the ObservableList of Transform objects to be applied to this Node.

def transforms_=(c: Iterable[Transform]): Unit

Sets the list of transforms, replacing the prior content.

def translateX: DoubleProperty

Defines the x coordinate of the translation that is added to this Node's transform.

def translateX_=(v: Double): Unit

def translateY: DoubleProperty

Defines the y coordinate of the translation that is added to this Node's transform.

def translateY_=(v: Double): Unit

def translateZ: DoubleProperty

Defines the Z coordinate of the translation that is added to the transformed coordinates of this Node.

def translateZ_=(v: Double): Unit

def treeColumn: ObjectProperty[javafx.scene.control.TreeTableColumn[S, _]]

Property that represents which column should have the disclosure node shown in it (that is, the column with the arrow).

def treeColumn_=(v: TreeTableColumn[S, _]): Unit

def treeItem(row: Int): TreeItem[S]

Returns the TreeItem in the given index, or null if it is out of bounds.

def treeItemLevel(node: TreeItem[_]): Int

Returns the number of levels of 'indentation' of the given TreeItem, based on how many times getParent() can be recursively called.

def typeSelector: String

The type of this Styleable that is to be used in selector matching.

def userData: AnyRef

Returns a previously set Object property, or null if no such property has been set using the setUserData(AnyRef) method.

def userData_=(v: AnyRef): Unit

def vgrow: Priority

Pseudo-property that returns this Node's vgrow constraint if set.

def vgrow_=(p: Priority): Unit

Sets the vertical grow priority for this Node inside its parent.

def visible: BooleanProperty

Specifies whether this Node and any subnodes should be rendered as part of the scene graph.

def visibleLeafColumn(column: Int): TreeTableColumn[S, _]

Returns the TreeTableColumn in the given column index, relative to all other visible leaf columns.

def visibleLeafColumns: ObservableBuffer[javafx.scene.control.TreeTableColumn[S, _]]

Returns an unmodifiable list containing the currently visible leaf columns.

def visibleLeafIndex(column: TreeTableColumn[S, _]): Int

Returns the position of the given column, relative to all other visible leaf columns.

def visible_=(v: Boolean): Unit

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def width: ReadOnlyDoubleProperty

The width of this resizable node.

def nodeLevel(node: TreeItem[S]): Int

Returns the number of levels of 'indentation' of the given TreeItem, based on how many times getParent() can be recursively called.