glok-core/uk.co.nickthecoder.glok.scene/Node

Node

abstract class Node

The base class for all GUI elements in a Scene. The nodes form a Scene Graph (which is a misnomer, because it is a tree structure, not a graph), starting at the Scene.root Node.

Each Node may only appear once (i.e. you cannot use the same node in two place, or in two scenes).

See Scene for a Class Diagram.

Inheritors

Constructors

Node

constructor()

Types

Companion

object Companion

Properties

children

open val children: ObservableList<Node>

The base class Node has no children, so this is an empty list.

focusAcceptable

var focusAcceptable: Boolean

focusAcceptableProperty

val focusAcceptableProperty: StylableBooleanProperty

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 the are clicked, then they should accept input focus. The user may wish to select, and copy part of the text.

focused

val focused: Boolean

focusedProperty

val focusedProperty: ReadOnlyBooleanProperty

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

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.

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

overrideMaxHeight

var overrideMaxHeight: Float?

overrideMaxHeightProperty

val overrideMaxHeightProperty: StylableOptionalFloatProperty

When not null, nodeMaxHeight is ignored.

overrideMaxWidth

var overrideMaxWidth: Float?

overrideMaxWidthProperty

val overrideMaxWidthProperty: StylableOptionalFloatProperty

When not null, nodeMaxWidth is ignored.

overrideMinHeight

var overrideMinHeight: Float?

overrideMinHeightProperty

val overrideMinHeightProperty: StylableOptionalFloatProperty

When not null, nodeMinHeight is ignored.

overrideMinWidth

var overrideMinWidth: Float?

overrideMinWidthProperty

val overrideMinWidthProperty: StylableOptionalFloatProperty

When not null, nodeMinWidth is ignored.

overridePrefHeight

var overridePrefHeight: Float?

overridePrefHeightProperty

val overridePrefHeightProperty: StylableOptionalFloatProperty

When not null, nodePrefHeight is ignored.

overridePrefWidth

var overridePrefWidth: Float?

overridePrefWidthProperty

val overridePrefWidthProperty: StylableOptionalFloatProperty

When not null, nodePrefWidth is ignored.

parent

var parent: Node?

parentProperty

val parentProperty: ReadOnlyOptionalNodeProperty

pseudoStyles

val pseudoStyles: MutableObservableSet<String>

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

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

shrinkPriority

var shrinkPriority: Float

shrinkPriorityProperty

val shrinkPriorityProperty: StylableFloatProperty

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

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).

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.

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 fun Number.em(): ObservableOptionalFloat

Converts em units to LogicalPixels.

evalMaxHeight

fun evalMaxHeight(): Float

evalMaxWidth

fun evalMaxWidth(): Float

evalMinHeight

fun evalMinHeight(): Float

evalMinWidth

fun evalMinWidth(): Float

evalPrefHeight

fun evalPrefHeight(): Float

evalPrefWidth

fun evalPrefWidth(): Float

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.

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.

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.

nextFocusableNode

fun nextFocusableNode(): Node?

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 fun nodeMinHeight(): Float

Each subclass of node can determine the minimum width it requires. This can be overridden on an ad-hoc basis using overrideMinHeight. The default implementation returns 0.

nodeMinWidth

open fun nodeMinWidth(): Float

Each subclass of node can determine the minimum width it requires. This can be overridden on an ad-hoc basis using overrideMinWidth. The default implementation returns 0.

nodePrefHeight

abstract fun nodePrefHeight(): Float

Each subclass of node can determine its preferred height. As most nodes are composed of smaller nodes, this is typically calculated using evalPrefWidth of the child nodes, with extra added for spacing, padding and borders.

nodePrefWidth

abstract fun nodePrefWidth(): Float

Each subclass of node can determine its preferred width. As most nodes are composed of smaller nodes, this is typically calculated using evalPrefWidth of the child nodes, with extra added for spacing, padding and borders.

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.

previousFocusableNode

fun previousFocusableNode(): 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)

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

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

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.

width

fun Node.width(width: Number)

Sets Node.overridePrefWidth