Base class for scene graph nodes. A scene graph is a tree-like data structure
where each item in the tree 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.
(More technically, the scene graph is a directed acyclic graph).

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,
its clip and effect variables (if set).

The layoutBounds variable defines the rectangular bounds of a
Node that should be used as the basis for layout calculations. By
default this will be equal to boundsInLocal plus transforms set
in the transforms variable but does NOT include transforms set by
the explicit translateX, translateY, scaleX,
scaleY, and rotate variables.

Finally, 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,
translateX, translateY, scaleX, scaleY,
and rotate. It is called "boundsInParent" because the rectangle
will be defined in terms of the parent Node's coordinate system.

If true, consumes mouse events in this Node and does not send
them to other nodes further up the scene graph.

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.

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

The rectangular bounds of this Node in the Node's
untransformed local coordinate space. For nodes that extend
javafx.scene.shape.Shape, the local bounds will also include
space required for a non-zero stroke that may fall outside the shape's
geometry that is defined by position and size attributes.
The local bounds will also include any clipping set with clip
as well as effects set with effect.

Note that this method does not take the node's visibility into account;
the test is based on the geometry of this Node only.

This variable will always be a non-null value.

Note that boundsInLocal is automatically recomputed whenever the
geometry of a node changes. For this reason, it is an error to bind any
of these values in a node
to an expression that depends upon this variable. For example, you
should not bind the "x" or "y" variables of a shape to boundsInLocal
for the purpose of positioning the node.

The rectangular bounds of this Node which include its transforms.
boundsInParent is calculated by
taking its local bounds (defined by boundsInLocal) and applying
the transform created by setting the following additional variables:

The resulting bounds will be conceptually in the coordinate space of the
Node's parent, however the node need not have a parent to calculate
these bounds.

Note that this method does not take the node's visibility into account;
the test is based on the geometry of this Node only.

This variable will always be a non-null value.

Note that boundsInParent is automatically recomputed whenever the
geometry of a node changes, or when any of the following change: the
transforms sequence, the translateX, translateY, scaleX, scaleY, or
rotate variable. For this reason, it is an error to bind any of these
values in a node
to an expression that depends upon this variable. For example, you
should not bind the "x", "y", translateX, or translateY variables of a shape to
boundsInParent for the purpose of positioning the node.

The rectangular bounds of this Node in the coordinate space of
the javafx.scene.Scene containing the Node.

The rectangular bounds of this Node in the coordinate space of
the javafx.scene.Scene containing the Node. The bounds will include
accummulated transforms of all ancestor nodes. If the Node is not
currently contained in a scene, returns the bounds in the coordinate
space of the topmost ancestor in the scene graph.

Note that this method does not take the node's visibility into account;
the test is based on the geometry of this Node only.

This variable will always be a non-null value.

Note that boundsInScene is automatically recomputed whenever any
transform in any ancestor group node changes, or when the
geometry of a node changes, or when any of the following change: the
transforms sequence, the translateX, translateY, scaleX, scaleY, or
rotate variable. For this reason, it is an error to bind any of these
values in a node
to an expression that depends upon this variable. For example, you
should not bind the "x", "y", translateX, or translateY variables of a shape to
boundsInScene for the purpose of positioning the node.

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

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.

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.

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.

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 not respond to input and ideally 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.

Specifies whether this Node should accept input focus. Even if
this is true, it is possible that the Node will not
receive focus. For example, a node may be focusable, but visible
is false and thus it cannot receive focus. Focusable is
simply a way for the application to indicate
that a specific node may be allowed to be focused. Nodes that don't
want input focus should set this variable to false.

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.

The rectangular bounds that should be used in calculations for both manual
and automatic layout of this Node.

The rectangular bounds that should be used in calculations for both manual
and automatic layout of this Node. By default, layoutBounds
is calculated by taking the local bounds of Node (defined by
boundsInLocal) and applying the transform created by setting
the transforms[] sequence.

Note that the translateX and translateY variables are not
included in the layoutBounds by default. This is important because
layout code must first determine the current size and location of the
Node (using layoutBounds) and then set translateX and
translateY to adjust the translation of the Node so that
it will have the desired layout position (if translateX and
translateY were included in layoutBounds
then they could not be used for such positioning since it would cause a
circular definition -- every time translateX was changed
it would cause layoutBounds to change, which would recompute translateX!)

Note that the default layoutBounds is automatically recomputed whenever the
geometry of a node changes, or when the transforms sequence changes.
For this reason, it is an error to bind any of these values in a node
to an expression that depends upon this variable. For example, you
should not bind the "x" or "y" variables of a shape to
layoutBounds for the purpose of positioning the node.

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 ZNode 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 one are clipped to 0 and 1 respectively.

The parent of this Node. If this Node has not been added to a
scene graph, then parent will be null. If null, then boundsInParent
and boundsInScene will both return the same value (the
transformed bounds of the node).

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

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
rectangular bounds formed by taking boundsInLocal and applying
all the transforms in the transforms[] sequence.

Note that the center of this Node is defined as the center of
the transformed bounding box as described above. Because the bounding box
is used to compute the pivot point, any change to the Node's
bounds will cause the pivot point to change, which can move the
object. For a leaf node, applying a clip or otherwise changing the
visible geometry will cause the bounds to be reevaluated. For a
group node, a similar change to any of its children, including a
change in a child's position, orientation, or scale, will cause the
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.

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

Defines the X coordinate of the translation that is added to the
transformed coordinates of this Node. This variable should be
used to position the Node by setting it to a value that adjusts
its x position relative to layoutBounds.minX.

For example, if mynode should have a final location of
finalX:

mynode.translateX = finalX - mynode.layoutBounds.minX;

This variable can also be used to animate the position of the node.

This translation factor is not included in layoutBounds by
default, which makes it ideal for moving the entire node around after
all effects and transforms are taken into account.

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

Defines the Y coordinate of the translation that is added to the
transformed coordinates of this Node. This variable should be
used to position the Node by setting it to a value that adjusts
its y position relative to layoutBounds.minY.

For example, if mynode should have a final location of
finalY:

mynode.translateY = finalY - mynode.layoutBounds.minY;

This variable can also be used to animate the position of the node.

This translation factor is not included in layoutBounds by
default, which makes it ideal for moving the entire node around after
all effects and transforms are taken into account.

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

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.

Inherited Variables

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

Returns true if the given point (specified in the local
coordinate space of this Node) is contained within the shape of
this Node. Note that this method does not take visibility into
account; the test is based on the geometry of this Node only.
The default behavior of this function is simply to check if the
given coordinates are contained in the local bounds.

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

Returns true if the given point (specified in the local
coordinate space of this Node) is contained within the shape of
this Node. Note that this method does not take visibility into
account; the test is based on the geometry of this Node only.
The default behavior of this function is simply to check if the
given coordinates are contained in the local bounds.

Creates the Scenario SGNode which backs this Node. This function will
be invoked before the Node class has finished initialization, and thus
need to be written wuch that it doesn't reference state that has not yet
been set.

Set the impl_needsLayout variable of every ancestor of this Node.
If this Node is a Group/CustomNode then set its impl_needsLayout
variable as well. We short-circuit when we find a node
who's impl_needsLayout bit is already set.

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

Returns true if the given rectangle (specified in the local
coordinate space of this Node) intersects the shape of this
Node. Note that this method does not take visibility into
account; the test is based on the geometry of this Node only.
The default behavior of this function is simply to check if the
given coordinates intersect with the local bounds.

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

Returns true if the given rectangle (specified in the local
coordinate space of this Node) intersects the shape of this
Node. Note that this method does not take visibility into
account; the test is based on the geometry of this Node only.
The default behavior of this function is simply to check if the
given coordinates intersect with the local bounds.

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

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

Parameters

parentPoint

Returns

Point2D

Profile: common

&nbsp;

publicrequestFocus()
:
Void

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

Requests that this Node get the input focus, and that this
Node's top-level ancestor become the focused Window. If this
node is not part of a scene graph rooted in a stage that is visible and
can accept input focus, then calls to
request focus will not cause this Node to become focused.

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

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

Parameters

scenePoint

Returns

Point2D

Profile: common

&nbsp;

publictoBack()
:
Void

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

Moves this Node to the back of its sibling nodes in terms of
z-order. This is accomplished by moving this Node to the
first position in its parent's content sequence.
This function has no effect if this Node is not part of a group.

Profile: common

&nbsp;

publictoFront()
:
Void

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

Moves this Node to the front of its sibling nodes in terms of
z-order. This is accomplished by moving this Node to the
last position in its parent's content sequence.
This function has no effect if this Node is not part of a group.