If a mouse is clicked on a node, should it request the focus? For controls which can be read-only (such as TextArea / TextField), we may want to jump over them when pressing Tab (i.e. focusTraversable = false), but if they are clicked, then they should accept input focus. The user may wish to select, and copy part of the text.

focusBorder

var focusBorder: Border

focusBorderColor

var focusBorderColor: Color

focusBorderColorProperty

val focusBorderColorProperty: StylableColorProperty

focusBorderProperty

val focusBorderProperty: StylableBorderProperty

The focus border is only ever drawn when the focus is set using keyboard shortcuts. So, when you use TAB or Shift+TAB, the extra focusBorder is drawn, but otherwise, it isn't drawn. This gives an uncluttered most of the time (when TAB isn't used).

focusBorderSize

var focusBorderSize: Edges

focusBorderSizeProperty

val focusBorderSizeProperty: StylableEdgesProperty

The border is drawn OUTSIDE the bounds given by sceneX, sceneY ->width x height, and therefore doesn't add to the size of the Node. Nodes which are at the edge of the scene will have one (or two) edges missing.

focused

var focused: Boolean

focusedProperty

val focusedProperty: ReadOnlyBooleanProperty

true when this node has the input focus. Only 1 node has the input focus.

focusHighlight

var focusHighlight: Background

focusHighlightColor

var focusHighlightColor: Color

focusHighlightColorProperty

val focusHighlightColorProperty: StylableColorProperty

focusHighlightProperty

val focusHighlightProperty: StylableBackgroundProperty

A Background, which is drawn ON TOP of the node to highlight it. Used to highlight a section, when using the F6 and Shift+F6 keyboard shortcuts.

focusTraversable

var focusTraversable: Boolean

focusTraversableProperty

val focusTraversableProperty: StylableBooleanProperty

Is this part of the cycle of node that can accept keyboard focus when he user presses the Tab key (or Shift-Tab).

growPriority

var growPriority: Float

growPriorityProperty

val growPriorityProperty: StylableFloatProperty

On a scale of 0..1, if this Node's parent has extra space compared to its preferred size, how much extra space should be give to this Node relative to its siblings?

height

var height: Float

The actual height of this node, in LogicalPixels.

heightProperty

val heightProperty: ReadOnlyFloatProperty

var id: String

idProperty

val idProperty: StringProperty

Supposedly unique identifier (or blank). However, it is up to the application developer to ensure the id is unique.

largeStep

open override var largeStep: Int

largeStepProperty

open override val largeStepProperty: IntProperty

localX

var localX: Float

The position of this Node, relative to its parent Node in LogicalPixels. The position and size of Nodes are assigned by their parent in layout, using setChildBounds.

localXProperty

val localXProperty: ReadOnlyFloatProperty

localY

var localY: Float

The position of this Node, relative to its parent Node in LogicalPixels. The position and size of Nodes are assigned by their parent in layout, using setChildBounds.

localYProperty

val localYProperty: ReadOnlyFloatProperty

max

open override var max: Int

maxProperty

open override val maxProperty: IntProperty

min

open override var min: Int

minProperty

open override val minProperty: IntProperty

overrideMaxHeight

var overrideMaxHeight: Float?

overrideMaxHeightProperty

val overrideMaxHeightProperty: StylableOptionalFloatProperty

See evalMaxHeight.

overrideMaxWidth

var overrideMaxWidth: Float?

overrideMaxWidthProperty

val overrideMaxWidthProperty: StylableOptionalFloatProperty

See evalMaxWidth.

overrideMinHeight

var overrideMinHeight: Float?

overrideMinHeightProperty

val overrideMinHeightProperty: StylableOptionalFloatProperty

A simple way to override the value calculated by nodeMinHeight. Most of the time, this value is null, and therefore nodeMinHeight is used.

overrideMinWidth

var overrideMinWidth: Float?

overrideMinWidthProperty

val overrideMinWidthProperty: StylableOptionalFloatProperty

A simple way to override the value calculated by nodeMinWidth. Most of the time, this value is null, and therefore nodeMinWidth is used.

overridePrefHeight

var overridePrefHeight: Float?

overridePrefHeightProperty

val overridePrefHeightProperty: StylableOptionalFloatProperty

A simple way to override the value calculated by nodePrefHeight. Most of the time, this value is null, and therefore nodePrefHeight is used.

overridePrefWidth

var overridePrefWidth: Float?

overridePrefWidthProperty

val overridePrefWidthProperty: StylableOptionalFloatProperty

A simple way to override the value calculated by nodeMinWidth. Most of the time, this value is null, and therefore nodeMinWidth is used.

padding

var padding: Edges

paddingProperty

val paddingProperty: StylableEdgesProperty

parent

var parent: Node?

parentProperty

val parentProperty: ReadOnlyOptionalNodeProperty

pseudoStyles

val pseudoStyles: MutableObservableSet<String>

Similar to styles, but used for temporary styles, such as :hover.

readOnly

override var readOnly: Boolean

readOnlyProperty

override val readOnlyProperty: BooleanProperty

scene

var scene: Scene?

sceneProperty

val sceneProperty: ReadOnlyOptionalSceneProperty

scenesFontProperty

val scenesFontProperty: ObservableOptionalFont

An ObservableOptionalFont, whose value is Theme.defaultFont. To access this is quite convoluted, because both Node.scene and Scene.theme can change.

sceneX

var sceneX: Float

The X position of the Node relative to the top left of the window in LogicalPixels. The position and size of Nodes are assigned by their parent in layout, using setChildBounds.

sceneXProperty

val sceneXProperty: ReadOnlyFloatProperty

sceneY

var sceneY: Float

The Y position of the Node relative to the top left of the window in LogicalPixels. The position and size of Nodes are assigned by their parent in layout, using setChildBounds.

sceneYProperty

val sceneYProperty: ReadOnlyFloatProperty

section

var section: Boolean

sectionProperty

val sectionProperty: StylableBooleanProperty

To help navigating a scene using keyboard shortcuts (not using a mouse), it is helpful to jump to different sections of the scene. The keyboard shortcut F6 is similar to TAB, but instead of moving one Node at a time, it jumps to the next node, where this is true. Shift+F6 navigates in the opposite direction.

shrinkPriority

var shrinkPriority: Float

shrinkPriorityProperty

val shrinkPriorityProperty: StylableFloatProperty

On a scale of 0..1, if this Node's parent has less space compared to its preferred size, how much should this node shrink by compared to its siblings.

smallStep

open override var smallStep: Int

smallStepProperty

open override val smallStepProperty: IntProperty

spinnerArrowPositions

var spinnerArrowPositions: SpinnerArrowPositions

spinnerArrowPositionsProperty

val spinnerArrowPositionsProperty: StylableSpinnerArrowPositionsProperty

styles

val styles: MutableObservableSet<String>

Used by the Theme to determine how this node should be styled. Similar in concept to CSS's class attribute.

tooltip

var tooltip: Tooltip?

tooltipProperty

val tooltipProperty: OptionalTooltipProperty

Defines a popup that appears when the user hover the mouse over this node for a period of time. Typically, containing help text and a KeyCombination.displayText (if this node can be activated using a keyboard shortcut).

value

open override var value: Int

valueProperty

open override val valueProperty: IntProperty

visible

var visible: Boolean

visibleProperty

val visibleProperty: StylableBooleanProperty

When false, this node will not appear in the scene, and will not take up any spaces.

width

var width: Float

The actual width of this node, in LogicalPixels.

widthProperty

val widthProperty: ReadOnlyFloatProperty

Functions

addEventFilter

fun <E : Event> addEventFilter(eventType: EventType<E>, handler: EventHandler<E>, combination: HandlerCombination = HandlerCombination.AFTER)

fun <E : Event> addEventFilter(eventType: EventType<E>, handlerCombination: HandlerCombination = HandlerCombination.AFTER, handler: (E) -> Unit)

addEventHandler

fun <E : Event> addEventHandler(eventType: EventType<E>, handler: EventHandler<E>, combination: HandlerCombination = HandlerCombination.AFTER)

fun <E : Event> addEventHandler(eventType: EventType<E>, combination: HandlerCombination = HandlerCombination.AFTER, handler: (E) -> Unit)

Consider using these convenience functions instead : onMousePressed, onMouseReleased, onPopupTrigger, onMouseClicked, onMouseDragged, onMouseMoved, onMouseEntered, onMouseExited, onKeyPressed, onKeyReleased.

adjust

open override fun adjust(direction: Int, byLargeStep: Boolean)

adjustment

open override fun adjustment(direction: Int, byLargeStep: Boolean): Int

borderSize

fun Region.borderSize(size: Number)

fun Region.borderSize(topBottom: Number, leftRight: Number)

fun Region.borderSize(top: Number, right: Number, bottom: Number, left: Number)

Sets Region.borderSize.

containsScenePoint

fun containsScenePoint(sceneX: Float, sceneY: Float): Boolean

dump

fun dump(prefix: String = "", borders: Boolean = true, size: Boolean = true, filter: (Node) -> Boolean = { it.visible })

Dumps the scene graph to stdout starting at this Node, and walking through all descendants. Useful for debugging, and to give insights into the structure of controls.

open override fun Number.em(): ObservableOptionalFloat

Converts em units to LogicalPixels.

evalMaxHeight

fun evalMaxHeight(): Float

If overrideMaxHeight is set, then return that, otherwise return nodeMaxHeight. Caching is used to improve speed, as calculating sizes can be relatively expensive.

evalMaxWidth

fun evalMaxWidth(): Float

If overrideMaxWidth is set, then return that, otherwise return nodeMaxWidth. Caching is used to improve speed, as calculating sizes can be relatively expensive.

evalMinHeight

fun evalMinHeight(): Float

If overrideMinWidth is set, then return that, otherwise return nodeMinHeight. Caching is used to improve speed, as calculating sizes can be relatively expensive.

evalMinWidth

fun evalMinWidth(): Float

If overrideMinWidth is set, then return that, otherwise return nodeMinWidth. Caching is used to improve speed, as calculating sizes can be relatively expensive.

evalPrefHeight

fun evalPrefHeight(): Float

If overridePrefWidth is set, then return that, otherwise return nodePrefHeight. Caching is used to improve speed, as calculating sizes can be relatively expensive.

evalPrefWidth

fun evalPrefWidth(): Float

If overridePrefWidth is set, then return that, otherwise return nodePrefWidth. Caching is used to improve speed, as calculating sizes can be relatively expensive.

findDeepestNodeAt

open fun findDeepestNodeAt(sceneX: Float, sceneY: Float): Node

@return this if none of my children are at sceneX,sceneY. Otherwise, the child (or one of its ancestors).

findNodeById

fun findNodeById(id: String): Node?

Checks this node, and all descendants for a matching id. @return The first node which matches, or null if none match.

findStylableProperty

open fun findStylableProperty(propertyName: String): StylableProperty<*>?

firstToRoot

fun firstToRoot(filter: (Node) -> Boolean): Node?

Tests each node from this one to the root node. When filter hold true, that node is returned, stopping the iteration. If none are found, returns null.

forEachDescending

fun forEachDescending(block: (Node) -> Unit)

forEachFromRoot

fun forEachFromRoot(block: (Node) -> Unit)

Applies a block of code on this node, and all of its ancestors, starting at the root node and working downwards to this node.

forEachToRoot

fun forEachToRoot(block: (Node) -> Unit)

Applies a block of code on this node, and all of its ancestors, starting at this node and working up to the root node.

getStylableProperties

open override fun getStylableProperties(): List<StylableProperty<*>>

height

fun Node.height(height: Number)

Sets Node.overridePrefHeight

isAncestorOf

fun isAncestorOf(other: Node): Boolean

Return true, if other === this, or this is a parent, grandparent etc. of other.

isValid

open override fun isValid(newValue: Int): Boolean

nextFocusableNode

fun nextFocusableNode(): Node?

nextSection

fun nextSection(): Node?

noBackground

fun Region.noBackground()

Sets [Region.background to NoBackground

noBorder

fun Region.noBorder()

nodeMaxHeight

open fun nodeMaxHeight(): Float

The default implementation returns NO_MAXIMUM (an arbitrary large number : 100,000).

nodeMaxWidth

open fun nodeMaxWidth(): Float

The default implementation returns NO_MAXIMUM (an arbitrary large number : 100,000).

nodeMinHeight

open override fun nodeMinHeight(): Float

Each subclass should override this, to calculate the minimum height it requires. In general, do not call this, and instead call evalMinHeight.

nodeMinWidth

open override fun nodeMinWidth(): Float

Each subclass should override this to calculate the minimum width it requires. In general, do not call this, and instead call evalMinWidth.

nodePrefHeight

open override fun nodePrefHeight(): Float

Each subclass much override this to calculate its preferred height. In general, do not call this, and instead call evalPrefHeight.

nodePrefWidth

open override fun nodePrefWidth(): Float

Each subclass much override this to calculate its preferred width. In general, do not call this, and instead call evalPrefWidth.

onFilesDropped

fun onFilesDropped(combination: HandlerCombination = HandlerCombination.AFTER, handler: (DroppedFilesEvent) -> Unit)

A more convenient version of addEventHandler for EventType.FILES_DROPPED.

onKeyPressed

fun onKeyPressed(combination: HandlerCombination = HandlerCombination.AFTER, handler: (KeyEvent) -> Unit)

A more convenient version of addEventHandler for EventType.KEY_PRESSED.

onKeyReleased

fun onKeyReleased(combination: HandlerCombination = HandlerCombination.AFTER, handler: (KeyEvent) -> Unit)

A more convenient version of addEventHandler for EventType.KEY_RELEASED.

onKeyTyped

fun onKeyTyped(combination: HandlerCombination = HandlerCombination.AFTER, handler: (KeyTypedEvent) -> Unit)

A more convenient version of addEventHandler for EventType.KEY_TYPED.

onMouseClicked

fun onMouseClicked(combination: HandlerCombination = HandlerCombination.AFTER, handler: (MouseEvent) -> Unit)

A more convenient version of addEventHandler for EventType.MOUSE_CLICKED.

onMouseDragged

fun onMouseDragged(combination: HandlerCombination = HandlerCombination.AFTER, handler: (MouseEvent) -> Unit)

A more convenient version of addEventHandler for EventType.MOUSE_DRAGGED.

onMouseEntered

fun onMouseEntered(combination: HandlerCombination = HandlerCombination.AFTER, handler: (MouseEvent) -> Unit)

A more convenient version of addEventHandler for EventType.MOUSE_ENTERED.

onMouseExited

fun onMouseExited(combination: HandlerCombination = HandlerCombination.AFTER, handler: (MouseEvent) -> Unit)

A more convenient version of addEventHandler for EventType.MOUSE_EXITED.

onMouseMoved

fun onMouseMoved(combination: HandlerCombination = HandlerCombination.AFTER, handler: (MouseEvent) -> Unit)

A more convenient version of addEventHandler for EventType.MOUSE_MOVED.

onMousePressed

fun onMousePressed(combination: HandlerCombination = HandlerCombination.AFTER, handler: (MouseEvent) -> Unit)

A more convenient version of addEventHandler for EventType.MOUSE_PRESSED.

onMouseReleased

fun onMouseReleased(combination: HandlerCombination = HandlerCombination.AFTER, handler: (MouseEvent) -> Unit)

A more convenient version of addEventHandler for EventType.MOUSE_RELEASED.

onPopupTrigger

fun onPopupTrigger(combination: HandlerCombination = HandlerCombination.AFTER, handler: (MouseEvent) -> Unit)

handler will fire when the secondary mouse button is pressed/released depending on the platform.

onScrolled

fun onScrolled(combination: HandlerCombination = HandlerCombination.AFTER, handler: (ScrollEvent) -> Unit)

A more convenient version of addEventHandler for EventType.SCROLL.

padding

fun Region.padding(size: Number)

fun Region.padding(topBottom: Number, leftRight: Number)

fun Region.padding(top: Number, right: Number, bottom: Number, left: Number)

Sets Region.padding.

plainBackground

fun Region.plainBackground(color: String)

Sets Region.background to Color[color]

fun Region.plainBackground(color: Color)

Sets Region.background to PlainBackground

plainBorder

fun Region.plainBorder(color: Color)

fun Region.plainBorder(color: Color, thickness: Number)

fun Region.plainBorder(color: Color, edges: Edges)

fun Region.plainBorder(color: Color, topBottom: Number, leftRight: Number)

previousFocusableNode

fun previousFocusableNode(): Node?

previousSection

fun previousSection(): Node?

pseudoStyle

fun Node.pseudoStyle(name: String)

Adds a style to Node.pseudoStyle

pseudoStyleIf

fun Node.pseudoStyleIf(test: Boolean, pseudoStyle: String)

Adds or removes the pseudoStyle depending on test. See Node.pseudoStyles

fun Node.pseudoStyleIf(test: Boolean, trueStyle: String, falseStyle: String)

When test is true, trueStyle is added, and falseStyle is removed from Node.pseudoStyles.

removeEventFilter

fun <E : Event> removeEventFilter(eventType: EventType<E>, handler: EventHandler<E>)

removeEventHandler

fun <E : Event> removeEventHandler(eventType: EventType<E>, handler: EventHandler<E>)

requestFocus

fun requestFocus(useFocusTraversable: Boolean = false, showFocusBorder: Boolean = false)

Gives the input focus to this node, so that keyboard events are sent to it.

requestLayout

open fun requestLayout()

Informs all ancestors that the pref/min/max size of this node has changed, and therefore layoutChildren needs to be called again before the scene is rendered. Cached data, such as prefWidth/height should be invalidated.

requestRedraw

fun requestRedraw()

Informs that this node needs to be redrawn. Currently, this causes the whole scene to be redrawn.

requiresClipping

open fun requiresClipping(): Boolean

roundedBackground

fun Region.roundedBackground(color: String, radius: Number)

fun Region.roundedBackground(color: Color, radius: Number)

roundedBorder

fun Region.roundedBorder(color: String, radius: Number)

fun Region.roundedBorder(color: Color, radius: Number)

fun Region.roundedBorder(color: String, radius: Number, thickness: Number)

fun Region.roundedBorder(color: Color, radius: Number, thickness: Number)

fun Region.roundedBorder(color: Color, radius: Number, edges: Edges)

fun Region.roundedBorder(color: Color, radius: Number, topBottom: Number, leftRight: Number)

scrollTo

fun scrollTo()

Ensure that this node is visible, by asking all ancestor nodes, which are Scrollable, to scroll to this node. ScrollPanes will adjust their scroll bars, TabPanes will select the appropriate tab, TitledPanes will open their content etc.

style

fun Node.style(name: String)

Adds a style to Node.styles

styleIf

fun Node.styleIf(test: Boolean, style: String)

Adds or removes the style depending on test. See Node.styles

surroundBottom

fun surroundBottom(): Float

surroundLeft

fun surroundLeft(): Float

surroundRight

fun surroundRight(): Float

surroundTop

fun surroundTop(): Float

surroundX

fun surroundX(): Float

surroundY

fun surroundY(): Float

thinBorder

fun Region.thinBorder(color: Color)

toShortString

fun toShortString(): String

toString

open override fun toString(): String

treeVisitor

fun treeVisitor(filter: (Node) -> Boolean = { true }, action: (Node) -> Unit)

Visits this node, and all descendant nodes, performing an action on each. Each node is filtered. If filter returns false, action will not be called on that node, and its children will not be visited.

units

fun Node.units(units: String): HBox

width

fun Node.width(width: Number)

Sets Node.overridePrefWidth

withExpandBar

fun Node.withExpandBar(orientation: Orientation): Box

Adds a thin bar below this node. Dragging the bar changes the Node.overridePrefHeight of the node, therefore the node grows/shrinks.

withExpandHeight

fun Node.withExpandHeight(): Box

withExpandWidth

fun Node.withExpandWidth(): Box