Node

Overview

Base class for scene graph nodes. A scene graph is a set of tree data structures where every item has zero or one parent, and each item is either a "leaf" with zero sub-items or a "branch" with zero or more sub-items.

Each item in the scene graph is called a Node. Branch nodes are either of type Group or of type CustomNode, or subclasses thereof. Leaf nodes are classes such as javafx.scene.shape.Rectangle, javafx.scene.text.Text, javafx.scene.image.ImageView, javafx.scene.media.MediaView, or other such leaf nodes. Only a single node within each scene graph tree will have no parent, which is often referred to as the "root" node.

There may be several trees in the scene graph. Some trees may be part of a Scene, in which case they are eligible to be displayed. Other trees might not part of any Scene.

A node may occur at most once anywhere in the scene graph. Specifically, a node must appear no more than once in all of the following: in the content sequence of a Group, in the content sequence of a Scene, in the children sequence of a Parent, or as the clip of a Node. Note that the return value of the create function of a CustomNode subclass is added to the children sequence of that CustomNode, and as such, is subject to these restrictions.

The scene graph must not have cycles. A cycle would exist if a node is an ancestor of itself in the tree, considering the Group content sequence, Parent children sequence, and Node clip relationships mentioned above.

If a program adds a child node to a Parent (including Group and CustomNode) or Scene, and that node is already a child of a different Parent or Scene, the node is automatically (and silently) removed from its former parent. If a program attempts to modify the scene graph in any other way that violates the above rules, an exception is thrown, the modification attempt is ignored and the scene graph is restored to its previous state.

It is possible to rearrange the structure of the scene graph, for example, to move a subtree from one location in the scene graph to another. In order to do this, one would normally remove the subtree from its old location before inserting it at the new location. However, the subtree will be automatically removed as described above if the application doesn't explicitly remove it.

String ID

Each node in the scene graph can be given a unique #id. This id is much like the "id" attribute of an HTML tag in that it is up to the designer and developer to ensure that the id is unique within the scene graph. A convenience function called #lookup(String) can be used to find a node with a unique id within the scene graph, or within a subtree of the scene graph.

Coordinate System

The Node class defines a traditional computer graphics "local" coordinate system in which the x axis increases to the right and the y axis increases downwards. The concrete node classes for shapes provide variables for configuring the geometry and location of the shape within this local coordinate space. For example, javafx.scene.shape.Rectangle provides x, y, width, height variables while javafx.scene.shape.Circle provides centerX, centerY, and radius.

Transformations

Any Node can have transformations applied to it. These include translation, rotation, scaling, or shearing transformations.

A translation transformation is one which shifts the origin of the node's coordinate space along either the x or y axis. For example, if you create a javafx.scene.shape.Rectangle which is drawn at the origin (x=0, y=0) and has a width of 100 and a height of 50, and then apply a javafx.scene.transform.Translate with a shift of 10 along the x axis (x=10), then the rectangle will appear drawn at (x=10, y=0) and remain 100 points wide and 50 tall. Note that the origin was shifted, not the x variable of the rectangle.

A rotation transformation is one which rotates the coordinate space of the node about a specified "pivot" point, causing the node to appear rotated. For example, if you create a javafx.scene.shape.Rectangle which is drawn at the origin (x=0, y=0) and has a width of 100 and height of 30 and you apply a javafx.scene.transform.Rotate with a 90 degree rotation (angle=90) and a pivot at the origin (pivotX=0, pivotY=0), then the rectangle will be drawn as if its x and y were zero but its height was 100 and its width -30. That is, it is as if a pin is being stuck at the top left corner and the rectangle is rotating 90 degrees clockwise around that pin. If the pivot point is instead placed in the center of the rectangle (at point x=50, y=15) then the rectangle will instead appear to rotate about its center.

Note that as with all transformations, the x, y, width, and height variables of the rectangle (which remain relative to the local coordinate space) have not changed, but rather the transformation alters the entire coordinate space of the rectangle.

A scaling transformation causes a node to either appear larger or smaller depending on the scaling factor. Scaling alters the coordinate space of the node such that each unit of distance along the axis in local coordinates is multipled by the scale factor. As with rotation transformations, scaling transformations are applied about a "pivot" point. You can think of this as the point in the Node around which you "zoom". For example, if you create a javafx.scene.shape.Rectangle with a strokeWidth of 5, and a width and height of 50, and you apply a javafx.scene.transform.Scale with scale factors (x=2.0, y=2.0) and a pivot at the origin (pivotX=0, pivotY=0), the entire rectangle (including the stroke) will double in size, growing to the right and downwards from the origin.

A shearing transformation, sometimes called a skew, effectively rotates one axis so that the x and y axes are no longer perpendicular.

Multiple transformations may be applied to a node by specifying an ordered chain of transforms. The order in which the transforms are applied is defined by the sequence specified in the #transforms variable.

Bounding Rectangles

Since every Node has transformations, every Node's geometric bounding rectangle that can be described differently depending on whether transformations are accounted for or not.

At the simplest, Node's have a read-only #boundsInLocal variable which specifies the bounding rectangle of the Node in untransformed local coordinates. boundsInLocal includes the Node's shape geometry, including any space required for a non-zero stroke that may fall outside the local position/size variables, and its #clip and #effect variables.

Each Node also has a read-only #boundsInParent variable which specifies the bounding rectangle of the Node after all transformations have been applied, including those set in #transforms, #scaleX/#scaleY, #rotate, #translateX/#translateY, and #layoutX/#layoutY. It is called "boundsInParent" because the rectangle will be relative to the parent's coordinate system.

Finally, the #layoutBounds variable defines the rectangular bounds of the Node that should be used as the basis for layout calculations. By default this includes only the shape geometry, including space required for a non-zero strokeWidth, but does not include the effect, clip, or any transforms.

Profile: common

Variable Summary

name	type	Default Value	description
id	String		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 much like the "id" attribute of an HTML element.
styleClass	String		A String identifier which can be used to logically group Nodes, specifically for an external style engine. This variable is exactly analogous to the styleClass attribute on an HTML element.
style	String		A string representation of the CSS style associated with this specific Node. This is exactly analogous to the "style" attribute on an HTML element, but uses the syntax defined in JavaFX CSS.
visible	Boolean	true	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.
cursor	Cursor	null	Defines the mouse cursor for this `Node` and subnodes. If null, then the cursor of the first parent node with a non-null cursor will be used. If no Node in the scene graph defines a cursor, then the cursor of the `Scene` will be used.
opacity	Number	1.0	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 Z `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 or greater than 1 are clipped to 0 and 1 respectively. On some platforms ImageView might not support opacity variable.
clip	Node	null	Specifies a `Node` to use to define the the clipping shape for this Node. This clipping Node is not a child of this `Node` in the scene graph sense. Rather, it is used to define the clip for this `Node`. For example, you can use an javafx.scene.image.ImageView Node as a mask to represent the Clip. Or you could use one of the geometric shape Nodes such as javafx.scene.shape.Rectangle or javafx.scene.shape.Circle. Or you could use a javafx.scene.text.Text node to represent the Clip. See the class documentation for Node for scene graph structure restrictions on setting the clip. If these restrictions are violated by a change to the clip variable, the change is ignored and the previous value of the clip variable is restored. Note: this is a conditional feature. See javafx.runtime.ConditionalFeature#SHAPE_CLIP ConditionalFeature.SHAPE_CLIP for more information.
cache	Boolean	false	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 `cacheHint` variable provides additional options for enabling more aggressive bitmap caching.
cacheHint	CacheHint	CacheHint.DEFAULT	Additional hint for controlling bitmap caching. Under certain circumstances, such as animating nodes that are very expensive to render, it is desirable to be able to perform transformations on the node without having to regenerate the cached bitmap. An option in such cases is to perform the transforms on the cached bitmap itself. This technique can provide a dramatic improvement to animation performance, though may also result in a reduction in visual quality. The `cacheHint` variable provides a hint to the system about how and when that trade-off (visual quality for animation performance) is acceptable. It is possible to enable the cacheHint only at times when your node is animating. In this way, expensive nodes can appear on screen with full visual quality, yet still animate smoothly. Example: `expensiveNode.cache = true; expensiveNode.cacheHint = CacheHint.QUALITY; ... // Do an animation expensiveNode.cacheHint = CacheHint.SPEED; Timeline { keyFrames: [ KeyFrame { time: 2s values: [ expensiveNode.scaleX => 2.0, expensiveNode.scaleY => 2.0, expensiveNode.rotate=> 360, expensiveNode.cacheHint => CacheHint.QUALITY ] } ] }.play();` Note that `cacheHint` is only a hint to the system. Depending on the details of the node or the transform, this hint may be ignored. If `Node.cache` is false, cacheHint is ignored.
effect	Effect	null	Specifies an effect to apply to this `Node`. Note: this is a conditional feature. See javafx.runtime.ConditionalFeature#EFFECT ConditionalFeature.EFFECT for more information.
disable	Boolean	false	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`.
pickOnBounds	Boolean	false	Defines how the picking computation is done for this node when triggered by a `MouseEvent` or a `contains` function call. If `pickOnBounds` is true, then picking is computed by intersecting with the bounds of this node, else picking is computed by intersecting with the geometric shape of this node.
managed	Boolean	true	Defines whether or not this node's layout will be managed by it's parent. Each parent class follows a strategy for laying out managed children during the scene's layout pass: Group: sets the size of any `Resizable` children to their preferred size; does not alter the size of non-Resizable children; does not position children. Container: sets the size of any `Resizable` content according to its layout rules and each node's layoutInfo; does not alter the size of non-Resizable content; will position nodes (setting `layoutX/layoutY` according to its layout rules. CustomNode: by default it behaves like Group, however its layout behavior may be overridden by a subclass. Parents will ignore unmanaged children for the purposes of layout and it is the application's responsibility to set the size and position of an unmanaged node. By default all nodes are managed. If a `Parent` node is unmanaged, then it will act as a root for layout, which means that layout requests beneath it will cause only the branch rooted by this node to be relayed out.
layoutX	Number	0	Defines the X coordinate of the translation that is added to the transformed coordinates of this `Node` for the purpose of layout. Containers or Groups performing layout will set this variable relative to `layoutBounds.minX` in order to position the node at the desired layout location. For example, if `child` should have a final location of `finalX`: `child.layoutX = finalX - child.layoutBounds.minX;`
layoutY	Number	0	Defines the Y coordinate of the translation that is added to the transformed coordinates of this `Node` for the purpose of layout. Containers or Groups performing layout will set this variable relative to `layoutBounds.minY` in order to position the node at the desired layout location. For example, if `child` should have a final location of `finalY`: `child.layoutY = finalY - child.layoutBounds.minY;`
layoutInfo	LayoutInfoBase		Hook for node-specific layout information used by layout containers. If the node is not a child of a container which supports layout info, this variable will be ignored. Note that layoutInfo object literals may be shared across nodes, which means altering the vars in layoutInfo will affect all such nodes.
transforms	Transform	[]	Defines the sequence of javafx.scene.transform.Transform objects to be applied to this `Node`. This sequence of transforms is applied before #translateX, #translateY, #scaleX, and #scaleY, #rotate transforms. By default, #layoutBounds is defined as the local bounds with all the transforms in this sequence applied.
translateX	Number	0	Defines the X 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` sequence and `layoutX`. 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.
translateY	Number	0	Defines the Y 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` sequence and `layoutY`. 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.
translateZ	Number	0	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` sequence 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: this is a conditional feature. See javafx.runtime.ConditionalFeature#SCENE3D ConditionalFeature.SCENE3D for more information.
scaleX	Number	1.0	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.
scaleY	Number	1.0	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.
scaleZ	Number	1.0	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[] sequence. Note: this is a conditional feature. See javafx.runtime.ConditionalFeature#SCENE3D ConditionalFeature.SCENE3D for more information.
rotate	Number	0.0	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[] sequence, and add a javafx.scene.transform.Rotate transform, which has a user-specifiable pivot point.
rotationAxis	Point3D	Rotate.Z_AXIS	Defines the axis of rotation of this `Node`. Note: this is a conditional feature. See javafx.runtime.ConditionalFeature#SCENE3D ConditionalFeature.SCENE3D for more information.
blocksMouse	Boolean	false	If `true`, consumes mouse events in this `Node` and does not send them to other nodes further up the scene graph. If a Node wants to block mouse events from going to nodes which are visually obscured by this `Node`, then set blocksMouse to true.
focusTraversable	Boolean	false	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()`.

Products and Services

Solutions

Downloads

Store

Support

Training

Partners

About

Oracle Technology Network

Profile: desktop, common

String ID

Coordinate System

Transformations

Bounding Rectangles

Oracle Cloud

Java

Customer and Events

Communities

Services and Store

Contact and Chat