_properties

class java.lang.Object
trait scala.Matchable
class Any
class Fx.List[A]
class Fx.Table[Fx.Table.ROW]
class Fx.ComboBox[A]
class Fx.Cell
class Fx.Table.Cell[Fx.Table.Cell.ROW, V, A]
class Fx.Table.Cell.X.CheckBox[Fx.Table.Cell.X.CheckBox.ROW, V, A]
class Fx.Table.Cell.X.ComboBox[Fx.Table.Cell.X.ComboBox.ROW, V, A]
class Fx.Table.Cell.X.Label[Fx.Table.Cell.X.Label.ROW, V, A]
class Fx.Table.Cell.X.TextField[Fx.Table.Cell.X.TextField.ROW, V, A]
class Fx.Table.RowCell[Fx.Table.RowCell.ROW, Fx.Table.RowCell.VIEW]
class Fx.Label
class Fx.Button
class Fx.Chart
class Fx.Chart.XY[X, Y]
class Fx.Chart.Xy.X.Basic[X, Y, Fx.Chart.Xy.X.Basic.XA, Fx.Chart.Xy.X.Basic.YA]
class Fx.Pane
class Fx.Chart.Axis[A]

Def

@scala.annotation.targetName("cache_Pro")

Performance hint

Performance hint

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

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

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

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

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

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

Source
_properties.scala
@scala.annotation.targetName("disable_Pro")

Disable

Disable

Sets the individual disabled state of this Node

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

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

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

Source
_properties.scala
@scala.annotation.targetName("disabled_Pro")

Check disabled

Check disabled

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

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

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

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

A disabled Node does not receive mouse or key events.

Source
_properties.scala
@scala.annotation.targetName("focused_Pro")
def focused_*: O

Check focused

Check focused

Indicates whether this Node currently has the input focus

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

See requestFocus() for more information

Source
_properties.scala
@scala.annotation.targetName("focusTraversable_Pro")

Check focus traversable

Check focus traversable

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

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

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

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

Source
_properties.scala
@scala.annotation.targetName("hover_Pro")
def hover_*: O

Check hover

Check hover

Whether or not this Node is being hovered over

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

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

Future implementations may provide alternative means of supporting hover.

Source
_properties.scala
@scala.annotation.targetName("id_Pro")

Node id

Node id

The id of this Node.

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

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

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

Source
_properties.scala
@scala.annotation.targetName("layoutX_Pro")

Layout x

Layout x

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

Source
_properties.scala
@scala.annotation.targetName("layoutY_Pro")

Layout y

Layout y

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

Source
_properties.scala
@scala.annotation.targetName("managed_Pro")

Managed switch

Managed switch

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

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

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

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

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

By default all nodes are managed.

Source
_properties.scala
@scala.annotation.targetName("mouseTransparent_Pro")

Mouse transparent

Mouse transparent

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

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

Source
_properties.scala
@scala.annotation.targetName("opacity_Pro")

Opacity

Opacity

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

A Node with 0% opacity is fully translucent

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

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

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

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

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

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

On some platforms ImageView might not support opacity variable.

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

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

Source
_properties.scala
@scala.annotation.targetName("pressed_Pro")
def pressed_*: O

Pressed

Pressed

Whether or not the Node is pressed

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

Source
_properties.scala
@scala.annotation.targetName("rotate_Pro")

Rotate

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

Source
_properties.scala
@scala.annotation.targetName("scaleX_Pro")

Scale x

Scale x

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

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

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

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

Source
_properties.scala
@scala.annotation.targetName("scaleY_Pro")

Scale y

Scale y

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

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

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

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

Source
_properties.scala
@scala.annotation.targetName("scaleZ_Pro")

Scale z

Scale z

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

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

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

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

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

Source
_properties.scala
@scala.annotation.targetName("style_Pro")

Style

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

Source
_properties.scala
@scala.annotation.targetName("translateX_Pro")

Translate x

Translate x

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

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

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

Source
_properties.scala
@scala.annotation.targetName("translateY_Pro")

Translate y

Translate y

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

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

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

Source
_properties.scala
@scala.annotation.targetName("translateZ_Pro")

Translate z

Translate z

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

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

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

Source
_properties.scala
@scala.annotation.targetName("visible_Pro")

Visible

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

Source
_properties.scala