core/io.nacular.doodle.core/Display

Display

The top-level surface for presenting Views. An item must be added to the Display (either directly, or as a descendant of the Display) before it can be rendered or interact with the user.

Author

Nicholas Eddy

Properties

children

abstract val children: ObservableList<View>

The list of top-level items added to the Display

childrenChanged

abstract val childrenChanged: Pool<ChildObserver<Display>>

Notifies changes to children

contentDirection

abstract var contentDirection: ContentDirection

Indicates the direction of content within the Display. This is used to support right-to-left locales. Top-level Views without a View.localContentDirection specified will inherit this value and pass it on to their descendants that have no explicit value.

contentDirectionChanged

abstract val contentDirectionChanged: ChangeObservers<Display>

Fires when contentDirection changes.

cursor

abstract var cursor: Cursor?

The top-level cursor. This will be the cursor used for View hierarchies that do not have one set.

cursorChanged

abstract val cursorChanged: PropertyObservers<Display, Cursor?>

Fires when the display cursor changes

focusTraversalPolicy

abstract var focusTraversalPolicy: FocusTraversalPolicy?

insets

abstract var insets: Insets

Insets if any

layout

abstract var layout: Layout?

The layout applied

mirrored

open val mirrored: Boolean

true if contentDirection == RightLeft&&mirrorWhenRightLeft

mirroringChanged

abstract val mirroringChanged: ChangeObservers<Display>

Fires when mirrored changes.

mirrorWhenRightLeft

abstract var mirrorWhenRightLeft: Boolean

Indicates whether the Display should be mirrored (as though transformed using AffineTransform.flipHorizontally), when the contentDirection is RightLeft.

size

abstract val size: Size

The current size of the Display. This may be smaller than the client's screen in situations where the application is hosted within a window.

sizeChanged

abstract val sizeChanged: PropertyObservers<Display, Size>

Fires when the display re-sizes

transform

abstract var transform: AffineTransform

Affine transform applied to the View. This transform does not affect the Display's size or how it is handled by Layout. Hit-detection is handled correctly such that the pointer intersects with the Display as expected after transformation. So no additional handling is necessary in general. The default is Identity

Inherited properties

center

val Display.center: Point

The Display's center point in its coordinate system.

height

val Display.height: Double

The height of the Display

width

val Display.width: Double

The width of the Display

Functions

ancestorOf

abstract infix fun ancestorOf(view: View): Boolean

child

abstract fun child(at: Point): View?

abstract fun child(at: Point, predicate: (View) -> Boolean): View?

fill

abstract fun fill(fill: Paint)

Fills the Display's background with the given fill

fromAbsolute

abstract fun fromAbsolute(point: Point): Point

Maps a Point from absolute coordinate-space un-transformed Display, into this Display's coordinate-space. The result is different form the input if the Display's transform is not Identity.

iterator