controls/io.nacular.doodle.controls/LazyPhoto

LazyPhoto

@ExperimentalCoroutinesApi

class LazyPhoto(pendingImage: Deferred<Image>, initialized: (imageSize: Size) -> Unit = {}, placeHolder: Canvas.() -> Unit = {}) : View(source)

A simple wrapper around a deferred Image. It renders a placeHolder while the image loads. Then the image is scaled to fit within the bounds of the Photo when it finally loads.

Parameters

pendingImage

to render when loaded

initialized

notified when loaded

placeHolder

used to render while the image loads

Constructors

constructor(pendingImage: Deferred<Image>, initialized: (imageSize: Size) -> Unit = {}, placeHolder: Canvas.() -> Unit = {})

Inherited properties

var acceptsThemes: Boolean

accessibilityDescriptionProvider

var accessibilityDescriptionProvider: View?

accessibilityLabel

var accessibilityLabel: String?

accessibilityLabelProvider

var accessibilityLabelProvider: View?

accessibilityRole

var accessibilityRole: AccessibilityRole?

backgroundColor

var backgroundColor: Color?

var boundingBox: Rectangle

override var bounds: Rectangle

val boundsChanged: PropertyObservers<View, Rectangle>

var camera: Camera

val cameraChanged: PropertyObservers<View, Camera>

protected open val children: ObservableList<View>

childrenChanged

protected val childrenChanged: Pool<ChildObserver<View>>

childrenClipPath

protected var childrenClipPath: View.ClipPath?

clipCanvasToBounds

protected var clipCanvasToBounds: Boolean

contentDirection

val contentDirection: ContentDirection

contentDirectionChanged

val contentDirectionChanged: ChangeObservers<View>

var cursor: Cursor?

val cursorChanged: PropertyObservers<View, Cursor?>

val displayChange: BooleanObservers

val displayed: Boolean

val displayRect: Rectangle

displayRectHandlingChanged

val displayRectHandlingChanged: BooleanObservers

var dragRecognizer: DragRecognizer?

var dropReceiver: DropReceiver?

var enabled: Boolean

val enabledChanged: BooleanObservers

val firstRender: ChangeObservers<View>

focusabilityChanged

val focusabilityChanged: BooleanObservers

open var focusable: Boolean

val focusChanged: BooleanObservers

protected val focusCycleRoot: View?

focusTraversalPolicy

protected open var focusTraversalPolicy: FocusTraversalPolicy?

var font: Font?

foregroundColor

var foregroundColor: Color?

var hasFocus: Boolean

override var height: Double

override var idealSize: Size?

protected open var insets: Insets

isFocusCycleRoot

protected open var isFocusCycleRoot: Boolean

val keyChanged: Pool<KeyListener>

val keyFilter: Pool<KeyListener>

protected open var layout: Layout?

localContentDirection

var localContentDirection: ContentDirection?

override var minimumSize: Size

val mirrored: Boolean

mirrorWhenRightLeft

var mirrorWhenRightLeft: Boolean

monitorsDisplayRect

var monitorsDisplayRect: Boolean

nextInAccessibleReadOrder

var nextInAccessibleReadOrder: View?

var opacity: Float

val opacityChanged: PropertyObservers<View, Float>

var parent: View?

val parentChange: PropertyObservers<View, View?>

val pointerChanged: Pool<PointerListener>

val pointerFilter: Pool<PointerListener>

pointerMotionChanged

val pointerMotionChanged: Pool<PointerMotionListener>

pointerMotionFilter

val pointerMotionFilter: Pool<PointerMotionListener>

pointerMotionPassedThrough

val pointerMotionPassedThrough: Pool<PointerMotionListener>

pointerPassedThrough

val pointerPassedThrough: Pool<PointerListener>

override var position: Point

var rendered: Boolean

override var size: Size

sizePreferencesChanged

val sizePreferencesChanged: PropertyObservers<View, View.SizePreferences>

val styleChanged: ChangeObservers<View>

var toolTipText: String

open var transform: AffineTransform

transformChanged

val transformChanged: PropertyObservers<View, AffineTransform>

visibilityChanged

val visibilityChanged: BooleanObservers

override var visible: Boolean

override var width: Double

override var x: Double

override var y: Double

var zOrder: Int

Functions

open override fun render(canvas: Canvas)

Inherited functions

protected open fun addedToDisplay()

protected open infix fun ancestorOf(view: View): Boolean

protected open fun child(at: Point): View?

protected operator fun contains(child: View): Boolean

open operator override fun contains(point: Point): Boolean

contentDirectionChanged

protected fun contentDirectionChanged()

protected fun cursorChanged(old: Cursor?, new: Cursor?)

protected open fun doLayout()

protected fun enabledChanged(old: Boolean, new: Boolean, filter: (View) -> Boolean)

protected open fun filterKeyEvent(event: KeyEvent)

filterPointerEvent

protected open fun filterPointerEvent(event: PointerEvent)

filterPointerMotionEvent

protected open fun filterPointerMotionEvent(event: PointerEvent)

fun fromAbsolute(point: Point): Point

operator fun get(traversalType: FocusTraversalPolicy.TraversalType): Set<KeyState>?

handleDisplayRectEvent

protected open fun handleDisplayRectEvent(old: Rectangle, new: Rectangle)

protected open fun handleKeyEvent(event: KeyEvent)

handlePointerEvent

protected open fun handlePointerEvent(event: PointerEvent)

handlePointerMotionEvent

protected open fun handlePointerMotionEvent(event: PointerEvent)

open infix fun intersects(point: Point): Boolean

protected open fun relayout()

removedFromDisplay

protected open fun removedFromDisplay()

fun rerenderNow()

protected fun revalidate()

operator fun set(traversalType: FocusTraversalPolicy.TraversalType, keyStates: Set<KeyState>?)

shouldHandlePointerEvent

protected open fun shouldHandlePointerEvent(event: PointerEvent): Boolean

shouldHandlePointerMotionEvent

protected open fun shouldHandlePointerMotionEvent(event: PointerEvent): Boolean

shouldYieldFocus

open fun shouldYieldFocus(): Boolean

protected fun styleChanged(filter: (View) -> Boolean)

fun toAbsolute(point: Point): Point

fun toLocal(point: Point, from: View?): Point

open fun toolTipText(for: PointerEvent): String

fun toParent(point: Point): Point