c

Fx.Button

class _Class extends Button.Like

Ordering
  1. Alphabetic
Inherited
  1. Button
  2. Button.Like
  3. Label.Like
  4. A.Control
  5. A.Region
  6. A.Parent
  7. A.Node
  8. A.Node._methods
  9. A.Node._events
  10. A.Node._events._onContextMenu
  11. A.Node._events._onZoom
  12. A.Node._events._onTouch
  13. A.Node._events._onSwipe
  14. A.Node._events._onScroll
  15. A.Node._events._onRotate
  16. A.Node._events._onKey
  17. A.Node._events._onMouseAndDrag
  18. A.Node._pro
  19. A.Node.Like
  20. A.Delegate.Gui
  21. Any.Ref.Extra.Property
  22. A.Delegate.Gui._eventBase
  23. Any.Ref.Extra.Event
  24. Any.Ref.Extra.Event0
  25. Any.Ref.Extra.Event.Like
  26. Any.Ref.Extra.Like
  27. scala.AnyRef
  28. scala.Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type

  1. type javafx.scene.control.Button = javafx.scene.control.Button
    Attributes
    protected
    Definition Classes
    _ClassLikeLike_Trait_Class_TraitLike_Trait

Constructor

  1. new Button()
    Definition Classes
    _Class

Method

  1. def arm: Unit

    Arm

    Arm

    Arms the button

    Definition Classes
    Like
  2. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  3. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  4. def disarm: Unit

    Disarms

    Disarms

    Disarms the button

    Definition Classes
    Like
  5. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  6. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  7. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  8. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  9. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  10. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  11. final def notify(): Unit
    Definition Classes
    AnyRef
  12. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  13. def parent: A.Parent

    Parent

    Parent

    Returns node Parent

    If this node has not been added to a scene graph, then parent will be null

    Definition Classes
    _methods
  14. def psedoClasses: Any.Collection.M[Style.Pseudo.Class]

    Mutable pseudo-class states

    Mutable pseudo-class states

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

    Definition Classes
    _methods
  15. final def real: javafx.scene.control.Button

    JavaFX peer

    JavaFX peer

    Returns the real JavaFX peer, which makes GUI happen

    It can be manipulated directly

    Definition Classes
    _Trait
  16. 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 reposition it

    Definition Classes
    _methods
  17. def scene: Scene

    Scene

    Scene

    Returns node Scene

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

    Definition Classes
    _methods
  18. def styleClasses: Idx.M[Style.Class]

    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

    Definition Classes
    _methods
  19. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  20. def toString(): String
    Definition Classes
    AnyRef → Any
  21. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  22. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  23. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Operator

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any

Property

  1. def alignmentPro: Pro.OM[Geometry.Pos]

    Alignment

    Alignment

    Specifies how the text and graphic within the Labeled should be aligned when there is empty space within the Label.Like

    Definition Classes
    Like
  2. def armedPro: Pro.O[Boolean]

    Armed

    Armed

    Indicates that the button has been "armed" such that a mouse release will cause the button's action to be invoked

    This is subtly different from pressed

    Pressed indicates that the mouse has been pressed on a Node and has not yet been released

    arm however also takes into account whether the mouse is actually over the button and pressed

    Definition Classes
    Like
  3. def backgroundPro: Pro.OM[A.Region.Background]

    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

    Definition Classes
    _Class
  4. def cachePro: Pro.OM[Boolean]

    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

    Definition Classes
    _pro
  5. def disabledPro: Pro.O[Boolean]

    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.

    Definition Classes
    _pro
  6. def disablePro: Pro.OM[Boolean]

    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

    Definition Classes
    _pro
  7. def focusedPro: Pro.O[Boolean]

    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

    Definition Classes
    _pro
  8. def focusTraversablePro: Pro.OM[Boolean]

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

    Definition Classes
    _pro
  9. def fontPro: Pro.OM[Text.Font]

    Font

    Font

    The default font to use for text

    If the Label.Like text is rich text then this font may or may not be used depending on the font information embedded in the rich text, but in any case where a default font is required, this font will be used

    Definition Classes
    Like
  10. def heightPro: Pro.O[Double]

    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

    Definition Classes
    _Class
  11. def hoverPro: Pro.O[Boolean]

    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.

    Definition Classes
    _pro
  12. def idPro: Pro.OM[String]

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

    Definition Classes
    _pro
  13. def layoutXPro: Pro.OM[Double]

    Layout x

    Layout x

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

    Definition Classes
    _pro
  14. def layoutYPro: Pro.OM[Double]

    Layout y

    Layout y

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

    Definition Classes
    _pro
  15. def managedPro: Pro.OM[Boolean]

    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.

    Definition Classes
    _pro
  16. def maxHeightPro: Pro.OM[Double]

    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

    Definition Classes
    _Class
  17. def maxWidthPro: Pro.OM[Double]

    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

    Definition Classes
    _Class
  18. def minHeightPro: Pro.OM[Double]

    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

    Definition Classes
    _Class
  19. def minWidthPro: Pro.OM[Double]

    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

    Definition Classes
    _Class
  20. def mouseTransparentPro: Pro.OM[Boolean]

    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.

    Definition Classes
    _pro
  21. def needsLayoutPro: Pro.O[Boolean]

    Needs layout check

    Needs layout check

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

    Definition Classes
    _Trait
  22. def opacityPro: Pro.OM[Double]

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

    Definition Classes
    _pro
  23. def paddingPro: Pro.OM[Insets]

    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.

    Definition Classes
    _Class
  24. def prefHeightPro: Pro.OM[Double]

    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

    Definition Classes
    _Class
  25. def prefWidthPro: Pro.OM[Double]

    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

    Definition Classes
    _Class
  26. def pressedPro: Pro.O[Boolean]

    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"

    Definition Classes
    _pro
  27. def rotatePro: Pro.OM[Double]

    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

    Definition Classes
    _pro
  28. def scaleXPro: Pro.OM[Double]

    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

    Definition Classes
    _pro
  29. def scaleYPro: Pro.OM[Double]

    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

    Definition Classes
    _pro
  30. def scaleZPro: Pro.OM[Double]

    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.

    Definition Classes
    _pro
  31. def stylePro: Pro.OM[Style]

    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

    Definition Classes
    _pro
  32. def textFillPro: Pro.OM[Paint]

    Paint used

    Paint used

    The Paint used to fill the text

    Definition Classes
    Like
  33. def textPro: Pro.OM[String]

    Display text

    Display text

    The text to display in the label

    The text may be null.

    Definition Classes
    Like
  34. def tooltipPro: Pro.OM[Tooltip]

    Tooltip

    Tooltip

    ToolTip for this control

    Definition Classes
    _Trait
  35. def translateXPro: Pro.OM[Double]

    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

    Definition Classes
    _pro
  36. def translateYPro: Pro.OM[Double]

    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

    Definition Classes
    _pro
  37. def translateZPro: Pro.OM[Double]

    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

    Definition Classes
    _pro
  38. def visiblePro: Pro.OM[Boolean]

    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

    Definition Classes
    _pro
  39. def widthPro: Pro.O[Double]

    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

    Definition Classes
    _Class

Event

  1. def onAction(run: (Action.Event) ⇒ Any): EventControl

    On action

    On action

    The button's action, which is invoked whenever the button is fired

    This may be due to the user clicking on the button with the mouse, or by a touch event, or by a key press, or if the developer programmatically invokes the fire() method

    Definition Classes
    Like
  2. def onActionRun(run: ⇒ Any): EventControl

    Run on action

    Run on action

    Overload of onAction

    Definition Classes
    Like
  3. def onContextMenu(on: (Event.ContextMenu) ⇒ Any): EventControl

    On context menu

    On context menu

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

    Definition Classes
    _onContextMenu
  4. def onDragDetected(on: (Event.Mouse) ⇒ Any): EventControl

    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

    Definition Classes
    _onMouseAndDrag
  5. def onDragDone(on: (Event.Drag) ⇒ Any): EventControl

    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

    Definition Classes
    _onMouseAndDrag
  6. def onDragDropped(on: (Event.Drag) ⇒ Any): EventControl

    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

    Definition Classes
    _onMouseAndDrag
  7. def onDragEntered(on: (Event.Drag) ⇒ Any): EventControl

    On drag entered

    On drag entered

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

    Definition Classes
    _onMouseAndDrag
  8. def onDragExited(on: (Event.Drag) ⇒ Any): EventControl

    On drag exited

    On drag exited

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

    Definition Classes
    _onMouseAndDrag
  9. def onDragOver(on: (Event.Drag) ⇒ Any): EventControl

    On drag over

    On drag over

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

    Definition Classes
    _onMouseAndDrag
  10. def onKeyPressed(on: (Event.Key) ⇒ Any): EventControl

    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

    Definition Classes
    _onKey
  11. def onKeyReleased(on: (Event.Key) ⇒ Any): EventControl

    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

    Definition Classes
    _onKey
  12. def onKeyTyped(on: (Event.Key) ⇒ Any): EventControl
    Definition Classes
    _onKey
  13. def onMouseClicked(on: (Event.Mouse) ⇒ Any): EventControl

    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

    Definition Classes
    _onMouseAndDrag
  14. def onMouseDragEntered(on: (Event.MouseDrag) ⇒ Any): EventControl

    On mouse drag entered

    On mouse drag entered

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

    Definition Classes
    _onMouseAndDrag
  15. def onMouseDragExited(on: (Event.MouseDrag) ⇒ Any): EventControl

    On mouse drag exited

    On mouse drag exited

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

    Definition Classes
    _onMouseAndDrag
  16. def onMouseDragged(on: (Event.Mouse) ⇒ Any): EventControl

    Mouse dragged

    Mouse dragged

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

    Definition Classes
    _onMouseAndDrag
  17. def onMouseDragOver(on: (Event.MouseDrag) ⇒ Any): EventControl

    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

    Definition Classes
    _onMouseAndDrag
  18. def onMouseDragReleased(on: (Event.MouseDrag) ⇒ Any): EventControl

    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

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

    Definition Classes
    _onMouseAndDrag
  19. def onMouseEntered(on: (Event.Mouse) ⇒ Any): EventControl

    On mouse entered

    On mouse entered

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

    Definition Classes
    _onMouseAndDrag
  20. def onMouseExited(on: (Event.Mouse) ⇒ Any): EventControl

    On mouse exited

    On mouse exited

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

    Definition Classes
    _onMouseAndDrag
  21. def onMouseLeftClicked(on: (Event.Mouse) ⇒ Any): EventControl

    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

    Definition Classes
    _onMouseAndDrag
  22. def onMouseMoved(on: (Event.Mouse) ⇒ Any): EventControl

    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

    Definition Classes
    _onMouseAndDrag
  23. def onMousePressed(on: (Event.Mouse) ⇒ Any): EventControl

    On mouse pressed

    On mouse pressed

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

    Definition Classes
    _onMouseAndDrag
  24. def onMouseReleased(on: (Event.Mouse) ⇒ Any): EventControl

    On mouse released

    On mouse released

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

    Definition Classes
    _onMouseAndDrag
  25. def onMouseRightClicked(on: (Event.Mouse) ⇒ Any): EventControl

    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

    Definition Classes
    _onMouseAndDrag
  26. def onRotate(on: (Event.Rotate) ⇒ Any): EventControl

    On rotate

    On rotate

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

    Definition Classes
    _onRotate
  27. def onRotationFinished(on: (Event.Rotate) ⇒ Any): EventControl

    On rotation finished

    On rotation finished

    Defines a function to be called when a rotation gesture ends

    Definition Classes
    _onRotate
  28. def onRotationStarted(on: (Event.Rotate) ⇒ Any): EventControl

    On rotation started

    On rotation started

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

    Definition Classes
    _onRotate
  29. def onScroll(on: (Event.Scroll) ⇒ Any): EventControl

    On scroll

    On scroll

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

    Definition Classes
    _onScroll
  30. def onScrollFinished(on: (Event.Scroll) ⇒ Any): EventControl

    On scroll finished

    On scroll finished

    Defines a function to be called when a scrolling gesture ends

    Definition Classes
    _onScroll
  31. def onScrollStarted(on: (Event.Scroll) ⇒ Any): EventControl

    On scroll started

    On scroll started

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

    Definition Classes
    _onScroll
  32. def onSwipeDown(on: (Event.Swipe) ⇒ Any): EventControl

    On swipe down

    On swipe down

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

    Definition Classes
    _onSwipe
  33. def onSwipeLeft(on: (Event.Swipe) ⇒ Any): EventControl

    On swipe left

    On swipe left

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

    Definition Classes
    _onSwipe
  34. def onSwipeRight(on: (Event.Swipe) ⇒ Any): EventControl

    On swipe right

    On swipe right

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

    Definition Classes
    _onSwipe
  35. def onSwipeUp(on: (Event.Swipe) ⇒ Any): EventControl

    On swipe up

    On swipe up

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

    Definition Classes
    _onSwipe
  36. def onTouchMoved(on: (Event.Touch) ⇒ Any): EventControl

    On touch moved

    On touch moved

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

    Definition Classes
    _onTouch
  37. def onTouchPressed(on: (Event.Touch) ⇒ Any): EventControl

    On touch pressed

    On touch pressed

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

    Definition Classes
    _onTouch
  38. def onTouchReleased(on: (Event.Touch) ⇒ Any): EventControl

    On touch released

    On touch released

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

    Definition Classes
    _onTouch
  39. def onTouchStationary(on: (Event.Touch) ⇒ Any): EventControl

    On touch stationary

    On touch stationary

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

    Definition Classes
    _onTouch
  40. def onZoom(on: (Event.Zoom) ⇒ Any): EventControl

    On zoom

    On zoom

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

    Definition Classes
    _onZoom
  41. def onZoomFinished(on: (Event.Zoom) ⇒ Any): EventControl

    On zoom

    On zoom

    Defines a function to be called when a zooming gesture ends

    Definition Classes
    _onZoom
  42. def onZoomStarted(on: (Event.Zoom) ⇒ Any): EventControl

    On zoom

    On zoom

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

    Definition Classes
    _onZoom

Hidden

  1. def _addEvent(scope: AnyRef, _this: AnyRef): EventControl
    Attributes
    protected
    Definition Classes
    _Trait
  2. def _createGui: javafx.scene.control.Button
    Attributes
    protected
    Definition Classes
    _Class_Class_Trait
  3. def _fireEvent[T](scope: AnyRef, f: (T) ⇒ Any): Int
    Attributes
    protected[scalqa.Any.Ref.Extra]
    Definition Classes
    _TraitLike
  4. def _fireEvent0(scope: AnyRef): Int
    Attributes
    protected
    Definition Classes
    Event0
  5. def _fireFxEvent[P1](scope: AnyRef, p1: P1): Int
    Attributes
    protected
    Definition Classes
    _eventBase
  6. def _getPropertyOpt[T](name: AnyRef, dflt: ⇒ Opt[T]): Opt[T]
    Attributes
    protected
    Definition Classes
    Property
  7. def _onAfterCreateGuiRun(f: ⇒ Any): Util.EventControl
    Attributes
    protected
    Definition Classes
    _Trait
  8. def _onCreateGuiRun(real: ⇒ javafx.scene.control.Button): Opt[() ⇒ javafx.scene.control.Button]
    Attributes
    protected
    Definition Classes
    _Trait
  9. def _onEvent0(scope: AnyRef, f: () ⇒ Any): EventControl
    Attributes
    protected
    Definition Classes
    Event0
  10. def _onFxEvent[T <: javafx.event.Event, E](op: ObjectProperty[EventHandler[T]], as: (T) ⇒ E, on: (E) ⇒ Any): EventControl
    Attributes
    protected
    Definition Classes
    _eventBase
  11. def _onFxEvent[T <: javafx.event.Event](op: ObjectProperty[EventHandler[T]], on: () ⇒ Any): EventControl
    Attributes
    protected
    Definition Classes
    _eventBase
  12. def _onFxEvent[T <: javafx.event.Event](op: ObjectProperty[EventHandler[T]], on: (T) ⇒ Any): EventControl
    Attributes
    protected
    Definition Classes
    _eventBase
  13. def _removePropertyOpt[T](name: AnyRef): Opt[T]
    Attributes
    protected
    Definition Classes
    Property
  14. def _setPropertyOpt[T](name: AnyRef, value: T): Opt[T]
    Attributes
    protected
    Definition Classes
    Property