Fx.Abstract.Node

Performance hint

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

Rendering a bitmap representation of a node will be faster than rendering primitives in many cases, especially in the case of primitives with effects applied (such as a blur)

However, it also increases memory usage. This hint indicates whether that trade-off (increased memory usage for increased performance) is worthwhile

Also note that on some platforms such as GPU accelerated platforms there is little benefit to caching Nodes as bitmaps when blurs and other effects are used since they are very fast to render on the GPU

The cacheHintProperty() variable provides additional options for enabling more aggressive bitmap caching

Caching may be disabled for any node that has a 3D transform on itself, any of its ancestors, or any of its descendants

Check disabled

Indicates whether or not this Node is disabled. A Node will become disabled if disable is set to true on either itself or one of its ancestors in the scene graph

A disabled Node should render itself differently to indicate its disabled state to the user. Such disabled rendering is dependent on the implementation of the Node

The shape classes contained in javafx.scene.shape do not implement such rendering by default, therefore applications using shapes for handling input must implement appropriate disabled rendering themselves

The user-interface controls defined in javafx.scene.control will implement disabled-sensitive rendering, however.

A disabled Node does not receive mouse or key events.

Disable

Sets the individual disabled state of this Node

Setting disable to true will cause this Node and any subnodes to become disabled

This variable should be used only to set the disabled state of a Node

For querying the disabled state of a Node, the disabled variable should instead be used, since it is possible that a Node was disabled as a result of an ancestor being disabled even if the individual disable state on this Node is false

Check focused

Indicates whether this Node currently has the input focus

To have the input focus, a node must be the Scene's focus owner, and the scene must be in a Stage that is visible and active

See requestFocus() for more information

Check focus traversable

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

When this property is true focus can be moved to this Node and from this Node using regular focus traversal keys

On a desktop such keys are usually TAB for moving focus forward and SHIFT+TAB for moving focus backward

When a Scene is created, the system gives focus to a Node whose focusTraversable variable is true and that is eligible to receive the focus, unless the focus had been set explicitly via a call to requestFocus()

Check hover

Whether or not this Node is being hovered over

Typically this is due to the mouse being over the node, though it could be due to a pen hovering on a graphics tablet or other form of input

Note that current implementation of hover relies on mouse enter and exit events to determine whether this Node is in the hover state; this means that this feature is currently supported only on systems that have a mouse

Future implementations may provide alternative means of supporting hover.

Node id

The id of this Node.

This simple string identifier is useful for finding a specific Node within the scene graph. While the id of a Node should be unique within the scene graph, this uniqueness is not enforced

This is analogous to the "id" attribute on an HTML element (CSS ID Specification)

For example, if a Node is given the id of "myId", then the map method can be used to find this node as follows: scene.map("#myId");

Layout x

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

Layout y

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

Managed switch

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

If the node is managed, it's parent will factor the node's Geometry into its own preferred size and layoutBounds calculations and will lay it out during the scene's layout pass

If a managed node's layoutBounds changes, it will automatically trigger relayout up the scene-graph to the nearest layout root (which is typically the scene's root node)

If the node is unmanaged, its parent will ignore the child in both preferred size computations and layout. Changes in layoutBounds will not trigger relayout above it

If an unmanaged node is of type Parent, it will act as a "layout root", meaning that calls to Parent.requestLayout() beneath it will cause only the branch rooted by the node to be relayed out, thereby isolating layout changes to that root and below. It's the application's responsibility to set the size and position of an unmanaged node.

By default all nodes are managed.

Mouse transparent

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

When choosing target for mouse event, nodes with mouseTransparent set to true and their subtrees won't be taken into account.

On drag detected

Defines a function to be called when drag gesture has been detected. This is the right place to start drag and drop operation

On drag done

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

The transferMode of the event shows what just happened at the drop target.

If transferMode has the value MOVE, then the source can clear out its data

Clearing the source's data gives the appropriate appearance to a user that the data has been moved by the drag and drop gesture

A transferMode that has the value NONE indicates that no data was transferred during the drag and drop gesture

On drag dropped

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

Transfer of data from the DragEvent's dragboard should happen in this function

On drag entered

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

On drag exited

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

On drag over

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

On key pressed

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

On key released

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

On key customized

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

On mouse clicked

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

On mouse drag entered

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

On mouse drag exited

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

Mouse dragged

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

On mouse drag over

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

On mouse drag released

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

// ------------------------------------------------------------------------------------------------

On mouse entered

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

On mouse exited

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

Mouse left clicked

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

On mouse moved

Defines a function to be called when mouse cursor moves within this Node but no buttons have been pushed

On mouse pressed

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

On mouse released

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

On mouse right clicked

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

On rotate

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

On rotation finished

Defines a function to be called when a rotation gesture ends

On rotation started

Defines a function to be called when a rotation gesture is detected

On scroll

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

On scroll finished

Defines a function to be called when a scrolling gesture ends

On scroll started

Defines a function to be called when a scrolling gesture is detected

On swipe down

Defines a function to be called when a downward swipe gesture centered over this node happens

On swipe left

Defines a function to be called when a leftward swipe gesture centered over this node happens

On swipe right

Defines a function to be called when an rightward swipe gesture centered over this node happens

On swipe up

Defines a function to be called when an upward swipe gesture centered over this node happens

On touch moved

Defines a function to be called when a touch point is moved

On touch pressed

Defines a function to be called when a new touch point is pressed

On touch released

Defines a function to be called when a touch point is released

On touch stationary

Defines a function to be called when a touch point stays pressed and still

On zoom

Defines a function to be called when user performs a zooming action

On zoom

Defines a function to be called when a zooming gesture ends

On zoom

Defines a function to be called when a zooming gesture is detected

Opacity

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

A Node with 0% opacity is fully translucent

That is, while it is still visible and rendered, you generally won't be able to see it

The exception to this rule is when the Node is combined with a blending mode and blend effect in which case a translucent Node may still have an impact in rendering

An opacity of 50% will render the node as being 50% transparent.

A visible node with any opacity setting still receives mouse events and can receive keyboard focus.

For example, if you want to have a large invisible rectangle overlay all Nodes in the scene graph in order to intercept mouse events but not be visible to the user, you could create a large Rectangle that had an opacity of 0%.

Opacity is specified as a value between 0 and 1. Values less than 0 are treated as 0, values greater than 1 are treated as 1.

On some platforms ImageView might not support opacity variable.

There is a known limitation of mixing opacity < 1.0 with a 3D Transform. Opacity/Blending is essentially a 2D image operation

The result of an opacity < 1.0 set on a Idx node with 3D transformed children will cause its children to be rendered in order without Z-buffering applied between those children

Parent

Returns node Parent

If this node has not been added to a scene graph, then option will be void

Pressed

Whether or not the Node is pressed

Typically this is true when the primary mouse button is down, though subclasses may define other mouse button state or key state to cause the node to be "pressed"

Mutable pseudo-class states

Adding/Removing pseudo-class states from this collection, will trigger re-application of CSS

JavaFX peer

Returns the real JavaFX peer, which makes GUI happen

JavaFx controls can be manipulated directly, especially for functionality not implemented in ScalqaFx

Resize and move

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

Once the node has been resized (if resizable) then sets the node's layoutX and layoutY translation properties in order to relocate it to x,y in the parent's coordinate space

This method should generally only be called by parent nodes from their layoutChildren() methods. All Parent classes will automatically resize resizable children, so resizing done directly by the application will be overridden by the node's parent, unless the child is unmanaged

Parents are responsible for ensuring the width and height values fall within the resizable node's preferred range. The autosize() and relocate() methods may be used if the parent just needs to resize the node to its preferred size and permutation it

Rotate

Defines the angle of rotation about the Node's center, measured in degrees. This is used to rotate the Node

This rotation factor is not included in layoutBounds by default, which makes it ideal for rotating the entire node after all effects and transforms have been taken into account

The pivot point about which the rotation occurs is the center of the untransformed layoutBounds

Note that because the pivot point is computed as the center of this Node's layout bounds, any change to the layout bounds will cause the pivot point to change, which can move the object

For a leaf node, any change to the Geometry will cause the layout bounds to change

For a group node, any change to any of its children, including a change in a child's Geometry, clip, effect, position, orientation, or scale, will cause the group's layout bounds to change

If this movement of the pivot point is not desired, applications should instead use the Node's transforms ObservableList, and add a Rotate transform, which has a user-specifiable pivot point

Scale x

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

This is used to stretch or animate the node either manually or by using an animation

This scale factor is not included in layoutBounds by default, which makes it ideal for scaling the entire node after all effects and transforms have been taken into account

The pivot point about which the scale occurs is the center of the untransformed layoutBounds

Scale y

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

This is used to stretch or animate the node either manually or by using an animation

This scale factor is not included in layoutBounds by default, which makes it ideal for scaling the entire node after all effects and transforms have been taken into account

The pivot point about which the scale occurs is the center of the untransformed layoutBounds

Scale z

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

This is used to stretch or animate the node either manually or by using an animation

This scale factor is not included in layoutBounds by default, which makes it ideal for scaling the entire node after all effects and transforms have been taken into account

The pivot point about which the scale occurs is the center of the rectangular bounds formed by taking boundsInLocal and applying all the transforms in the transforms ObservableList.

Note that this is a conditional feature. See ConditionalFeature.SCENE3D for more information.

Scene

Returns node Scene

If the node is not part of a scene, then scene will be null

Mutable styles

An index collection of Style.Class which can be used to logically group Nodes, specifically for an external style engine

This variable is analogous to the "class" attribute on an HTML element and, as such, each element of the list is a style class to which this Node belongs

Style

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

This is analogous to the "style" attribute of an HTML element

Note that, like the HTML style attribute, this variable contains style properties and values and not the selector portion of a style rule

Translate x

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

The node's final translation will be computed as layoutX + translateX, where layoutX establishes the node's stable position and translateX optionally makes dynamic adjustments to that position

This variable can be used to alter the location of a node without disturbing its layoutBounds, which makes it useful for animating a node's location

Translate y

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

The node's final translation will be computed as layoutY + translateY, where layoutY establishes the node's stable position and translateY optionally makes dynamic adjustments to that position

This variable can be used to alter the location of a node without disturbing its layoutBounds, which makes it useful for animating a node's location

Translate z

Defines the Z coordinate of the translation that is added to the transformed coordinates of this Node. This value will be added to any translation defined by the transforms ObservableList and layoutZ

This variable can be used to alter the location of a Node without disturbing its layout bounds, which makes it useful for animating a node's location

Note that this is a conditional feature. See ConditionalFeature.SCENE3D for more information

On context menu

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

Visible

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

A node may be visible and yet not be shown in the rendered scene if, for instance, it is off the screen or obscured by another Node

Invisible nodes never receive mouse events or keyboard focus and never maintain keyboard focus when they become invisible