abstract class Node extends EventTarget with Styleable with SFXDelegate[javafx.scene.Node]
- Alphabetic
- By Inheritance
- Node
- Styleable
- EventTarget
- SFXDelegate
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new Node(delegate: javafx.scene.Node)
creates a new ScalaFX Node from a JavaFX Node.
creates a new ScalaFX Node from a JavaFX Node.
- delegate
JavaFX Node
- Attributes
- protected
Type Members
- sealed trait FilterMagnet[J <: javafx.event.Event, S <: SFXDelegate[J]] extends AnyRef
Trait implementing Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"
Trait implementing Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"
- Definition Classes
- EventTarget
- sealed trait HandlerMagnet[J <: javafx.event.Event, S <: SFXDelegate[J]] extends AnyRef
Trait implementing Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"
Trait implementing Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"
- Definition Classes
- EventTarget
Value Members
- object FilterMagnet
Companion object implementing Magnet Pattern Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"
Companion object implementing Magnet Pattern Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"
- Definition Classes
- EventTarget
- object HandlerMagnet
Companion object implementing Magnet Pattern Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"
Companion object implementing Magnet Pattern Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"
- Definition Classes
- EventTarget
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def accessibleHelp: ObjectProperty[String]
The accessible help text for this
Node
.The accessible help text for this
Node
.The help text provides a more detailed description of the accessible text for a node. By default, if the node has a tool tip, this text is used.
Default value is
null
.- Since
JavaFX 8u40
- def accessibleHelp_=(v: String): Unit
- def accessibleRole: ObjectProperty[javafx.scene.AccessibleRole]
The accessible role for this
Node
.The accessible role for this
Node
.The screen reader uses the role of a node to determine the attributes and actions that are supported.
- Since
JavaFX 8u40
- def accessibleRoleDescription: ObjectProperty[String]
The role description of this
Node
.The role description of this
Node
.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 is
null
.- Since
JavaFX 8u40
- def accessibleRoleDescription_=(v: String): Unit
- def accessibleRole_=(v: AccessibleRole): Unit
- def accessibleText: ObjectProperty[String]
The accessible text for this
Node
.The accessible text for this
Node
.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 is
null
.- Since
JavaFX 8u40
- def accessibleText_=(v: String): Unit
- def alignmentInParent: Pos
Pseudo-property that indicates this Node position inside its respective parent.
- def alignmentInParent_=(p: Pos): Unit
Sets this Node's alignment constraint inside its Parent.
Sets this Node's alignment constraint inside its Parent. If set, will override the Parent's default alignment. Setting the value to
null
will remove the constraint. Internally it callssetAlignment(Node, Pos)
static method JavaFX's BorderPane, StackPane and TilePane. Furthermore, it is sethalignment
andvalignment
property (using JavaFX Node'sgetProperties()
) and called javafx.geometry.HPos) setHalignment and javafx.geometry.VPos) setValignment static methods from GridPane; this time usinghpos
andvpos
from Pos argument. Besides, it sets this nodealignment
property towards JavaFX Node's getProperties() andsetAlignment
static method fromDo not confuse with
alignment
property from scalafx.delegate.AlignmentDelegate! It refers to alignment inside element, whilealignmentInParent
refers to element's alignment inside its parent.- p
New node's Position
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def autosize(): Unit
If the node is resizable, will set its layout bounds to its current preferred width and height.
- def baselineOffset: Double
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.
- def blendMode: ObjectProperty[BlendMode]
The BlendMode used to blend this individual node into the scene behind it.
- def blendMode_=(v: BlendMode): Unit
- def boundsInLocal: ReadOnlyObjectProperty[Bounds]
The rectangular bounds of this Node in the node's untransformed local coordinate space.
- def boundsInParent: ReadOnlyObjectProperty[Bounds]
The rectangular bounds of this Node which include its transforms.
- def buildEventDispatchChain(tail: EventDispatchChain): EventDispatchChain
Construct an event dispatch chain for this target.
Construct an event dispatch chain for this target. The event dispatch chain contains event dispatchers which might be interested in processing of events targeted at this
EventTarget
. This event target is not automatically added to the chain, so if it wants to process events, it needs to add anEventDispatcher
for itself to the chain.In the case the event target is part of some hierarchy, the chain for it is usually built from event dispatchers collected from the root of the hierarchy to the event target.
The event dispatch chain is constructed by modifications to the provided initial event dispatch chain. The returned chain should have the initial chain at its end so the dispatchers should be prepended to the initial chain.
The caller shouldn't assume that the initial chain remains unchanged nor that the returned value will reference a different chain.
- tail
the initial chain to build from
- returns
the resulting event dispatch chain for this target
- Definition Classes
- EventTarget
- See also
- def cache: BooleanProperty
A performance hint to the system to indicate that this Node should be cached as a bitmap.
- def cacheHint: ObjectProperty[javafx.scene.CacheHint]
Additional hint for controlling bitmap caching.
- def cacheHint_=(v: CacheHint): Unit
- def cache_=(v: Boolean): Unit
- def clip: ObjectProperty[javafx.scene.Node]
Specifies a Node to use to define the the clipping shape for this Node.
- def clip_=(v: Node): Unit
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @IntrinsicCandidate() @native()
- def contains(localPoint: Point2D): Boolean
Returns true if the given point (specified in the local coordinate space of this Node) is contained within the shape of this Node.
- def contains(localX: Double, localY: Double): Boolean
Returns true if the given point (specified in the local coordinate space of this Node) is contained within the shape of this Node.
- def contentBias: Orientation
Returns the orientation of a node's resizing bias for layout purposes.
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.
- returns
orientation of width/height dependency or
null
if there is none
- def cssMetaData: Seq[CssMetaData[_ <: Styleable, _]]
The CssMetaData of this Styleable.
The CssMetaData of this Styleable.
- Definition Classes
- Styleable
- def cursor: ObjectProperty[javafx.scene.Cursor]
Defines the mouse cursor for this Node and subnodes.
- def cursor_=(v: Cursor): Unit
- val delegate: javafx.scene.Node
JavaFX object to be wrapped.
JavaFX object to be wrapped.
- Definition Classes
- Node → EventTarget → SFXDelegate
- def depthTest: ObjectProperty[javafx.scene.DepthTest]
Indicates whether depth testing is used when rendering this node.
- def depthTest_=(v: DepthTest): Unit
- def disable: BooleanProperty
Sets the individual disabled state of this Node.
- def disable_=(v: Boolean): Unit
- def disabled: ReadOnlyBooleanProperty
Indicates whether or not this Node is disabled.
- def effect: ObjectProperty[Effect]
Specifies an effect to apply to this Node.
- def effect_=(v: Effect): Unit
- def effectiveNodeOrientation: ReadOnlyObjectProperty[NodeOrientation]
The effective orientation of a node resolves the inheritance of node orientation, returning either left-to-right or right-to-left.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(ref: Any): Boolean
Verifies if a object is equals to this delegate.
Verifies if a object is equals to this delegate.
- ref
Object to be compared.
- returns
if the other object is equals to this delegate or not.
- Definition Classes
- SFXDelegate → AnyRef → Any
- def eventDispatcher: ObjectProperty[EventDispatcher]
Specifies the event dispatcher for this node.
- def eventDispatcher_=(v: EventDispatcher): Unit
- def filterEvent[J <: Event, S <: Event with SFXDelegate[J]](eventType: EventType[J])(filter: FilterMagnet[J, S]): Subscription
Registers an event filter.
Registers an event filter. Registered event filters get an event before any associated event handlers.
Example of filtering mouse events
pane.filterEvent(MouseEvent.Any) { me: MouseEvent => { me.eventType match { case MouseEvent.MousePressed => { ... } case MouseEvent.MouseDragged => { ... } case _ => { ... } } } }
or
pane.filterEvent(MouseEvent.Any) { () => println("Some mouse event handled") }
- J
type JavaFX delegate of the event
- S
ScalaFX type for
J
type wrapper.- eventType
type of events that will be handled.
- filter
code handling the event, see examples above.
- Definition Classes
- EventTarget
- def fireEvent(event: Event): Unit
Fires the specified event.
- def focusTraversable: BooleanProperty
Specifies whether this Node should be a part of focus traversal cycle.
- def focusTraversable_=(v: Boolean): Unit
- def focusVisible: ReadOnlyBooleanProperty
Indicates whether this
Node
should visibly indicate focus.Indicates whether this
Node
should visibly indicate focus. This flag is set when the node acquires input focus via keyboard navigation, and it is cleared when the node loses focus or when requestFocus is called.- Since
19
- def focusWithin: ReadOnlyBooleanProperty
Indicates whether this
Node
or any of its descendants currently has the input focus.Indicates whether this
Node
or any of its descendants currently has the input focus.- Since
19
- def focused: ReadOnlyBooleanProperty
Indicates whether this Node currently has the input focus.
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @IntrinsicCandidate() @native()
- def getId: String
The id of this Styleable.
The id of this Styleable.
IMPLEMENTATION NOTE: For this method was adopted the name
getId
insteadid
to not conflict with its subclasses already have a method with this name which returns aStringProperty
.- Definition Classes
- Styleable
- def getStyle: String
A string representation of the CSS style associated with this specific Node.
A string representation of the CSS style associated with this specific Node.
IMPLEMENTATION NOTE: For this method was adopted the name
getStyle
insteadstyle
to not conflict with its subclasses already have a method with this name which returns aStringProperty
.- Definition Classes
- Styleable
- def handleEvent[J <: Event, S <: Event with SFXDelegate[J]](eventType: EventType[J])(handler: HandlerMagnet[J, S]): Subscription
Registers an event handler.
Registers an event handler. The handler is called when the node receives an Event of the specified type during the bubbling phase of event delivery.
Example of handling mouse events
pane.handleEvent(MouseEvent.Any) { me: MouseEvent => { me.eventType match { case MouseEvent.MousePressed => ... case MouseEvent.MouseDragged => ... case _ => {} } } }
or
pane.handleEvent(MouseEvent.Any) { () => println("Some mouse event handled") }
- J
type JavaFX delegate of the event
- S
ScalaFX type for
J
type wrapper.- eventType
type of events that will be handled.
- handler
code handling the event, see examples above.
- returns
Returns a subscription that can be used to cancel/remove this event handler
- Definition Classes
- EventTarget
- def hashCode(): Int
- returns
The delegate hashcode
- Definition Classes
- SFXDelegate → AnyRef → Any
- def hgrow: Priority
Pseudo-property that returns this Node's hgrow constraint if set.
Pseudo-property that returns this Node's hgrow constraint if set.
- returns
the horizontal grow priority for the child or
null
if no priority was set
- def hgrow_=(p: Priority): Unit
Sets the horizontal grow priority for this Node inside its parent.
Sets the horizontal grow priority for this Node inside its parent. Setting the value to
null
will remove the constraint. Internally it callssetHgrow(Node, Priority)
static method from JavaFX'sGridPane
andHBox
besides fill this Node's "hgrow" property.- p
the horizontal grow priority for this Node
- def hover: ReadOnlyBooleanProperty
Whether or not this Node is being hovered over.
- def id: StringProperty
The id of this Node.
- def id_=(v: String): Unit
- def inputMethodRequests: ObjectProperty[InputMethodRequests]
Property holding InputMethodRequests.
- def inputMethodRequests_=(v: InputMethodRequests): Unit
- def intersects(localX: Double, localY: Double, localWidth: Double, localHeight: Double): Boolean
Returns true if the given rectangle (specified in the local coordinate space of this Node) intersects the shape of this Node.
- def intersects(localBounds: Bounds): Boolean
Returns true if the given bounds (specified in the local coordinate space of this Node) intersects the shape of this Node.
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def layoutBounds: ReadOnlyObjectProperty[Bounds]
The rectangular bounds that should be used for layout calculations for this node.
- def layoutX: DoubleProperty
Defines the x coordinate of the translation that is added to this Node's transform for the purpose of layout.
- def layoutX_=(v: Double): Unit
- def layoutY: DoubleProperty
Defines the y coordinate of the translation that is added to this Node's transform for the purpose of layout.
- def layoutY_=(v: Double): Unit
- def localToParent(localPoint: Point2D): Point2D
Transforms a point from the local coordinate space of this Node into the coordinate space of its parent.
- def localToParent(localX: Double, localY: Double): Point2D
Transforms a point from the local coordinate space of this Node into the coordinate space of its parent.
- def localToParent(localBounds: Bounds): Bounds
Transforms a bounds from the local coordinate space of this Node into the coordinate space of its parent.
- def localToParentTransform: Transform
An affine transform that holds the computed local-to-parent transform.
An affine transform that holds the computed local-to-parent transform. This is the concatenation of all transforms in this node, including all of the convenience transforms.
- Since
2.2
- def localToScene(localPoint: Point2D): Point2D
Transforms a point from the local coordinate space of this Node into the coordinate space of its Scene.
- def localToScene(localX: Double, localY: Double): Point2D
Transforms a point from the local coordinate space of this Node into the coordinate space of its Scene.
- def localToScene(localBounds: Bounds): Bounds
Transforms a bounds from the local coordinate space of this Node into the coordinate space of its Scene.
- def localToSceneTransform: Transform
An affine transform that holds the computed local-to-scene transform.
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.
- Since
2.2
- def lookup(selector: String): Node
Finds this Node, or the first sub-node, based on the given CSS selector.
- def lookupAll(selector: String): Set[javafx.scene.Node]
Finds all Nodes, including this one and any children, which match the given CSS selector.
- def managed: BooleanProperty
Defines whether or not this node's layout will be managed by it's parent.
- def managed_=(v: Boolean): Unit
- def margin: Insets
Pseudo-property that returns this Node's margin constraint inside its Parent if set.
Pseudo-property that returns this Node's margin constraint inside its Parent if set.
- returns
this Node's margin constraint inside its Parent or
null
if no margin was set.
- def margin_=(i: Insets): Unit
Sets this Node's margin constraint inside its Parent if set.
Sets this Node's margin constraint inside its Parent if set. If set, the parent will layout the child with the margin space around it. Setting the value to
null
will remove the constraint. Internally it callssetMargin(Node, Insets)
static method from JavaFX'sBorderPane
,FlowPane
,GridPane
,HBox
,StackPane
andVBox
besides fill this Node's "margin" property.- i
The margin of space around this Node inside its parent.
- def maxHeight(height: Double): Double
Returns the node's maximum height for use in layout calculations.
- def maxWidth(width: Double): Double
Returns the node's maximum width for use in layout calculations.
- def minHeight(height: Double): Double
Returns the node's minimum height for use in layout calculations.
- def minWidth(width: Double): Double
Returns the node's minimum width for use in layout calculations.
- def mouseTransparent: BooleanProperty
If true, this node (together with all its children) is completely transparent to mouse events.
- def mouseTransparent_=(v: Boolean): Unit
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nodeOrientation: ObjectProperty[NodeOrientation]
Node orientation describes the flow of visual data within a node.
- def nodeOrientation_=(v: NodeOrientation): Unit
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @IntrinsicCandidate() @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @IntrinsicCandidate() @native()
- def onContextMenuRequested: ObjectProperty[EventHandler[_ >: ContextMenuEvent]]
Defines a function to be called when a context menu has been requested on this Node.
- def onContextMenuRequested_=(v: EventHandler[_ >: ContextMenuEvent]): Unit
- def onDragDetected: ObjectProperty[EventHandler[_ >: MouseEvent]]
Defines a function to be called when drag gesture has been detected.
- def onDragDetected_=(v: EventHandler[_ >: MouseEvent]): Unit
- def onDragDone: ObjectProperty[EventHandler[_ >: DragEvent]]
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.
- def onDragDone_=(v: EventHandler[_ >: DragEvent]): Unit
- def onDragDropped: ObjectProperty[EventHandler[_ >: DragEvent]]
Defines a function to be called when the mouse button is released on this Node during drag and drop gesture.
- def onDragDropped_=(v: EventHandler[_ >: DragEvent]): Unit
- def onDragEntered: ObjectProperty[EventHandler[_ >: DragEvent]]
Defines a function to be called when drag gesture enters this Node.
- def onDragEntered_=(v: EventHandler[_ >: DragEvent]): Unit
- def onDragExited: ObjectProperty[EventHandler[_ >: DragEvent]]
Defines a function to be called when drag gesture exits this Node.
- def onDragExited_=(v: EventHandler[_ >: DragEvent]): Unit
- def onDragOver: ObjectProperty[EventHandler[_ >: DragEvent]]
Defines a function to be called when drag gesture progresses within this Node.
- def onDragOver_=(v: EventHandler[_ >: DragEvent]): Unit
- def onInputMethodTextChanged: ObjectProperty[EventHandler[_ >: InputMethodEvent]]
Defines a function to be called when this Node has input focus and the input method text has changed.
- def onInputMethodTextChanged_=(v: EventHandler[_ >: InputMethodEvent]): Unit
- def onKeyPressed: ObjectProperty[EventHandler[_ >: KeyEvent]]
Defines a function to be called when this Node or its child Node has input focus and a key has been pressed.
- def onKeyPressed_=(v: EventHandler[_ >: KeyEvent]): Unit
- def onKeyReleased: ObjectProperty[EventHandler[_ >: KeyEvent]]
Defines a function to be called when this Node or its child Node has input focus and a key has been released.
- def onKeyReleased_=(v: EventHandler[_ >: KeyEvent]): Unit
- def onKeyTyped: ObjectProperty[EventHandler[_ >: KeyEvent]]
Defines a function to be called when this Node or its child Node has input focus and a key has been typed.
- def onKeyTyped_=(v: EventHandler[_ >: KeyEvent]): Unit
- def onMouseClicked: ObjectProperty[EventHandler[_ >: MouseEvent]]
Defines a function to be called when a mouse button has been clicked (pressed and released) on this Node.
- def onMouseClicked_=(v: EventHandler[_ >: MouseEvent]): Unit
- def onMouseDragEntered: ObjectProperty[EventHandler[_ >: MouseDragEvent]]
Defines a function to be called when a full press-drag-release gesture enters this Node.
- def onMouseDragEntered_=(v: EventHandler[_ >: MouseDragEvent]): Unit
- def onMouseDragExited: ObjectProperty[EventHandler[_ >: MouseDragEvent]]
Defines a function to be called when a full press-drag-release gesture leaves this Node.
- def onMouseDragExited_=(v: EventHandler[_ >: MouseDragEvent]): Unit
- def onMouseDragOver: ObjectProperty[EventHandler[_ >: MouseDragEvent]]
Defines a function to be called when a full press-drag-release gesture progresses within this Node.
- def onMouseDragOver_=(v: EventHandler[_ >: MouseDragEvent]): Unit
- def onMouseDragReleased: ObjectProperty[EventHandler[_ >: MouseDragEvent]]
Defines a function to be called when a full press-drag-release gesture ends (by releasing mouse button) within this Node.
- def onMouseDragReleased_=(v: EventHandler[_ >: MouseDragEvent]): Unit
- def onMouseDragged: ObjectProperty[EventHandler[_ >: MouseEvent]]
Defines a function to be called when a mouse button is pressed on this Node and then dragged.
- def onMouseDragged_=(v: EventHandler[_ >: MouseEvent]): Unit
- def onMouseEntered: ObjectProperty[EventHandler[_ >: MouseEvent]]
Defines a function to be called when the mouse enters this Node.
- def onMouseEntered_=(v: EventHandler[_ >: MouseEvent]): Unit
- def onMouseExited: ObjectProperty[EventHandler[_ >: MouseEvent]]
Defines a function to be called when the mouse exits this Node.
- def onMouseExited_=(v: EventHandler[_ >: MouseEvent]): Unit
- def onMouseMoved: ObjectProperty[EventHandler[_ >: MouseEvent]]
- def onMouseMoved_=(v: EventHandler[_ >: MouseEvent]): Unit
- def onMousePressed: ObjectProperty[EventHandler[_ >: MouseEvent]]
Defines a function to be called when a mouse button has been pressed on this Node.
- def onMousePressed_=(v: EventHandler[_ >: MouseEvent]): Unit
- def onMouseReleased: ObjectProperty[EventHandler[_ >: MouseEvent]]
Defines a function to be called when a mouse button has been released on this Node.
- def onMouseReleased_=(v: EventHandler[_ >: MouseEvent]): Unit
- def onRotate: ObjectProperty[EventHandler[_ >: RotateEvent]]
Defines a function to be called when user performs a rotation action.
Defines a function to be called when user performs a rotation action.
- Since
2.2
- def onRotate_=(v: EventHandler[_ >: RotateEvent]): Unit
- def onRotationFinished: ObjectProperty[EventHandler[_ >: RotateEvent]]
Defines a function to be called when a rotation gesture ends.
Defines a function to be called when a rotation gesture ends.
- Since
2.2
- def onRotationFinished_=(v: EventHandler[_ >: RotateEvent]): Unit
- def onRotationStarted: ObjectProperty[EventHandler[_ >: RotateEvent]]
Defines a function to be called when a rotation gesture starts.
Defines a function to be called when a rotation gesture starts.
- Since
2.2
- def onRotationStarted_=(v: EventHandler[_ >: RotateEvent]): Unit
- def onScroll: ObjectProperty[EventHandler[_ >: ScrollEvent]]
Defines a function to be called when user performs a scrolling action.
- def onScrollFinished: ObjectProperty[EventHandler[_ >: ScrollEvent]]
Defines a function to be called when a Scroll gesture ends.
Defines a function to be called when a Scroll gesture ends.
- Since
2.2
- def onScrollFinished_=(v: EventHandler[_ >: ScrollEvent]): Unit
- def onScrollStarted: ObjectProperty[EventHandler[_ >: ScrollEvent]]
Defines a function to be called when a Scroll gesture starts.
Defines a function to be called when a Scroll gesture starts.
- Since
2.2
- def onScrollStarted_=(v: EventHandler[_ >: ScrollEvent]): Unit
- def onScroll_=(v: EventHandler[_ >: ScrollEvent]): Unit
- def onSwipeDown: ObjectProperty[EventHandler[_ >: SwipeEvent]]
Defines a function to be called when a Swipe Down gesture starts.
Defines a function to be called when a Swipe Down gesture starts.
- Since
2.2
- def onSwipeDown_=(v: EventHandler[_ >: SwipeEvent]): Unit
- def onSwipeLeft: ObjectProperty[EventHandler[_ >: SwipeEvent]]
Defines a function to be called when a Swipe Down gesture starts.
Defines a function to be called when a Swipe Down gesture starts.
- Since
2.2
- def onSwipeLeft_=(v: EventHandler[_ >: SwipeEvent]): Unit
- def onSwipeRight: ObjectProperty[EventHandler[_ >: SwipeEvent]]
Defines a function to be called when a Swipe Right gesture starts.
Defines a function to be called when a Swipe Right gesture starts.
- Since
2.2
- def onSwipeRight_=(v: EventHandler[_ >: SwipeEvent]): Unit
- def onSwipeUp: ObjectProperty[EventHandler[_ >: SwipeEvent]]
Defines a function to be called when a Swipe Up gesture starts.
Defines a function to be called when a Swipe Up gesture starts.
- Since
2.2
- def onSwipeUp_=(v: EventHandler[_ >: SwipeEvent]): Unit
- def onTouchMoved: ObjectProperty[EventHandler[_ >: TouchEvent]]
Defines a function to be called when user performs a Touch Moved action.
Defines a function to be called when user performs a Touch Moved action.
- Since
2.2
- def onTouchMoved_=(v: EventHandler[_ >: TouchEvent]): Unit
- def onTouchPressed: ObjectProperty[EventHandler[_ >: TouchEvent]]
Defines a function to be called when user performs a Touch Pressed action.
Defines a function to be called when user performs a Touch Pressed action.
- Since
2.2
- def onTouchPressed_=(v: EventHandler[_ >: TouchEvent]): Unit
- def onTouchReleased: ObjectProperty[EventHandler[_ >: TouchEvent]]
Defines a function to be called when user performs a Touch Released action.
Defines a function to be called when user performs a Touch Released action.
- Since
2.2
- def onTouchReleased_=(v: EventHandler[_ >: TouchEvent]): Unit
- def onTouchStationary: ObjectProperty[EventHandler[_ >: TouchEvent]]
Defines a function to be called when user performs a Touch Stationary action.
Defines a function to be called when user performs a Touch Stationary action.
- Since
2.2
- def onTouchStationary_=(v: EventHandler[_ >: TouchEvent]): Unit
- def onZoom: ObjectProperty[EventHandler[_ >: ZoomEvent]]
Defines a function to be called when user performs a Touch action.
Defines a function to be called when user performs a Touch action.
- Since
2.2
- def onZoomFinished: ObjectProperty[EventHandler[_ >: ZoomEvent]]
Defines a function to be called when a Zoom gesture ends.
Defines a function to be called when a Zoom gesture ends.
- Since
2.2
- def onZoomFinished_=(v: EventHandler[_ >: ZoomEvent]): Unit
- def onZoomStarted: ObjectProperty[EventHandler[_ >: ZoomEvent]]
Defines a function to be called when a Zoom gesture starts.
Defines a function to be called when a Zoom gesture starts.
- Since
2.2
- def onZoomStarted_=(v: EventHandler[_ >: ZoomEvent]): Unit
- def onZoom_=(v: EventHandler[_ >: ZoomEvent]): Unit
- def opacity: DoubleProperty
Specifies how opaque (that is, solid) the Node appears.
- def opacity_=(v: Double): Unit
- def parent: ReadOnlyObjectProperty[javafx.scene.Parent]
The parent of this Node.
- def parentToLocal(parentPoint: Point2D): Point2D
Transforms a point from the coordinate space of the parent into the local coordinate space of this Node.
- def parentToLocal(parentX: Double, parentY: Double): Point2D
Transforms a point from the coordinate space of the parent into the local coordinate space of this Node.
- def parentToLocal(parentBounds: Bounds): Bounds
Transforms a rectangle from the coordinate space of the parent into the local coordinate space of this Node.
- def pickOnBounds: BooleanProperty
Defines how the picking computation is done for this node when triggered by a MouseEvent or a contains function call.
- def pickOnBounds_=(v: Boolean): Unit
- def pressed: ReadOnlyBooleanProperty
Whether or not the Node is pressed.
- def pseudoClassStates: ObservableSet[PseudoClass]
The pseudo-class state of this Styleable.
The pseudo-class state of this Styleable.
- Definition Classes
- Styleable
- def relocate(x: Double, y: Double): Unit
Sets the node's layoutX and layoutY translation properties in order to relocate this node to the x,y location in the parent.
- def requestFocus(): Unit
Requests that this Node get the input focus, and that this Node's top-level ancestor become the focused window.
- def resize(width: Double, height: Double): Unit
If the node is resizable, will set its layout bounds to the specified width and height.
- def resizeRelocate(x: Double, y: Double, width: Double, height: Double): Unit
If the node is resizable, will set its layout bounds to the specified width and height.
- def rotate: DoubleProperty
Defines the angle of rotation about the Node's center, measured in degrees.
- def rotate_=(v: Double): Unit
- def rotationAxis: ObjectProperty[Point3D]
Defines the axis of rotation of this Node.
- def rotationAxis_=(v: Point3D): Unit
- def scaleX: DoubleProperty
Defines the factor by which coordinates are scaled about the center of the object along the X axis of this Node.
- def scaleX_=(v: Double): Unit
- def scaleY: DoubleProperty
Defines the factor by which coordinates are scaled about the center of the object along the Y axis of this Node.
- def scaleY_=(v: Double): Unit
- def scaleZ: DoubleProperty
Defines the factor by which coordinates are scaled about the center of the object along the Z axis of this Node.
- def scaleZ_=(v: Double): Unit
- def scene: ReadOnlyObjectProperty[javafx.scene.Scene]
The Scene that this Node is part of.
- def sceneToLocal(scenePoint: Point2D): Point2D
Transforms a point from the coordinate space of the Scene into the local coordinate space of this Node.
- def sceneToLocal(sceneX: Double, sceneY: Double): Point2D
Transforms a point from the coordinate space of the Scene into the local coordinate space of this Node.
- def sceneToLocal(sceneBounds: Bounds): Bounds
Transforms a rectangle from the coordinate space of the Scene into the local coordinate space of this Node.
- def snapshot(callback: (SnapshotResult) => Unit, params: SnapshotParameters, image: WritableImage): Unit
Takes a snapshot of this node at the next frame and calls the specified callback method when the image is ready.
Takes a snapshot of this node at the next frame and calls the specified callback method when the image is ready. Arguments
params
andimage
can be null. - def snapshot(params: SnapshotParameters, image: WritableImage): WritableImage
Takes a snapshot of this node and returns the rendered image when it is ready.
- def startDragAndDrop(transferModes: TransferMode*): Dragboard
Confirms a potential drag and drop gesture that is recognized over this Node.
- def startFullDrag(): Unit
Starts a full press-drag-release gesture with this node as gesture source.
- def style: StringProperty
A string representation of the CSS style associated with this specific Node.
- def styleClass: ObservableBuffer[String]
A list of String identifiers which can be used to logically group Nodes, specifically for an external style engine.
A list of String identifiers which can be used to logically group Nodes, specifically for an external style engine.
- Definition Classes
- Styleable
- def styleClass_=(c: Iterable[String]): Unit
Sets the list of CSS styles classes, replacing the prior content.
Sets the list of CSS styles classes, replacing the prior content. If you want append to current content, use
add
or similar.- c
list of CSS styles classes to replace prior content.
- def style_=(v: String): Unit
- def styleableNode: Node
Returns the Node that represents this Styleable object.
Returns the Node that represents this Styleable object. This method should be overridden in cases where the Styleable is not itself a Node, so that it may optionally return the relevant root node representation of itself. By default this method returns null, which can mean that either the Styleable itself is a Node, or if that is not the case, that the Styleable does not have a node representation available at the time of request.
- returns
the Node that represents this Styleable object
- Definition Classes
- Styleable
- Since
9
- def styleableParent: Styleable
The parent of this Styleable, or null if there is no parent.
The parent of this Styleable, or null if there is no parent.
- Definition Classes
- Styleable
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toBack(): Unit
Moves this Node to the back of its sibling nodes in terms of z-order.
- def toFront(): Unit
Moves this Node to the front of its sibling nodes in terms of z-order.
- def toString(): String
- returns
Returns the original delegate's
toString()
adding a[SFX]
prefix.
- Definition Classes
- SFXDelegate → AnyRef → Any
- def transforms: ObservableBuffer[Transform]
Defines the ObservableList of Transform objects to be applied to this Node.
- def transforms_=(c: Iterable[Transform]): Unit
Sets the list of transforms, replacing the prior content.
Sets the list of transforms, replacing the prior content. If you want append to current content, use
add
or similar.- c
list of transforms to replace prior content.
- def translateX: DoubleProperty
Defines the x coordinate of the translation that is added to this Node's transform.
- def translateX_=(v: Double): Unit
- def translateY: DoubleProperty
Defines the y coordinate of the translation that is added to this Node's transform.
- def translateY_=(v: Double): Unit
- def translateZ: DoubleProperty
Defines the Z coordinate of the translation that is added to the transformed coordinates of this Node.
- def translateZ_=(v: Double): Unit
- def typeSelector: String
The type of this
Styleable
that is to be used in selector matching.The type of this
Styleable
that is to be used in selector matching.- Definition Classes
- Styleable
- def userData: AnyRef
Returns a previously set Object property, or null if no such property has been set using the setUserData(AnyRef) method.
- def userData_=(v: AnyRef): Unit
- def vgrow: Priority
Pseudo-property that returns this Node's vgrow constraint if set.
Pseudo-property that returns this Node's vgrow constraint if set.
- returns
the vertical grow priority for the child or
null
if no priority was set
- def vgrow_=(p: Priority): Unit
Sets the vertical grow priority for this Node inside its parent.
Sets the vertical grow priority for this Node inside its parent. Setting the value to
null
will remove the constraint. Internally it callssetVgrow(Node, Priority)
static method from JavaFX'sGridPane
andVBox
besides fill this Node's "vgrow" property.- p
the vertical grow priority for this Node
- def viewOrder: DoubleProperty
Defines the rendering and picking order of this
Node
within its parent.Defines the rendering and picking order of this
Node
within its parent.This property is used to alter the rendering and picking order of a node within its parent without reordering the parent's
children
list. For example, this can be used as a more efficient way to implement transparency sorting. To do this, an application can assign the viewOrder value of each node to the computed distance between that node and the viewer.The parent will traverse its
children
in decreasingviewOrder
order. This means that a child with a lowerviewOrder
will be in front of a child with a higherviewOrder
. If two children have the sameviewOrder
, the parent will traverse them in the order they appear in the parent'schildren
list.However,
viewOrder
does not alter the layout and focus traversal order of this Node within its parent. A parent always traverses itschildren
list in order when doing layout or focus traversal.- returns
the view order for this
Node
- Since
9 Default value is 0.0
- def viewOrder_(value: Double): Unit
- def visible: BooleanProperty
Specifies whether this Node and any subnodes should be rendered as part of the scene graph.
- def visible_=(v: Boolean): Unit
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
ScalaFX is a UI DSL written within the Scala Language that sits on top of JavaFX 2.x and and JavaFX 8. This means that every ScalaFX application is also a valid Scala application. By extension it supports full interoperability with Java and can run anywhere the Java Virtual Machine (JVM) and JavaFX 2.0 or JavaFX 8 are supported.
Package Structure
ScalaFX package structure corresponds to JavaFX package structure, for instance
scalafx.animation
corresponds tojavafx.animation
.Example Usage
A basic ScalaFX application is created creating an object that is an instance of
JFXApp3
. Following Java FX theatre metaphor, it contains astage
that contains ascene
. Astage
roughly corresponds to a window in a typical UI environment. Thescene
holds UI content presented to the user. In the example below, the content is a pane with a singlelabel
component.