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
of type Parent, whose concrete subclasses are Group,
Region, and Control,
or subclasses thereof.

Leaf nodes are classes such as
Rectangle, Text,
ImageView, MediaView,
or other such leaf classes which cannot have children. Only a single node within
each scene graph tree will have no parent, which is 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 be 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:
as the root node of a Scene,
the children ObservableList of a Parent,
or as the clip of a Node.

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
ObservableList, Parent children ObservableList, and Node clip relationships
mentioned above.

If a program adds a child node to a Parent (including Group, Region, etc)
and that node is already a child of a different Parent or the root of a 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.

Node objects may be constructed and modified on any thread as long they are
not yet attached to a Scene in a Window that is showing.
An application must attach nodes to such a Scene or modify them on the JavaFX
Application Thread.

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. The id can also be used identify nodes for applying styles; see
the CSS section below.

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 defining the geometry and location of the shape
within this local coordinate space. For example,
Rectangle provides x, y,
width, height variables while
Circle provides centerX, centerY,
and radius.

At the device pixel level, integer coordinates map onto the corners and
cracks between the pixels and the centers of the pixels appear at the
midpoints between integer pixel locations. Because all coordinate values
are specified with floating point numbers, coordinates can precisely
point to these corners (when the floating point values have exact integer
values) or to any location on the pixel. For example, a coordinate of
(0.5, 0.5) would point to the center of the upper left pixel on the
Stage. Similarly, a rectangle at (0, 0) with dimensions
of 10 by 10 would span from the upper left corner of the
upper left pixel on the Stage to the lower right corner of the
10th pixel on the 10th scanline. The pixel center of the last pixel
inside that rectangle would be at the coordinates (9.5, 9.5).

In practice, most nodes have transformations applied to their coordinate
system as mentioned below. As a result, the information above describing
the alignment of device coordinates to the pixel grid is relative to
the transformed coordinates, not the local coordinates of the nodes.
The Shape class describes some additional
important context-specific information about coordinate mapping and how
it can affect rendering.

Transformations

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

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 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
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 common node transform is a translation by an integer distance, most often
used to lay out nodes on the stage. Such integer translations maintain the
device pixel mapping so that local coordinates that are integers still
map to the cracks between pixels.

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 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 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 Rectangle with a
strokeWidth of 5, and a width and height of 50, and you apply a
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 ObservableList specified in the transforms variable.

Bounding Rectangles

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

Each Node has 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. This is the 'visual' bounds of the node.

Finally, the layoutBounds variable defines the rectangular bounds of
the Node that should be used as the basis for layout calculations and
may differ from the visual bounds of the node. For shapes, Text, and ImageView,
layoutBounds by default includes only the shape geometry, including space required
for a non-zero strokeWidth, but does not include the effect,
clip, or any transforms. For resizable classes (Regions and Controls)
layoutBounds will always map to 0,0 width x height.

The image shows a node without any transformation and its boundsInLocal:

If we rotate the image by 20 degrees we get following result:

The red rectangle represents boundsInParent in the
coordinate space of the Node's parent. The boundsInLocal stays the same
as in the first image, the green rectangle in this image represents boundsInLocal
in the coordinate space of the Node.

The images show a filled and stroked rectangle and their bounds. The
first rectangle [x:10.0 y:10.0 width:100.0 height:100.0 strokeWidth:0]
has the following bounds bounds: [x:10.0 y:10.0 width:100.0 height:100.0].
The second rectangle [x:10.0 y:10.0 width:100.0 height:100.0 strokeWidth:5]
has the following bounds: [x:7.5 y:7.5 width:105 height:105]
(the stroke is centered by default, so only half of it is outside
of the original bounds; it is also possible to create inside or outside
stroke).
Since neither of the rectangles has any transformation applied,
boundsInParent and boundsInLocal are the same.

CSS

The Node class contains id, styleClass, and
style variables that are used in styling this node from
CSS. The id and styleClass variables are used in
CSS style sheets to identify nodes to which styles should be
applied. The style variable contains style properties and
values that are applied directly to this node.

For further information about CSS and how to apply CSS styles
to nodes, see the CSS Reference
Guide.

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 lookup method can
be used to find this node as follows: scene.lookup("#myId");.

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.

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.

cursor

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

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 Group node with 3D transformed children
will cause its children to be rendered in order without Z-buffering
applied between those children.

blendMode

The BlendMode used to blend this individual node
into the scene behind it. If this node happens to be a Group then all of the
children will be composited individually into a temporary buffer using their
own blend modes and then that temporary buffer will be composited into the
scene using the specified blend mode.
A value of null is treated as pass-though this means no effect on a
parent such as a Group and the equivalent of SRC_OVER for a single Node.

clip

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 ImageView Node as
a mask to represent the Clip. Or you could use one of the geometric shape
Nodes such as Rectangle or
Circle. Or you could use a
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.

There is a known limitation of mixing Clip with a 3D Transform.
Clipping is essentially a 2D image operation. The result of
a Clip set on a Group node with 3D transformed children
will cause its children to be rendered in order without Z-buffering
applied between those children.

cache

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.

cacheHint

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.setCache(true);
expensiveNode.setCacheHint(CacheHint.QUALITY);
...
// Do an animation
expensiveNode.setCacheHint(CacheHint.SPEED);
new Timeline(
new KeyFrame(Duration.seconds(2),
new KeyValue(expensiveNode.scaleXProperty(), 2.0),
new KeyValue(expensiveNode.scaleYProperty(), 2.0),
new KeyValue(expensiveNode.rotateProperty(), 360),
new KeyValue(expensiveNode.cacheHintProperty(), 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.
Caching may be disabled for any node that has a 3D transform on itself,
any of its ancestors, or any of its descendants.

effect

There is a known limitation of mixing Effect with a 3D Transform. Effect is
essentially a 2D image operation. The result of an Effect set on
a Group node with 3D transformed children will cause its children
to be rendered in order without Z-buffering applied between those
children.

depthTest

Indicates whether depth testing is used when rendering this node.
If the depthTest flag is DepthTest.DISABLE, then depth testing
is disabled for this node.
If the depthTest flag is DepthTest.ENABLE, then depth testing
is enabled for this node.
If the depthTest flag is DepthTest.INHERIT, then depth testing
is enabled for this node if it is enabled for the parent node or the
parent node is null.

The depthTest flag is only used when the depthBuffer flag for
the Scene is true (meaning that the
Scene has an associated depth buffer)

Depth test comparison is only done among nodes with depthTest enabled.
A node with depthTest disabled does not read, test, or write the depth buffer,
that is to say its Z value will not be considered for depth testing
with other nodes.

disable

Defines the individual disabled state of this Node. Setting
disable to true will cause this Node and any subnodes to
become disabled. This property should be used only to set the disabled
state of a Node. For querying the disabled state of a
Node, the disabled property 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

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.

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.

onDragDone

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.

managed

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.

layoutX

Defines the x coordinate of the translation that is added to this Node's
transform for the purpose of layout. The value should be computed as the
offset required to adjust the position of the node from its current
layoutBounds minX position (which might not be 0) to the desired location.

For example, if textnode should be positioned at finalX

textnode.setLayoutX(finalX - textnode.getLayoutBounds().getMinX());

Failure to subtract layoutBounds minX may result in misplacement
of the node. The relocate(x, y) method will automatically do the
correct computation and should generally be used over setting layoutX directly.

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.

If the node is managed and has a Region
as its parent, then the layout region will set layoutX according to its
own layout policy. If the node is unmanaged or parented by a Group,
then the application may set layoutX directly to position it.

layoutY

Defines the y coordinate of the translation that is added to this Node's
transform for the purpose of layout. The value should be computed as the
offset required to adjust the position of the node from its current
layoutBounds minY position (which might not be 0) to the desired location.

For example, if textnode should be positioned at finalY

textnode.setLayoutY(finalY - textnode.getLayoutBounds().getMinY());

Failure to subtract layoutBounds minY may result in misplacement
of the node. The relocate(x, y) method will automatically do the
correct computation and should generally be used over setting layoutY directly.

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.

If the node is managed and has a Region
as its parent, then the region will set layoutY according to its
own layout policy. If the node is unmanaged or parented by a Group,
then the application may set layoutY directly to position it.

boundsInParent

The rectangular bounds of this Node which include its transforms.
boundsInParent is calculated by
taking the 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 computation is based on the geometry of this Node only.

This property will always have a non-null value.

Note that boundsInParent is automatically recomputed whenever the
geometry of a node changes, or when any of the following the change:
transforms ObservableList, translateX, translateY, layoutX, layoutY,
scaleX, scaleY, or the 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, the x or y variables of a shape, or
translateX, translateY should never be bound to boundsInParent
for the purpose of positioning the node.

boundsInLocal

The rectangular bounds of this Node in the node's
untransformed local coordinate space. For nodes that extend
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 computation is based on the geometry of this Node only.

This property will always have 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, the x or y variables of a shape should never be bound
to boundsInLocal for the purpose of positioning the node.

layoutBounds

The rectangular bounds that should be used for layout calculations for
this node. layoutBounds may differ from the visual bounds
of the node and is computed differently depending on the node type.

If the node type is resizable (Region,
Control, or WebView)
then the layoutBounds will always be 0,0 width x height.
If the node type is not resizable (Shape,
Text, or Group), then the layoutBounds
are computed based on the node's geometric properties and does not include the
node's clip, effect, or transforms. See individual class documentation
for details.

Note that the layoutX, layoutY, translateX, and
translateY variables are not included in the layoutBounds.
This is important because layout code must first determine the current
size and location of the node (using layoutBounds) and then set
layoutX and layoutY to adjust the translation of the
node so that it will have the desired layout position.

Because the computation of layoutBounds is often tied to a node's
geometric variables, it is an error to bind any such variables to an
expression that depends upon layoutBounds. For example, the
x or y variables of a shape should never be bound to layoutBounds
for the purpose of positioning the node.

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.

localToSceneTransform

An affine transform that holds the computed local-to-scene transform.
This is the concatenation of all transforms in this node's parents and
in this node, including all of the convenience transforms up to the root.
If this node is in a SubScene, this property represents
transforms up to the subscene, not the root scene.

Note that when you register a listener or a binding to this property,
it needs to listen for invalidation on all its parents to the root node.
This means that registering a listener on this
property on many nodes may negatively affect performance of
transformation changes in their common parents.

nodeOrientation

Node orientation describes the flow of visual data within a node.
In the English speaking world, visual data normally flows from
left-to-right. In an Arabic or Hebrew world, visual data flows
from right-to-left. This is consistent with the reading order
of text in both worlds. The default value is left-to-right.

mouseTransparent

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.

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.

onKeyPressed

Defines a function to be called when this Node or its child
Node has input focus and a key has been pressed. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

onKeyReleased

Defines a function to be called when this Node or its child
Node has input focus and a key has been released. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

onKeyTyped

Defines a function to be called when this Node or its child
Node has input focus and a key has been typed. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

onInputMethodTextChanged

Defines a function to be called when this Node
has input focus and the input method text has changed. If this
function is not defined in this Node, then it
receives the result string of the input method composition as a
series of onKeyTyped function calls.
When the Node loses the input focus, the JavaFX runtime
automatically commits the existing composed text if any.

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.

focusTraversable

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

eventDispatcher

Specifies the event dispatcher for this node. The default event
dispatcher sends the received events to the registered event handlers and
filters. When replacing the value with a new EventDispatcher,
the new dispatcher should forward events to the replaced dispatcher
to maintain the node's default event handling behavior.

accessibleRoleDescription

Noramlly, when a role is provided for a node, the screen reader
speaks the role as well as the contents of the node. When this
value is set, it is possbile to override the default. This is
useful because the set of roles is predefined. For example,
it is possible to set the role of a node to be a button, but
have the role description be arbitrary text.

accessibleText

This property is used to set the text that the screen
reader will speak. If a node normally speaks text,
that text is overriden. For example, a button
usually speaks using the text in the control but will
no longer do this when this value is set.

hasProperties

setUserData

Convenience method for setting a single Object property that can be
retrieved at a later date. This is functionally equivalent to calling
the getProperties().put(Object key, Object value) method. This can later
be retrieved by calling getUserData().

Parameters:

value - The value to be stored - this can later be retrieved by calling
getUserData().

setId

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 lookup method can
be used to find this node as follows: scene.lookup("#myId");.

Default value:

null

getId

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

idProperty

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 lookup method can
be used to find this node as follows: scene.lookup("#myId");.

getStyleClass

A list of String identifiers 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.

setStyle

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.

Default value:

empty string

Parameters:

value - The inline CSS style to use for this Node.
null is implicitly converted to an empty String.

getStyle

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.

styleProperty

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.

setVisible

public final void setVisible(boolean value)

Sets the value of the property visible.

Property description:

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.

Default value:

true

isVisible

public final boolean isVisible()

Gets the value of the property visible.

Property description:

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.

Default value:

true

visibleProperty

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.

setCursor

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.

Default value:

null

getCursor

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.

Default value:

null

cursorProperty

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.

setOpacity

public final void setOpacity(double value)

Sets the value of the property opacity.

Property description:

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 Group node with 3D transformed children
will cause its children to be rendered in order without Z-buffering
applied between those children.

Default value:

1.0

getOpacity

public final double getOpacity()

Gets the value of the property opacity.

Property description:

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 Group node with 3D transformed children
will cause its children to be rendered in order without Z-buffering
applied between those children.

Default value:

1.0

opacityProperty

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 Group node with 3D transformed children
will cause its children to be rendered in order without Z-buffering
applied between those children.

setBlendMode

The BlendMode used to blend this individual node
into the scene behind it. If this node happens to be a Group then all of the
children will be composited individually into a temporary buffer using their
own blend modes and then that temporary buffer will be composited into the
scene using the specified blend mode.
A value of null is treated as pass-though this means no effect on a
parent such as a Group and the equivalent of SRC_OVER for a single Node.

Default value:

null

getBlendMode

The BlendMode used to blend this individual node
into the scene behind it. If this node happens to be a Group then all of the
children will be composited individually into a temporary buffer using their
own blend modes and then that temporary buffer will be composited into the
scene using the specified blend mode.
A value of null is treated as pass-though this means no effect on a
parent such as a Group and the equivalent of SRC_OVER for a single Node.

Default value:

null

blendModeProperty

The BlendMode used to blend this individual node
into the scene behind it. If this node happens to be a Group then all of the
children will be composited individually into a temporary buffer using their
own blend modes and then that temporary buffer will be composited into the
scene using the specified blend mode.
A value of null is treated as pass-though this means no effect on a
parent such as a Group and the equivalent of SRC_OVER for a single Node.

setClip

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 ImageView Node as
a mask to represent the Clip. Or you could use one of the geometric shape
Nodes such as Rectangle or
Circle. Or you could use a
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.

There is a known limitation of mixing Clip with a 3D Transform.
Clipping is essentially a 2D image operation. The result of
a Clip set on a Group node with 3D transformed children
will cause its children to be rendered in order without Z-buffering
applied between those children.

getClip

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 ImageView Node as
a mask to represent the Clip. Or you could use one of the geometric shape
Nodes such as Rectangle or
Circle. Or you could use a
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.

There is a known limitation of mixing Clip with a 3D Transform.
Clipping is essentially a 2D image operation. The result of
a Clip set on a Group node with 3D transformed children
will cause its children to be rendered in order without Z-buffering
applied between those children.

clipProperty

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 ImageView Node as
a mask to represent the Clip. Or you could use one of the geometric shape
Nodes such as Rectangle or
Circle. Or you could use a
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.

There is a known limitation of mixing Clip with a 3D Transform.
Clipping is essentially a 2D image operation. The result of
a Clip set on a Group node with 3D transformed children
will cause its children to be rendered in order without Z-buffering
applied between those children.

setCache

public final void setCache(boolean value)

Sets the value of the property cache.

Property description:

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.

Default value:

false

isCache

public final boolean isCache()

Gets the value of the property cache.

Property description:

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.

Default value:

false

cacheProperty

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.

setCacheHint

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.setCache(true);
expensiveNode.setCacheHint(CacheHint.QUALITY);
...
// Do an animation
expensiveNode.setCacheHint(CacheHint.SPEED);
new Timeline(
new KeyFrame(Duration.seconds(2),
new KeyValue(expensiveNode.scaleXProperty(), 2.0),
new KeyValue(expensiveNode.scaleYProperty(), 2.0),
new KeyValue(expensiveNode.rotateProperty(), 360),
new KeyValue(expensiveNode.cacheHintProperty(), 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.
Caching may be disabled for any node that has a 3D transform on itself,
any of its ancestors, or any of its descendants.

Default value:

CacheHint.DEFAULT

getCacheHint

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.setCache(true);
expensiveNode.setCacheHint(CacheHint.QUALITY);
...
// Do an animation
expensiveNode.setCacheHint(CacheHint.SPEED);
new Timeline(
new KeyFrame(Duration.seconds(2),
new KeyValue(expensiveNode.scaleXProperty(), 2.0),
new KeyValue(expensiveNode.scaleYProperty(), 2.0),
new KeyValue(expensiveNode.rotateProperty(), 360),
new KeyValue(expensiveNode.cacheHintProperty(), 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.
Caching may be disabled for any node that has a 3D transform on itself,
any of its ancestors, or any of its descendants.

Default value:

CacheHint.DEFAULT

cacheHintProperty

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.setCache(true);
expensiveNode.setCacheHint(CacheHint.QUALITY);
...
// Do an animation
expensiveNode.setCacheHint(CacheHint.SPEED);
new Timeline(
new KeyFrame(Duration.seconds(2),
new KeyValue(expensiveNode.scaleXProperty(), 2.0),
new KeyValue(expensiveNode.scaleYProperty(), 2.0),
new KeyValue(expensiveNode.rotateProperty(), 360),
new KeyValue(expensiveNode.cacheHintProperty(), 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.
Caching may be disabled for any node that has a 3D transform on itself,
any of its ancestors, or any of its descendants.

There is a known limitation of mixing Effect with a 3D Transform. Effect is
essentially a 2D image operation. The result of an Effect set on
a Group node with 3D transformed children will cause its children
to be rendered in order without Z-buffering applied between those
children.

There is a known limitation of mixing Effect with a 3D Transform. Effect is
essentially a 2D image operation. The result of an Effect set on
a Group node with 3D transformed children will cause its children
to be rendered in order without Z-buffering applied between those
children.

Default value:

null

effectProperty

There is a known limitation of mixing Effect with a 3D Transform. Effect is
essentially a 2D image operation. The result of an Effect set on
a Group node with 3D transformed children will cause its children
to be rendered in order without Z-buffering applied between those
children.

setDepthTest

Indicates whether depth testing is used when rendering this node.
If the depthTest flag is DepthTest.DISABLE, then depth testing
is disabled for this node.
If the depthTest flag is DepthTest.ENABLE, then depth testing
is enabled for this node.
If the depthTest flag is DepthTest.INHERIT, then depth testing
is enabled for this node if it is enabled for the parent node or the
parent node is null.

The depthTest flag is only used when the depthBuffer flag for
the Scene is true (meaning that the
Scene has an associated depth buffer)

Depth test comparison is only done among nodes with depthTest enabled.
A node with depthTest disabled does not read, test, or write the depth buffer,
that is to say its Z value will not be considered for depth testing
with other nodes.

getDepthTest

Indicates whether depth testing is used when rendering this node.
If the depthTest flag is DepthTest.DISABLE, then depth testing
is disabled for this node.
If the depthTest flag is DepthTest.ENABLE, then depth testing
is enabled for this node.
If the depthTest flag is DepthTest.INHERIT, then depth testing
is enabled for this node if it is enabled for the parent node or the
parent node is null.

The depthTest flag is only used when the depthBuffer flag for
the Scene is true (meaning that the
Scene has an associated depth buffer)

Depth test comparison is only done among nodes with depthTest enabled.
A node with depthTest disabled does not read, test, or write the depth buffer,
that is to say its Z value will not be considered for depth testing
with other nodes.

depthTestProperty

Indicates whether depth testing is used when rendering this node.
If the depthTest flag is DepthTest.DISABLE, then depth testing
is disabled for this node.
If the depthTest flag is DepthTest.ENABLE, then depth testing
is enabled for this node.
If the depthTest flag is DepthTest.INHERIT, then depth testing
is enabled for this node if it is enabled for the parent node or the
parent node is null.

The depthTest flag is only used when the depthBuffer flag for
the Scene is true (meaning that the
Scene has an associated depth buffer)

Depth test comparison is only done among nodes with depthTest enabled.
A node with depthTest disabled does not read, test, or write the depth buffer,
that is to say its Z value will not be considered for depth testing
with other nodes.

setDisable

public final void setDisable(boolean value)

Sets the value of the property disable.

Property description:

Defines the individual disabled state of this Node. Setting
disable to true will cause this Node and any subnodes to
become disabled. This property should be used only to set the disabled
state of a Node. For querying the disabled state of a
Node, the disabled property 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.

Default value:

false

isDisable

public final boolean isDisable()

Gets the value of the property disable.

Property description:

Defines the individual disabled state of this Node. Setting
disable to true will cause this Node and any subnodes to
become disabled. This property should be used only to set the disabled
state of a Node. For querying the disabled state of a
Node, the disabled property 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.

Default value:

false

disableProperty

Defines the individual disabled state of this Node. Setting
disable to true will cause this Node and any subnodes to
become disabled. This property should be used only to set the disabled
state of a Node. For querying the disabled state of a
Node, the disabled property 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.

setPickOnBounds

public final void setPickOnBounds(boolean value)

Sets the value of the property pickOnBounds.

Property description:

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.

Default value:

false

isPickOnBounds

public final boolean isPickOnBounds()

Gets the value of the property pickOnBounds.

Property description:

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.

Default value:

false

pickOnBoundsProperty

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.

setDisabled

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.

Default value:

false

isDisabled

public final boolean isDisabled()

Gets the value of the property disabled.

Property description:

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.

disabledProperty

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.

lookup

Finds this Node, or the first sub-node, based on the given CSS selector.
If this node is a Parent, then this function will traverse down
into the branch until it finds a match. If more than one sub-node matches the
specified selector, this function returns the first of them.

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

Parameters:

selector - The css selector of the node to find

Returns:

The first node, starting from this Node, which matches
the CSS selector, null if none is found.

lookupAll

Finds all Nodes, including this one and any children, which match
the given CSS selector. If no matches are found, an empty unmodifiable set is
returned. The set is explicitly unordered.

Parameters:

selector - The css selector of the nodes to find

Returns:

All nodes, starting from and including this Node, which match
the CSS selector. The returned set is always unordered and
unmodifiable, and never null.

toBack

public void toBack()

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 ObservableList.
This function has no effect if this Node is not part of a group.

toFront

public void toFront()

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 ObservableList.
This function has no effect if this Node is not part of a group.

snapshot

Takes a snapshot of this node and returns the rendered image when
it is ready.
CSS and layout processing will be done for the node, and any of its
children, prior to rendering it.
The entire destination image is cleared to the fill Paint
specified by the SnapshotParameters. This node is then rendered to
the image.
If the viewport specified by the SnapshotParameters is null, the
upper-left pixel of the boundsInParent of this
node, after first applying the transform specified by the
SnapshotParameters,
is mapped to the upper-left pixel (0,0) in the image.
If a non-null viewport is specified,
the upper-left pixel of the viewport is mapped to upper-left pixel
(0,0) in the image.
In both cases, this mapping to (0,0) of the image is done with an integer
translation. The portion of the node that is outside of the rendered
image will be clipped by the image.

When taking a snapshot of a scene that is being animated, either
explicitly by the application or implicitly (such as chart animation),
the snapshot will be rendered based on the state of the scene graph at
the moment the snapshot is taken and will not reflect any subsequent
animation changes.

NOTE: In order for CSS and layout to function correctly, the node
must be part of a Scene (the Scene may be attached to a Stage, but need
not be).

Parameters:

params - the snapshot parameters containing attributes that
will control the rendering. If the SnapshotParameters object is null,
then the Scene's attributes will be used if this node is part of a scene,
or default attributes will be used if this node is not part of a scene.

image - the writable image that will be used to hold the rendered node.
It may be null in which case a new WritableImage will be constructed.
The new image is constructed using integer width and
height values that are derived either from the transformed bounds of this
Node or from the size of the viewport as specified in the
SnapShotParameters. These integer values are chosen such that the image
will wholly contain the bounds of this Node or the specified viewport.
If the image is non-null, the node will be rendered into the
existing image.
In this case, the width and height of the image determine the area
that is rendered instead of the width and height of the bounds or
viewport.

snapshot

Takes a snapshot of this node at the next frame and calls the
specified callback method when the image is ready.
CSS and layout processing will be done for the node, and any of its
children, prior to rendering it.
The entire destination image is cleared to the fill Paint
specified by the SnapshotParameters. This node is then rendered to
the image.
If the viewport specified by the SnapshotParameters is null, the
upper-left pixel of the boundsInParent of this
node, after first applying the transform specified by the
SnapshotParameters,
is mapped to the upper-left pixel (0,0) in the image.
If a non-null viewport is specified,
the upper-left pixel of the viewport is mapped to upper-left pixel
(0,0) in the image.
In both cases, this mapping to (0,0) of the image is done with an integer
translation. The portion of the node that is outside of the rendered
image will be clipped by the image.

This is an asynchronous call, which means that other
events or animation might be processed before the node is rendered.
If any such events modify the node, or any of its children, that
modification will be reflected in the rendered image (just like it
will also be reflected in the frame rendered to the Stage, if this node
is part of a live scene graph).

When taking a snapshot of a node that is being animated, either
explicitly by the application or implicitly (such as chart animation),
the snapshot will be rendered based on the state of the scene graph at
the moment the snapshot is taken and will not reflect any subsequent
animation changes.

NOTE: In order for CSS and layout to function correctly, the node
must be part of a Scene (the Scene may be attached to a Stage, but need
not be).

Parameters:

callback - a class whose call method will be called when the image
is ready. The SnapshotResult that is passed into the call method of
the callback will contain the rendered image, the source node
that was rendered, and a copy of the SnapshotParameters.
The callback parameter must not be null.

params - the snapshot parameters containing attributes that
will control the rendering. If the SnapshotParameters object is null,
then the Scene's attributes will be used if this node is part of a scene,
or default attributes will be used if this node is not part of a scene.

image - the writable image that will be used to hold the rendered node.
It may be null in which case a new WritableImage will be constructed.
The new image is constructed using integer width and
height values that are derived either from the transformed bounds of this
Node or from the size of the viewport as specified in the
SnapShotParameters. These integer values are chosen such that the image
will wholly contain the bounds of this Node or the specified viewport.
If the image is non-null, the node will be rendered into the
existing image.
In this case, the width and height of the image determine the area
that is rendered instead of the width and height of the bounds or
viewport.

setOnDragDone

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.

getOnDragDone

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.

onDragDoneProperty

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.

startDragAndDrop

Confirms a potential drag and drop gesture that is recognized over this
Node.
Can be called only from a DRAG_DETECTED event handler. The returned
Dragboard is used to transfer data during
the drag and drop gesture. Placing this Node's data on the
Dragboard also identifies this Node as the source of
the drag and drop gesture.
More detail about drag and drop gestures is described in the overivew
of DragEvent.

Parameters:

transferModes - The supported TransferMode(s) of this Node

Returns:

A Dragboard to place this Node's data on

Throws:

IllegalStateException - if drag and drop cannot be started at this
moment (it's called outside of DRAG_DETECTED event handling or
this node is not in scene).

startFullDrag

public void startFullDrag()

Starts a full press-drag-release gesture with this node as gesture
source. This method can be called only from a DRAG_DETECTED mouse
event handler. More detail about dragging gestures can be found
in the overview of MouseEvent and MouseDragEvent.

Throws:

IllegalStateException - if the full press-drag-release gesture
cannot be started at this moment (it's called outside of
DRAG_DETECTED event handling or this node is not in scene).

setManaged

public final void setManaged(boolean value)

Sets the value of the property managed.

Property description:

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.

isManaged

public final boolean isManaged()

Gets the value of the property managed.

Property description:

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.

managedProperty

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.

setLayoutX

public final void setLayoutX(double value)

Sets the value of the property layoutX.

Property description:

Defines the x coordinate of the translation that is added to this Node's
transform for the purpose of layout. The value should be computed as the
offset required to adjust the position of the node from its current
layoutBounds minX position (which might not be 0) to the desired location.

For example, if textnode should be positioned at finalX

textnode.setLayoutX(finalX - textnode.getLayoutBounds().getMinX());

Failure to subtract layoutBounds minX may result in misplacement
of the node. The relocate(x, y) method will automatically do the
correct computation and should generally be used over setting layoutX directly.

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.

If the node is managed and has a Region
as its parent, then the layout region will set layoutX according to its
own layout policy. If the node is unmanaged or parented by a Group,
then the application may set layoutX directly to position it.

getLayoutX

public final double getLayoutX()

Gets the value of the property layoutX.

Property description:

Defines the x coordinate of the translation that is added to this Node's
transform for the purpose of layout. The value should be computed as the
offset required to adjust the position of the node from its current
layoutBounds minX position (which might not be 0) to the desired location.

For example, if textnode should be positioned at finalX

textnode.setLayoutX(finalX - textnode.getLayoutBounds().getMinX());

Failure to subtract layoutBounds minX may result in misplacement
of the node. The relocate(x, y) method will automatically do the
correct computation and should generally be used over setting layoutX directly.

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.

If the node is managed and has a Region
as its parent, then the layout region will set layoutX according to its
own layout policy. If the node is unmanaged or parented by a Group,
then the application may set layoutX directly to position it.

layoutXProperty

Defines the x coordinate of the translation that is added to this Node's
transform for the purpose of layout. The value should be computed as the
offset required to adjust the position of the node from its current
layoutBounds minX position (which might not be 0) to the desired location.

For example, if textnode should be positioned at finalX

textnode.setLayoutX(finalX - textnode.getLayoutBounds().getMinX());

Failure to subtract layoutBounds minX may result in misplacement
of the node. The relocate(x, y) method will automatically do the
correct computation and should generally be used over setting layoutX directly.

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.

If the node is managed and has a Region
as its parent, then the layout region will set layoutX according to its
own layout policy. If the node is unmanaged or parented by a Group,
then the application may set layoutX directly to position it.

setLayoutY

public final void setLayoutY(double value)

Sets the value of the property layoutY.

Property description:

Defines the y coordinate of the translation that is added to this Node's
transform for the purpose of layout. The value should be computed as the
offset required to adjust the position of the node from its current
layoutBounds minY position (which might not be 0) to the desired location.

For example, if textnode should be positioned at finalY

textnode.setLayoutY(finalY - textnode.getLayoutBounds().getMinY());

Failure to subtract layoutBounds minY may result in misplacement
of the node. The relocate(x, y) method will automatically do the
correct computation and should generally be used over setting layoutY directly.

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.

If the node is managed and has a Region
as its parent, then the region will set layoutY according to its
own layout policy. If the node is unmanaged or parented by a Group,
then the application may set layoutY directly to position it.

getLayoutY

public final double getLayoutY()

Gets the value of the property layoutY.

Property description:

Defines the y coordinate of the translation that is added to this Node's
transform for the purpose of layout. The value should be computed as the
offset required to adjust the position of the node from its current
layoutBounds minY position (which might not be 0) to the desired location.

For example, if textnode should be positioned at finalY

textnode.setLayoutY(finalY - textnode.getLayoutBounds().getMinY());

Failure to subtract layoutBounds minY may result in misplacement
of the node. The relocate(x, y) method will automatically do the
correct computation and should generally be used over setting layoutY directly.

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.

If the node is managed and has a Region
as its parent, then the region will set layoutY according to its
own layout policy. If the node is unmanaged or parented by a Group,
then the application may set layoutY directly to position it.

layoutYProperty

Defines the y coordinate of the translation that is added to this Node's
transform for the purpose of layout. The value should be computed as the
offset required to adjust the position of the node from its current
layoutBounds minY position (which might not be 0) to the desired location.

For example, if textnode should be positioned at finalY

textnode.setLayoutY(finalY - textnode.getLayoutBounds().getMinY());

Failure to subtract layoutBounds minY may result in misplacement
of the node. The relocate(x, y) method will automatically do the
correct computation and should generally be used over setting layoutY directly.

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.

If the node is managed and has a Region
as its parent, then the region will set layoutY according to its
own layout policy. If the node is unmanaged or parented by a Group,
then the application may set layoutY directly to position it.

relocate

Sets the node's layoutX and layoutY translation properties in order to
relocate this node to the x,y location in the parent.

This method does not alter translateX or translateY, which if also set
will be added to layoutX and layoutY, adjusting the final location by
corresponding amounts.

Parameters:

x - the target x coordinate location

y - the target y coordinate location

isResizable

public boolean isResizable()

Indicates whether this node is a type which can be resized by its parent.
If this method returns true, then the parent will resize the node (ideally
within its size range) by calling node.resize(width,height) during the
layout pass. All Regions, Controls, and WebView are resizable classes
which depend on their parents resizing them during layout once all sizing
and CSS styling information has been applied.

If this method returns false, then the parent cannot resize it during
layout (resize() is a no-op) and it should return its layoutBounds for
minimum, preferred, and maximum sizes. Group, Text, and all Shapes are not
resizable and hence depend on the application to establish their sizing
by setting appropriate properties (e.g. width/height for Rectangle,
text on Text, and so on). Non-resizable nodes may still be relocated
during layout.

Returns:

whether or not this node type can be resized by its parent during layout

getContentBias

Returns the orientation of a node's resizing bias for layout purposes.
If the node type has no bias, returns null. If the node is resizable and
it's height depends on its width, returns HORIZONTAL, else if its width
depends on its height, returns VERTICAL.

Resizable subclasses should override this method to return an
appropriate value.

minWidth

public double minWidth(double height)

Returns the node's minimum width for use in layout calculations.
If the node is resizable, its parent should not resize its width any
smaller than this value. If the node is not resizable, returns its
layoutBounds width.

Layout code which calls this method should first check the content-bias
of the node. If the node has a vertical content-bias, then callers
should pass in a height value that the minimum width should be based on.
If the node has either a horizontal or null content-bias, then the caller
should pass in -1.

Node subclasses with a vertical content-bias should honor the height
parameter whether -1 or a positive value. All other subclasses may ignore
the height parameter (which will likely be -1).

If Node's maxWidth(double) is lower than this number,
minWidth takes precedence. This means the Node should never be resized below minWidth.

Parameters:

height - the height that should be used if minimum width depends on it

Returns:

the minimum width that the node should be resized to during layout.
The result will never be NaN, nor will it ever be negative.

minHeight

public double minHeight(double width)

Returns the node's minimum height for use in layout calculations.
If the node is resizable, its parent should not resize its height any
smaller than this value. If the node is not resizable, returns its
layoutBounds height.

Layout code which calls this method should first check the content-bias
of the node. If the node has a horizontal content-bias, then callers
should pass in a width value that the minimum height should be based on.
If the node has either a vertical or null content-bias, then the caller
should pass in -1.

Node subclasses with a horizontal content-bias should honor the width
parameter whether -1 or a positive value. All other subclasses may ignore
the width parameter (which will likely be -1).

If Node's maxHeight(double) is lower than this number,
minHeight takes precedence. This means the Node should never be resized below minHeight.

Parameters:

width - the width that should be used if minimum height depends on it

Returns:

the minimum height that the node should be resized to during layout
The result will never be NaN, nor will it ever be negative.

prefWidth

public double prefWidth(double height)

Returns the node's preferred width for use in layout calculations.
If the node is resizable, its parent should treat this value as the
node's ideal width within its range. If the node is not resizable,
just returns its layoutBounds width, which should be treated as the rigid
width of the node.

Layout code which calls this method should first check the content-bias
of the node. If the node has a vertical content-bias, then callers
should pass in a height value that the preferred width should be based on.
If the node has either a horizontal or null content-bias, then the caller
should pass in -1.

Node subclasses with a vertical content-bias should honor the height
parameter whether -1 or a positive value. All other subclasses may ignore
the height parameter (which will likely be -1).

Parameters:

height - the height that should be used if preferred width depends on it

Returns:

the preferred width that the node should be resized to during layout
The result will never be NaN, nor will it ever be negative.

prefHeight

public double prefHeight(double width)

Returns the node's preferred height for use in layout calculations.
If the node is resizable, its parent should treat this value as the
node's ideal height within its range. If the node is not resizable,
just returns its layoutBounds height, which should be treated as the rigid
height of the node.

Layout code which calls this method should first check the content-bias
of the node. If the node has a horizontal content-bias, then callers
should pass in a width value that the preferred height should be based on.
If the node has either a vertical or null content-bias, then the caller
should pass in -1.

Node subclasses with a horizontal content-bias should honor the height
parameter whether -1 or a positive value. All other subclasses may ignore
the height parameter (which will likely be -1).

Parameters:

width - the width that should be used if preferred height depends on it

Returns:

the preferred height that the node should be resized to during layout
The result will never be NaN, nor will it ever be negative.

maxWidth

public double maxWidth(double height)

Returns the node's maximum width for use in layout calculations.
If the node is resizable, its parent should not resize its width any
larger than this value. A value of Double.MAX_VALUE indicates the
parent may expand the node's width beyond its preferred without limits.

If the node is not resizable, returns its layoutBounds width.

Layout code which calls this method should first check the content-bias
of the node. If the node has a vertical content-bias, then callers
should pass in a height value that the maximum width should be based on.
If the node has either a horizontal or null content-bias, then the caller
should pass in -1.

Node subclasses with a vertical content-bias should honor the height
parameter whether -1 or a positive value. All other subclasses may ignore
the height parameter (which will likely be -1).

If Node's minWidth(double) is greater, it should take precedence
over the maxWidth. This means the Node should never be resized below minWidth.

Parameters:

height - the height that should be used if maximum width depends on it

Returns:

the maximum width that the node should be resized to during layout
The result will never be NaN, nor will it ever be negative.

maxHeight

public double maxHeight(double width)

Returns the node's maximum height for use in layout calculations.
If the node is resizable, its parent should not resize its height any
larger than this value. A value of Double.MAX_VALUE indicates the
parent may expand the node's height beyond its preferred without limits.

If the node is not resizable, returns its layoutBounds height.

Layout code which calls this method should first check the content-bias
of the node. If the node has a horizontal content-bias, then callers
should pass in a width value that the maximum height should be based on.
If the node has either a vertical or null content-bias, then the caller
should pass in -1.

Node subclasses with a horizontal content-bias should honor the width
parameter whether -1 or a positive value. All other subclasses may ignore
the width parameter (which will likely be -1).

If Node's minHeight(double) is greater, it should take precedence
over the maxHeight. This means the Node should never be resized below minHeight.

Parameters:

width - the width that should be used if maximum height depends on it

Returns:

the maximum height that the node should be resized to during layout
The result will never be NaN, nor will it ever be negative.

resize

public void resize(double width,
double height)

If the node is resizable, will set its layout bounds to the specified
width and height. If the node is not resizable, this method is a no-op.

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() method may
be used if the parent just needs to resize the node to its preferred size.

autosize

public final void autosize()

If the node is resizable, will set its layout bounds to its current preferred
width and height. If the node is not resizable, this method is a no-op.

This method automatically queries the node's content-bias and if it's
horizontal, will pass in the node's preferred width to get the preferred
height; if vertical, will pass in the node's preferred height to get the width,
and if null, will compute the preferred width/height independently.

resizeRelocate

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 reposition it.

getBaselineOffset

public double getBaselineOffset()

The 'alphabetic' (or 'roman') baseline offset from the node's layoutBounds.minY location
that should be used when this node is being vertically aligned by baseline with
other nodes. By default this returns BASELINE_OFFSET_SAME_AS_HEIGHT for resizable Nodes
and layoutBounds height for non-resizable. Subclasses
which contain text should override this method to return their actual text baseline offset.

getBoundsInParent

The rectangular bounds of this Node which include its transforms.
boundsInParent is calculated by
taking the 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 computation is based on the geometry of this Node only.

This property will always have a non-null value.

Note that boundsInParent is automatically recomputed whenever the
geometry of a node changes, or when any of the following the change:
transforms ObservableList, translateX, translateY, layoutX, layoutY,
scaleX, scaleY, or the 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, the x or y variables of a shape, or
translateX, translateY should never be bound to boundsInParent
for the purpose of positioning the node.

boundsInParentProperty

The rectangular bounds of this Node which include its transforms.
boundsInParent is calculated by
taking the 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 computation is based on the geometry of this Node only.

This property will always have a non-null value.

Note that boundsInParent is automatically recomputed whenever the
geometry of a node changes, or when any of the following the change:
transforms ObservableList, translateX, translateY, layoutX, layoutY,
scaleX, scaleY, or the 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, the x or y variables of a shape, or
translateX, translateY should never be bound to boundsInParent
for the purpose of positioning the node.

getBoundsInLocal

The rectangular bounds of this Node in the node's
untransformed local coordinate space. For nodes that extend
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 computation is based on the geometry of this Node only.

This property will always have 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, the x or y variables of a shape should never be bound
to boundsInLocal for the purpose of positioning the node.

boundsInLocalProperty

The rectangular bounds of this Node in the node's
untransformed local coordinate space. For nodes that extend
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 computation is based on the geometry of this Node only.

This property will always have 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, the x or y variables of a shape should never be bound
to boundsInLocal for the purpose of positioning the node.

getLayoutBounds

The rectangular bounds that should be used for layout calculations for
this node. layoutBounds may differ from the visual bounds
of the node and is computed differently depending on the node type.

If the node type is resizable (Region,
Control, or WebView)
then the layoutBounds will always be 0,0 width x height.
If the node type is not resizable (Shape,
Text, or Group), then the layoutBounds
are computed based on the node's geometric properties and does not include the
node's clip, effect, or transforms. See individual class documentation
for details.

Note that the layoutX, layoutY, translateX, and
translateY variables are not included in the layoutBounds.
This is important because layout code must first determine the current
size and location of the node (using layoutBounds) and then set
layoutX and layoutY to adjust the translation of the
node so that it will have the desired layout position.

Because the computation of layoutBounds is often tied to a node's
geometric variables, it is an error to bind any such variables to an
expression that depends upon layoutBounds. For example, the
x or y variables of a shape should never be bound to layoutBounds
for the purpose of positioning the node.

layoutBoundsProperty

The rectangular bounds that should be used for layout calculations for
this node. layoutBounds may differ from the visual bounds
of the node and is computed differently depending on the node type.

If the node type is resizable (Region,
Control, or WebView)
then the layoutBounds will always be 0,0 width x height.
If the node type is not resizable (Shape,
Text, or Group), then the layoutBounds
are computed based on the node's geometric properties and does not include the
node's clip, effect, or transforms. See individual class documentation
for details.

Note that the layoutX, layoutY, translateX, and
translateY variables are not included in the layoutBounds.
This is important because layout code must first determine the current
size and location of the node (using layoutBounds) and then set
layoutX and layoutY to adjust the translation of the
node so that it will have the desired layout position.

Because the computation of layoutBounds is often tied to a node's
geometric variables, it is an error to bind any such variables to an
expression that depends upon layoutBounds. For example, the
x or y variables of a shape should never be bound to layoutBounds
for the purpose of positioning the node.

contains

public boolean contains(double localX,
double localY)

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.

contains

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.

intersects

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.

intersects

Returns true if the given bounds (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.

sceneToLocal

Transforms a point from the coordinate space of the scene
into the local coordinate space of this Node.
If the Node does not have any SubScene or rootScene is set to true, the arguments are in Scene coordinates
of the Node returned by getScene(). Othwerwise, the subscene coordinates are used, which is equivalent to calling
sceneToLocal(double, double)

Parameters:

x - the x coordinate

y - the y coordinate

rootScene - whether Scene coordinates should be used even if the Node is in a SubScene

Returns:

local coordinates of the point

Since:

JavaFX 8u40

sceneToLocal

Transforms a point from the coordinate space of the scene
into the local coordinate space of this Node.
If the Node does not have any SubScene or rootScene is set to true, the arguments are in Scene coordinates
of the Node returned by getScene(). Othwerwise, the subscene coordinates are used, which is equivalent to calling
sceneToLocal(javafx.geometry.Point2D)

Parameters:

point - the point

rootScene - whether Scene coordinates should be used even if the Node is in a SubScene

Returns:

local coordinates of the point

Since:

JavaFX 8u40

sceneToLocal

Transforms a bounds from the coordinate space of the scene
into the local coordinate space of this Node.
If the Node does not have any SubScene or rootScene is set to true, the arguments are in Scene coordinates
of the Node returned by getScene(). Othwerwise, the subscene coordinates are used, which is equivalent to calling
sceneToLocal(javafx.geometry.Bounds).

Since 3D bounds cannot be converted with rootScene set to true, trying to convert 3D bounds will yield null.

Parameters:

bounds - the bounds

rootScene - whether Scene coordinates should be used even if the Node is in a SubScene

Returns:

local coordinates of the bounds

Since:

JavaFX 8u40

sceneToLocal

Transforms a point from the coordinate space of the scene
into the local coordinate space of this Node.
Note that if this node is in a SubScene, the arguments should be in the subscene coordinates,
not that of Scene.

Parameters:

sceneX - x coordinate of a point on a Scene

sceneY - y coordinate of a point on a Scene

Returns:

local Node's coordinates of the point or null if Node is not in a Window.
Null is also returned if the transformation from local to Scene is not invertible.

sceneToLocal

Transforms a point from the coordinate space of the scene
into the local coordinate space of this Node.
Note that if this node is in a SubScene, the arguments should be in the subscene coordinates,
not that of Scene.

Parameters:

scenePoint - a point on a Scene

Returns:

local Node's coordinates of the point or null if Node is not in a Window.
Null is also returned if the transformation from local to Scene is not invertible.

sceneToLocal

Transforms a point from the coordinate space of the scene
into the local coordinate space of this Node.
Note that if this node is in a SubScene, the arguments should be in the subscene coordinates,
not that of Scene.

Parameters:

scenePoint - a point on a Scene

Returns:

local Node's coordinates of the point or null if Node is not in a Window.
Null is also returned if the transformation from local to Scene is not invertible.

Since:

JavaFX 8.0

sceneToLocal

Transforms a point from the coordinate space of the scene
into the local coordinate space of this Node.
Note that if this node is in a SubScene, the arguments should be in the subscene coordinates,
not that of Scene.

Parameters:

sceneX - x coordinate of a point on a Scene

sceneY - y coordinate of a point on a Scene

sceneZ - z coordinate of a point on a Scene

Returns:

local Node's coordinates of the point or null if Node is not in a Window.
Null is also returned if the transformation from local to Scene is not invertible.

Since:

JavaFX 8.0

sceneToLocal

Transforms a rectangle from the coordinate space of the
scene into the local coordinate space of this
Node.
Note that if this node is in a SubScene, the arguments should be in the subscene coordinates,
not that of Scene.

Parameters:

sceneBounds - bounds on a Scene

Returns:

bounds in the local Node'space or null if Node is not in a Window.
Null is also returned if the transformation from local to Scene is not invertible.

localToScene

Transforms a point from the local coordinate space of this Node
into the coordinate space of its scene.
Note that if this node is in a SubScene, the result is in the subscene coordinates,
not that of Scene.

localToScene

Transforms a point from the local coordinate space of this Node
into the coordinate space of its scene.
Note that if this node is in a SubScene, the result is in the subscene coordinates,
not that of Scene.

localToScene

Transforms a point from the local coordinate space of this Node
into the coordinate space of its scene.
Note that if this node is in a SubScene, the result is in the subscene coordinates,
not that of Scene.

localToScene

Transforms a point from the local coordinate space of this Node
into the coordinate space of its scene.
Note that if this node is in a SubScene, the result is in the subscene coordinates,
not that of Scene.

localToScene

Transforms a point from the local coordinate space of this Node
into the coordinate space of its scene.
If the Node does not have any SubScene or rootScene is set to true, the result point is in Scene coordinates
of the Node returned by getScene(). Othwerwise, the subscene coordinates are used, which is equivalent to calling
localToScene(javafx.geometry.Point3D)

Parameters:

localPoint - the point in local coordinates

rootScene - whether Scene coordinates should be used even if the Node is in a SubScene

localToScene

Transforms a point from the local coordinate space of this Node
into the coordinate space of its scene.
If the Node does not have any SubScene or rootScene is set to true, the result point is in Scene coordinates
of the Node returned by getScene(). Othwerwise, the subscene coordinates are used, which is equivalent to calling
localToScene(double, double, double)

Parameters:

x - the x coordinate of the point in local coordinates

y - the y coordinate of the point in local coordinates

z - the z coordinate of the point in local coordinates

rootScene - whether Scene coordinates should be used even if the Node is in a SubScene

localToScene

Transforms a point from the local coordinate space of this Node
into the coordinate space of its scene.
If the Node does not have any SubScene or rootScene is set to true, the result point is in Scene coordinates
of the Node returned by getScene(). Othwerwise, the subscene coordinates are used, which is equivalent to calling
localToScene(javafx.geometry.Point2D)

Parameters:

localPoint - the point in local coordinates

rootScene - whether Scene coordinates should be used even if the Node is in a SubScene

localToScene

Transforms a point from the local coordinate space of this Node
into the coordinate space of its scene.
If the Node does not have any SubScene or rootScene is set to true, the result point is in Scene coordinates
of the Node returned by getScene(). Othwerwise, the subscene coordinates are used, which is equivalent to calling
localToScene(double, double)

Parameters:

x - the x coordinate of the point in local coordinates

y - the y coordinate of the point in local coordinates

rootScene - whether Scene coordinates should be used even if the Node is in a SubScene

localToScene

Transforms a bounds from the local coordinate space of this Node
into the coordinate space of its scene.
If the Node does not have any SubScene or rootScene is set to true, the result bounds are in Scene coordinates
of the Node returned by getScene(). Othwerwise, the subscene coordinates are used, which is equivalent to calling
localToScene(javafx.geometry.Bounds)

Parameters:

localBounds - the bounds in local coordinates

rootScene - whether Scene coordinates should be used even if the Node is in a SubScene

localToScene

Transforms a bounds from the local coordinate space of this
Node into the coordinate space of its scene.
Note that if this node is in a SubScene, the result is in the subscene coordinates,
not that of Scene.

Parameters:

localBounds - bounds in Node's space

Returns:

the bounds in the scene coordinates or null if Node is not in a Window

setRotate

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.

Default value:

0.0

getRotate

public final double getRotate()

Gets the value of the property rotate.

Property description:

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.

rotateProperty

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.

localToSceneTransformProperty

An affine transform that holds the computed local-to-scene transform.
This is the concatenation of all transforms in this node's parents and
in this node, including all of the convenience transforms up to the root.
If this node is in a SubScene, this property represents
transforms up to the subscene, not the root scene.

Note that when you register a listener or a binding to this property,
it needs to listen for invalidation on all its parents to the root node.
This means that registering a listener on this
property on many nodes may negatively affect performance of
transformation changes in their common parents.

getLocalToSceneTransform

An affine transform that holds the computed local-to-scene transform.
This is the concatenation of all transforms in this node's parents and
in this node, including all of the convenience transforms up to the root.
If this node is in a SubScene, this property represents
transforms up to the subscene, not the root scene.

Note that when you register a listener or a binding to this property,
it needs to listen for invalidation on all its parents to the root node.
This means that registering a listener on this
property on many nodes may negatively affect performance of
transformation changes in their common parents.

nodeOrientationProperty

Node orientation describes the flow of visual data within a node.
In the English speaking world, visual data normally flows from
left-to-right. In an Arabic or Hebrew world, visual data flows
from right-to-left. This is consistent with the reading order
of text in both worlds. The default value is left-to-right.

usesMirroring

public boolean usesMirroring()

Determines whether a node should be mirrored when node orientation
is right-to-left.

When a node is mirrored, the origin is automatically moved to the
top right corner causing the node to layout children and draw from
right to left using a mirroring transformation. Some nodes may wish
to draw from right to left without using a transformation. These
nodes will will answer false and implement right-to-left
orientation without using the automatic transformation.

Since:

JavaFX 8.0

setMouseTransparent

public final void setMouseTransparent(boolean value)

Sets the value of the property mouseTransparent.

Property description:

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.

isMouseTransparent

public final boolean isMouseTransparent()

Gets the value of the property mouseTransparent.

Property description:

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.

mouseTransparentProperty

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.

setHover

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.

Default value:

false

isHover

public final boolean isHover()

Gets the value of the property hover.

Property description:

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.

hoverProperty

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.

setOnKeyPressed

Defines a function to be called when this Node or its child
Node has input focus and a key has been pressed. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

getOnKeyPressed

Defines a function to be called when this Node or its child
Node has input focus and a key has been pressed. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

onKeyPressedProperty

Defines a function to be called when this Node or its child
Node has input focus and a key has been pressed. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

setOnKeyReleased

Defines a function to be called when this Node or its child
Node has input focus and a key has been released. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

getOnKeyReleased

Defines a function to be called when this Node or its child
Node has input focus and a key has been released. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

onKeyReleasedProperty

Defines a function to be called when this Node or its child
Node has input focus and a key has been released. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

setOnKeyTyped

Defines a function to be called when this Node or its child
Node has input focus and a key has been typed. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

getOnKeyTyped

Defines a function to be called when this Node or its child
Node has input focus and a key has been typed. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

onKeyTypedProperty

Defines a function to be called when this Node or its child
Node has input focus and a key has been typed. The function
is called only if the event hasn't been already consumed during its
capturing or bubbling phase.

setOnInputMethodTextChanged

Defines a function to be called when this Node
has input focus and the input method text has changed. If this
function is not defined in this Node, then it
receives the result string of the input method composition as a
series of onKeyTyped function calls.
When the Node loses the input focus, the JavaFX runtime
automatically commits the existing composed text if any.

getOnInputMethodTextChanged

Defines a function to be called when this Node
has input focus and the input method text has changed. If this
function is not defined in this Node, then it
receives the result string of the input method composition as a
series of onKeyTyped function calls.
When the Node loses the input focus, the JavaFX runtime
automatically commits the existing composed text if any.

onInputMethodTextChangedProperty

Defines a function to be called when this Node
has input focus and the input method text has changed. If this
function is not defined in this Node, then it
receives the result string of the input method composition as a
series of onKeyTyped function calls.
When the Node loses the input focus, the JavaFX runtime
automatically commits the existing composed text if any.

inputMethodRequestsProperty

setFocused

protected final void setFocused(boolean value)

Sets the value of the property focused.

Property description:

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.

Default value:

false

isFocused

public final boolean isFocused()

Gets the value of the property focused.

Property description:

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.

Default value:

false

focusedProperty

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.

setFocusTraversable

public final void setFocusTraversable(boolean value)

Sets the value of the property focusTraversable.

Property description:

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

Default value:

false

isFocusTraversable

public final boolean isFocusTraversable()

Gets the value of the property focusTraversable.

Property description:

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

Default value:

false

focusTraversableProperty

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

requestFocus

public void requestFocus()

Requests that this Node get the input focus, and that this
Node's top-level ancestor become the focused window. To be
eligible to receive the focus, the node must be part of a scene, it and
all of its ancestors must be visible, and it must not be disabled.
If this node is eligible, this function will cause it to become this
Scene's "focus owner". Each scene has at most one focus owner
node. The focus owner will not actually have the input focus, however,
unless the scene belongs to a Stage that is both visible
and active.

setEventDispatcher

Specifies the event dispatcher for this node. The default event
dispatcher sends the received events to the registered event handlers and
filters. When replacing the value with a new EventDispatcher,
the new dispatcher should forward events to the replaced dispatcher
to maintain the node's default event handling behavior.

getEventDispatcher

Specifies the event dispatcher for this node. The default event
dispatcher sends the received events to the registered event handlers and
filters. When replacing the value with a new EventDispatcher,
the new dispatcher should forward events to the replaced dispatcher
to maintain the node's default event handling behavior.

eventDispatcherProperty

Specifies the event dispatcher for this node. The default event
dispatcher sends the received events to the registered event handlers and
filters. When replacing the value with a new EventDispatcher,
the new dispatcher should forward events to the replaced dispatcher
to maintain the node's default event handling behavior.

removeEventHandler

Unregisters a previously registered event handler from this node. One
handler might have been registered for different event types, so the
caller needs to specify the particular event type from which to
unregister the handler.

removeEventFilter

Unregisters a previously registered event filter from this node. One
filter might have been registered for different event types, so the
caller needs to specify the particular event type from which to
unregister the filter.

fireEvent

Fires the specified event. By default the event will travel through the
hierarchy from the stage to this node. Any event filter encountered will
be notified and can consume the event. If not consumed by the filters,
the event handlers on this node are notified. If these don't consume the
event eighter, the event will travel back the same path it arrived to
this node. All event handlers encountered are called and can consume the
event.

pseudoClassStateChanged

Used to specify that a pseudo-class of this Node has changed. If the
pseudo-class is used in a CSS selector that matches this Node, CSS will
be reapplied. Typically, this method is called from the invalidated
method of a property that is used as a pseudo-class. For example:

The active pseudo-class states of this Node, wrapped in an unmodifiable ObservableSet

Since:

JavaFX 8.0

applyCss

public final void applyCss()

If required, apply styles to this Node and its children, if any. This method does not normally need to
be invoked directly but may be used in conjunction with Parent.layout() to size a Node before the
next pulse, or if the Scene is not in a Stage.

Provided that the Node's Scene is not null, CSS is applied to this Node regardless
of whether this Node's CSS state is clean. CSS styles are applied from the top‑most parent
of this Node whose CSS state is other than clean, which may affect the styling of other nodes.
This method is a no-op if the Node is not in a Scene. The Scene does not have to be in a Stage.

This method does not invoke the Parent.layout() method. Typically, the caller will use the
following sequence of operations.

parentNode.applyCss();
parentNode.layout();

As a more complete example, the following code uses applyCss() and layout() to find
the width and height of the Button before the Stage has been shown. If either the call to applyCss()
or the call to layout() is commented out, the calls to getWidth() and getHeight()
will return zero (until some time after the Stage is shown).

setAccessibleRoleDescription

Noramlly, when a role is provided for a node, the screen reader
speaks the role as well as the contents of the node. When this
value is set, it is possbile to override the default. This is
useful because the set of roles is predefined. For example,
it is possible to set the role of a node to be a button, but
have the role description be arbitrary text.

Default value:

null

Since:

JavaFX 8u40

getAccessibleRoleDescription

Noramlly, when a role is provided for a node, the screen reader
speaks the role as well as the contents of the node. When this
value is set, it is possbile to override the default. This is
useful because the set of roles is predefined. For example,
it is possible to set the role of a node to be a button, but
have the role description be arbitrary text.

Default value:

null

Since:

JavaFX 8u40

accessibleRoleDescriptionProperty

Noramlly, when a role is provided for a node, the screen reader
speaks the role as well as the contents of the node. When this
value is set, it is possbile to override the default. This is
useful because the set of roles is predefined. For example,
it is possible to set the role of a node to be a button, but
have the role description be arbitrary text.

setAccessibleText

This property is used to set the text that the screen
reader will speak. If a node normally speaks text,
that text is overriden. For example, a button
usually speaks using the text in the control but will
no longer do this when this value is set.

Default value:

null

Since:

JavaFX 8u40

getAccessibleText

This property is used to set the text that the screen
reader will speak. If a node normally speaks text,
that text is overriden. For example, a button
usually speaks using the text in the control but will
no longer do this when this value is set.

Default value:

null

Since:

JavaFX 8u40

accessibleTextProperty

This property is used to set the text that the screen
reader will speak. If a node normally speaks text,
that text is overriden. For example, a button
usually speaks using the text in the control but will
no longer do this when this value is set.