Fx.Chart.Axis

abstract class Axis[A] extends Fx.Abstract.Region with _properties
Source
__.scala
trait _methods
trait _events
trait _onZoom
trait _onTouch
trait _onSwipe
trait _onScroll
trait _onRotate
trait _onKey
class java.lang.Object
trait scala.Matchable
class Any

Alias

type VALUE
Source
__.scala

Def

@scala.annotation.targetName("animated_Pro")
Inherited from
_properties
Source
_properties.scala
def apply(v: A): Double
Source
__.scala
@scala.annotation.targetName("background_Pro")

Background

Background

The background of the Region, which is made up of zero or more BackgroundFills, and zero or more BackgroundImages

It is possible for a Background to be empty, where it has neither fills nor images, and is semantically equivalent to null

Inherited from
Region
Source
__.scala
@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

Inherited from
_properties
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

Inherited from
_properties
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.

Inherited from
_properties
Source
_properties.scala
lazy protected val eventStore: Event.Store
Inherited from
Provider
Source
Provider.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

Inherited from
_properties
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()

Inherited from
_properties
Source
_properties.scala
@scala.annotation.targetName("height_Pro")
def height_*: O

Height

Height

The height of this resizable node

This property is set by the region's parent during layout and may not be set by the application

If an application needs to explicitly control the size of a region, it should override its preferred size range by setting the minHeight, prefHeight, and maxHeight properties

Inherited from
Region
Source
__.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.

Inherited from
_properties
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");

Inherited from
_properties
Source
_properties.scala
@scala.annotation.targetName("label_Pro")
Inherited from
_properties
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

Inherited from
_properties
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

Inherited from
_properties
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.

Inherited from
_properties
Source
_properties.scala
@scala.annotation.targetName("maxHeight_Pro")

Maximum height

Maximum height

Property for overriding the region's computed maximum height

This should only be set if the region's internally computed maximum height doesn't meet the application's layout needs

Defaults to the Region.UseComputedSize flag, which means that getMaxHeight(forWidth) will return the region's internally computed maximum height

Setting this value to the Region.UsePrefSize flag will cause getMaxHeight(forWidth) to return the region's preferred height, enabling applications to easily restrict the resizability of the region

Inherited from
Region
Source
__.scala
@scala.annotation.targetName("maxWidth_Pro")

Maximum width

Maximum width

Property for overriding the region's computed maximum width

This should only be set if the region's internally computed maximum width doesn't meet the application's layout needs

Defaults to the Region.UseComputedSize flag, which means that maxWidth(forHeight) will return the region's internally computed maximum width

Setting this value to the Region.UsePrefSize flag will cause maxWidth(forHeight) to return the region's preferred width, enabling applications to easily restrict the resizability of the region

Inherited from
Region
Source
__.scala
@scala.annotation.targetName("minHeight_Pro")

Minimum height

Minimum height

Property for overriding the region's computed minimum height

This should only be set if the region's internally computed minimum height doesn't meet the application's layout needs

Defaults to the Region.UseComputedSize flag, which means that minHeight(forWidth) will return the region's internally computed minimum height

Setting this value to the Region.UsePrefSize flag will cause minHeight(forWidth) to return the region's preferred height, enabling applications to easily restrict the resizability of the region

Inherited from
Region
Source
__.scala
@scala.annotation.targetName("minWidth_Pro")

Maximum width

Maximum width

Property for overriding the region's computed minimum width

This should only be set if the region's internally computed minimum width doesn't meet the application's layout needs

Defaults to the Region.UseComputedSize flag, which means that minWidth(forHeight) will return the region's internally computed minimum width

Setting this value to the Region.UsePrefSize flag will cause minWidth(forHeight) to return the region's preferred width, enabling applications to easily restrict the resizability of the region

Inherited from
Region
Source
__.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.

Inherited from
_properties
Source
_properties.scala
@scala.annotation.targetName("needsLayout_Pro")

Needs layout check

Needs layout check

Indicates that this Node and its subnodes requires a layout pass on the next pulse
Inherited from
Parent
Source
Parent.scala

On context menu

On context menu

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

Inherited from
_onContextMenu
Source
_onContextMenu.scala

On drag detected

On drag detected

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On drag done

On drag done

Defines a function to be called when this Node is a drag and drop gesture source after its data has been dropped on a drop target

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

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

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

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On drag dropped

On drag dropped

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

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On drag entered

On drag entered

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On drag exited

On drag exited

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On drag over

On drag over

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On key pressed

On key pressed

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

Inherited from
_onKey
Source
_onKey.scala

On key released

On key released

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

Inherited from
_onKey
Source
_onKey.scala

On key typed

On key typed

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

Inherited from
_onKey
Source
_onKey.scala

On mouse clicked

On mouse clicked

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On mouse drag entered

On mouse drag entered

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On mouse drag exited

On mouse drag exited

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

Mouse dragged

Mouse dragged

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On mouse drag over

On mouse drag over

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On mouse drag released

On mouse drag released

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

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On mouse entered

On mouse entered

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On mouse exited

On mouse exited

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

Mouse left clicked

Mouse left clicked

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On mouse moved

On mouse moved

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On mouse pressed

On mouse pressed

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On mouse released

On mouse released

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On mouse right clicked

On mouse right clicked

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

Inherited from
_onMouseAndDrag
Source
_onMouseAndDrag.scala

On rotate

On rotate

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

Inherited from
_onRotate
Source
_onRotate.scala

On rotation finished

On rotation finished

Defines a function to be called when a rotation gesture ends

Inherited from
_onRotate
Source
_onRotate.scala

On rotation started

On rotation started

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

Inherited from
_onRotate
Source
_onRotate.scala

On scroll

On scroll

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

Inherited from
_onScroll
Source
_onScroll.scala

On scroll finished

On scroll finished

Defines a function to be called when a scrolling gesture ends

Inherited from
_onScroll
Source
_onScroll.scala

On scroll started

On scroll started

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

Inherited from
_onScroll
Source
_onScroll.scala

On swipe down

On swipe down

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

Inherited from
_onSwipe
Source
_onSwipe.scala

On swipe left

On swipe left

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

Inherited from
_onSwipe
Source
_onSwipe.scala

On swipe right

On swipe right

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

Inherited from
_onSwipe
Source
_onSwipe.scala

On swipe up

On swipe up

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

Inherited from
_onSwipe
Source
_onSwipe.scala

On touch moved

On touch moved

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

Inherited from
_onTouch
Source
_onTouch.scala

On touch pressed

On touch pressed

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

Inherited from
_onTouch
Source
_onTouch.scala

On touch released

On touch released

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

Inherited from
_onTouch
Source
_onTouch.scala

On touch stationary

On touch stationary

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

Inherited from
_onTouch
Source
_onTouch.scala

On zoom

On zoom

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

Inherited from
_onZoom
Source
_onZoom.scala

On zoom

On zoom

Defines a function to be called when a zooming gesture ends

Inherited from
_onZoom
Source
_onZoom.scala

On zoom

On zoom

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

Inherited from
_onZoom
Source
_onZoom.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

Inherited from
_properties
Source
_properties.scala
val ordering: scala.Ordering[A]
Source
__.scala
@scala.annotation.targetName("padding_Pro")

Padding

Padding

The top, right, bottom, and left padding around the region's content

This space will be included in the calculation of the region's minimum and preferred sizes

By default padding is Insets.EMPTY. Setting the value to null should be avoided.

Inherited from
Region
Source
__.scala
@scala.annotation.targetName("parent_Opt")

Parent

Parent

Returns node Parent

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

Inherited from
_methods
Source
_methods.scala
@scala.annotation.targetName("prefHeight_Pro")

Preferred height

Preferred height

Property for overriding the region's computed preferred width

This should only be set if the region's internally computed preferred width doesn't meet the application's layout needs

Defaults to the Region.UseComputedSize flag, which means that getPrefWidth(forHeight) will return the region's internally computed preferred width

Inherited from
Region
Source
__.scala
@scala.annotation.targetName("prefWidth_Pro")

Preferred width

Preferred width

Property for overriding the region's computed preferred width. This should only be set if the region's internally computed preferred width doesn't meet the application's layout needs

Defaults to the Region.UseComputedSize flag, which means that getPrefWidth(forHeight) will return the region's internally computed preferred width

Inherited from
Region
Source
__.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"

Inherited from
_properties
Source
_properties.scala

Mutable pseudo-class states

Mutable pseudo-class states

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

Inherited from
_methods
Source
_methods.scala
final def real: Fx.Chart.Axis.REAL

JavaFX peer

JavaFX peer

Returns the real JavaFX peer, which makes GUI happen

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

Inherited from
Gui
Source
__.scala
def resizeRelocate(x: Double, y: Double, width: Double, height: Double): Unit

Resize and move

Resize and move

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

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

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

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

Inherited from
_methods
Source
_methods.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

Inherited from
_properties
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

Inherited from
_properties
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

Inherited from
_properties
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.

Inherited from
_properties
Source
_properties.scala

Scene

Scene

Returns node Scene

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

Inherited from
_methods
Source
_methods.scala
@scala.annotation.targetName("scene_Opt")
Inherited from
Like
Source
Like.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

Inherited from
_properties
Source
_properties.scala

Mutable styles

Mutable styles

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

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

Inherited from
_methods
Source
_methods.scala
@scala.annotation.targetName("ticksFill_Pro")
Inherited from
_properties
Source
_properties.scala
@scala.annotation.targetName("ticksFont_Pro")
Inherited from
_properties
Source
_properties.scala
@scala.annotation.targetName("ticksGap_Pro")
Inherited from
_properties
Source
_properties.scala
@scala.annotation.targetName("ticksMarkVisible_Pro")
Inherited from
_properties
Source
_properties.scala
@scala.annotation.targetName("ticksRotation_Pro")
Inherited from
_properties
Source
_properties.scala
@scala.annotation.targetName("ticksVisible_Pro")
Inherited from
_properties
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

Inherited from
_properties
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

Inherited from
_properties
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

Inherited from
_properties
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

Inherited from
_properties
Source
_properties.scala
@scala.annotation.targetName("width_Pro")
def width_*: O

Width

Width

The width of this resizable node

This property is set by the region's parent during layout and may not be set by the application

If an application needs to explicitly control the size of a region, it should override its preferred size range by setting the minWidth, prefWidth, and maxWidth properties

Inherited from
Region
Source
__.scala