Group

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object FilterMagnet

Companion object implementing Magnet Pattern Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"

object HandlerMagnet

Companion object implementing Magnet Pattern Magnet Pattern to avoid compilation error "ambiguous reference to overloaded definition"

def addEventFilter[E <: Event](eventType: EventType[E], eventHandler: EventHandler[_ >: E]): Unit

Registers an event filter to this task.

def addEventHandler[E <: Event](eventType: EventType[E], eventHandler: EventHandler[_ >: E]): Unit

Registers an event handler to this task.

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.

final def asInstanceOf[T0]: T0

def autoSizeChildren: BooleanProperty

Controls whether or not this Group will automatically resize any managed resizable children to their preferred sizes during the layout pass.

def autoSizeChildren_=(v: Boolean): Unit

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(chain: EventDispatchChain): EventDispatchChain

Construct an event dispatch chain for this target.

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 children: ObservableList[javafx.scene.Node]

Gets the list of children of this Group.

def children_=(n: Node): Unit

Sets a child, replacing the prior content.

def children_=(c: Iterable[Node]): Unit

Sets the list of children, replacing the prior content.

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

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 cursor: ObjectProperty[javafx.scene.Cursor]

Defines the mouse cursor for this Node and subnodes.

def cursor_=(v: Cursor): Unit

val delegate: javafx.scene.Group

JavaFX object to be wrapped.

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

final def eq(arg0: AnyRef): Boolean

def equals(ref: Any): Boolean

Verifies if a object is equals to this delegate.

def eventDispatcher: ObjectProperty[EventDispatcher]

Specifies the event dispatcher for this node.

def eventDispatcher_=(v: EventDispatcher): Unit

def eventHandlerDelegate: EventHandled

Returns a object that implements scalafx.event.EventHandlerDelegate.EventHandled.

def filterEvent[J <: Event, S <: Event with SFXDelegate[J]](eventType: EventType[J])(filter: FilterMagnet[J, S]): Subscription

Registers an event filter.

pane.filterEvent(MouseEvent.Any) {
  me: MouseEvent => {
    me.eventType match {
      case MouseEvent.MousePressed => {
        ...
      }
      case MouseEvent.MouseDragged => {
        ...
      }
      case _ => {
        ...
      }
    }
  }
}

pane.filterEvent(MouseEvent.Any) { () => println("Some mouse event handled") }

def finalize(): Unit

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 focused: ReadOnlyBooleanProperty

Indicates whether this Node currently has the input focus.

final def getClass(): Class[_]

def handleEvent[J <: Event, S <: Event with SFXDelegate[J]](eventType: EventType[J])(handler: HandlerMagnet[J, S]): Subscription

Registers an event handler.

pane.handleEvent(MouseEvent.Any) {
  me: MouseEvent => {
    me.eventType match {
      case MouseEvent.MousePressed => ...
      case MouseEvent.MouseDragged => ...
      case _                       => {}
    }
  }
}

pane.handleEvent(MouseEvent.Any) { () => println("Some mouse event handled") }

def hashCode(): Int

def hgrow: Priority

Pseudo-property that returns this Node's hgrow constraint if set.

def hgrow_=(p: Priority): Unit

Sets the horizontal grow priority for this Node inside its parent.

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

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.

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.

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.

def margin_=(i: Insets): Unit

Sets this Node's margin constraint inside its Parent if set.

def maxHeight(width: Double): Double

Returns the node's maximum height for use in layout calculations.

def maxWidth(height: Double): Double

Returns the node's maximum width for use in layout calculations.

def minHeight(width: Double): Double

Returns the node's minimum height for use in layout calculations.

def minWidth(height: 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

def needsLayout: ReadOnlyBooleanProperty

Indicates that this Node and its subnodes requires a layout pass on the next pulse.

final def notify(): Unit

final def notifyAll(): Unit

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.

def onRotate_=(v: EventHandler[RotateEvent]): Unit

def onRotationFinished: ObjectProperty[EventHandler[_ >: RotateEvent]]

Defines a function to be called when a rotation gesture ends.

def onRotationFinished_=(v: EventHandler[RotateEvent]): Unit

def onRotationStarted: ObjectProperty[EventHandler[_ >: RotateEvent]]

Defines a function to be called when a rotation gesture starts.

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.

def onScrollFinished_=(v: EventHandler[ScrollEvent]): Unit

def onScrollStarted: ObjectProperty[EventHandler[_ >: ScrollEvent]]

Defines a function to be called when a Scroll gesture starts.

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.

def onSwipeDown_=(v: EventHandler[SwipeEvent]): Unit

def onSwipeLeft: ObjectProperty[EventHandler[_ >: SwipeEvent]]

Defines a function to be called when a Swipe Down gesture starts.

def onSwipeLeft_=(v: EventHandler[SwipeEvent]): Unit

def onSwipeRight: ObjectProperty[EventHandler[_ >: SwipeEvent]]

Defines a function to be called when a Swipe Right gesture starts.

def onSwipeRight_=(v: EventHandler[SwipeEvent]): Unit

def onSwipeUp: ObjectProperty[EventHandler[_ >: SwipeEvent]]

Defines a function to be called when a Swipe Up gesture starts.

def onSwipeUp_=(v: EventHandler[SwipeEvent]): Unit

def onTouchMoved: ObjectProperty[EventHandler[_ >: TouchEvent]]

Defines a function to be called when user performs a Touch Moved action.

def onTouchMoved_=(v: EventHandler[TouchEvent]): Unit

def onTouchPressed: ObjectProperty[EventHandler[_ >: TouchEvent]]

Defines a function to be called when user performs a Touch Pressed action.

def onTouchPressed_=(v: EventHandler[TouchEvent]): Unit

def onTouchReleased: ObjectProperty[EventHandler[_ >: TouchEvent]]

Defines a function to be called when user performs a Touch Released action.

def onTouchReleased_=(v: EventHandler[TouchEvent]): Unit

def onTouchStationary: ObjectProperty[EventHandler[_ >: TouchEvent]]

Defines a function to be called when user performs a Touch Stationary action.

def onTouchStationary_=(v: EventHandler[TouchEvent]): Unit

def onZoom: ObjectProperty[EventHandler[_ >: ZoomEvent]]

Defines a function to be called when user performs a Touch action.

def onZoomFinished: ObjectProperty[EventHandler[_ >: ZoomEvent]]

Defines a function to be called when a Zoom gesture ends.

def onZoomFinished_=(v: EventHandler[ZoomEvent]): Unit

def onZoomStarted: ObjectProperty[EventHandler[_ >: ZoomEvent]]

Defines a function to be called when a Zoom gesture starts.

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 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 removeEventFilter[E <: Event](eventType: EventType[E], eventHandler: EventHandler[_ >: E]): Unit

Unregisters a previously registered event filter from this task.

def removeEventHandler[E <: Event](eventType: EventType[E], eventHandler: EventHandler[_ >: E]): Unit

Unregisters a previously registered event handler from this task.

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: (javafx.scene.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.

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: ObservableList[String]

CSS styles classes used by this Node.

def styleClass_=(c: Iterable[String]): Unit

Sets the list of CSS styles classes, replacing the prior content.

def style_=(v: String): Unit

def stylesheets: ObservableList[String]

Gets an observable list of string URLs linking to the stylesheets to use with this Parent's contents.

def stylesheets_=(c: Iterable[String]): Unit

Sets the list of stylesheets URLs, replacing the prior content.

final def synchronized[T0](arg0: ⇒ T0): T0

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

def transforms: ObservableList[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.

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

def vgrow_=(p: Priority): Unit

Sets the vertical grow priority for this Node inside its parent.

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(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def content: ObservableList[javafx.scene.Node]

Gets the list of children of this Group.

def content_=(n: Node): Unit

Sets a child, replacing the prior content.

def content_=(c: Iterable[Node]): Unit

Sets the list of children, replacing the prior content.