Controls/io.nacular.doodle.controls/ProgressBar

ProgressBar

class ProgressBar(model: ConfinedValueModel<Double> = BasicConfinedValueModel(0.0 .. 100.0), val orientation: Orientation = Horizontal) : ProgressIndicator(source)

Represents a progress indicator that can be Horizontal or Vertical.

Parameters

model

containing range and value

orientation

of the control

Constructors

ProgressBar

constructor(model: ConfinedValueModel<Double> = BasicConfinedValueModel(0.0 .. 100.0), orientation: Orientation = Horizontal)

constructor(range: ClosedRange<Double> = 0.0 .. 100.0, value: Double = range.start, orientation: Orientation = Horizontal)

Creates a ProgressBar with a given range and starting value.

Properties

acceptsThemes

var acceptsThemes: Boolean

accessibilityDescriptionProvider

var accessibilityDescriptionProvider: View?

accessibilityLabel

var accessibilityLabel: String?

accessibilityLabelProvider

var accessibilityLabelProvider: View?

accessibilityRole

var accessibilityRole: AccessibilityRole?

backgroundColor

var backgroundColor: Color?

behavior

var behavior: Behavior<ProgressIndicator>?

Defines the control's look and feel

boundingBox

var boundingBox: Rectangle

bounds

var bounds: Rectangle

boundsChanged

val boundsChanged: PropertyObservers<View, Rectangle>

camera

var camera: Camera

cameraChanged

val cameraChanged: PropertyObservers<View, Camera>

changed

val changed: PropertyObservers<ProgressIndicator, Double>

children

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>

cursor

var cursor: Cursor?

cursorChanged

val cursorChanged: PropertyObservers<View, Cursor?>

displayChanged

val displayChanged: BooleanObservers

displayed

val displayed: Boolean

displayRect

val displayRect: Rectangle

displayRectHandlingChanged

val displayRectHandlingChanged: BooleanObservers

dragRecognizer

var dragRecognizer: DragRecognizer?

dropReceiver

var dropReceiver: DropReceiver?

enabled

var enabled: Boolean

enabledChanged

val enabledChanged: BooleanObservers

firstRender

val firstRender: ChangeObservers<View>

focusabilityChanged

val focusabilityChanged: BooleanObservers

focusable

open override var focusable: Boolean

focusChanged

val focusChanged: BooleanObservers

focusCycleRoot

protected val focusCycleRoot: View?

focusTraversalPolicy

protected open var focusTraversalPolicy: FocusTraversalPolicy?

font

var font: Font?

foregroundColor

var foregroundColor: Color?

hasFocus

var hasFocus: Boolean

height

val height: Double

idealSize

val idealSize: Size

insets

protected open var insets: Insets

isFocusCycleRoot

protected open var isFocusCycleRoot: Boolean

keyChanged

val keyChanged: Pool<KeyListener>

keyFilter

val keyFilter: Pool<KeyListener>

layout

protected open var layout: Layout?

limitsChanged

val limitsChanged: PropertyObservers<ProgressIndicator, ClosedRange<Double>>

localContentDirection

var localContentDirection: ContentDirection?

mirrored

val mirrored: Boolean

mirrorWhenRightLeft

var mirrorWhenRightLeft: Boolean

model

var model: ConfinedValueModel<Double>

Underlying model representing the current progress within a range.

monitorsDisplayRect

var monitorsDisplayRect: Boolean

nextInAccessibleReadOrder

var nextInAccessibleReadOrder: View?

opacity

var opacity: Float

opacityChanged

val opacityChanged: PropertyObservers<View, Float>

orientation

val orientation: Orientation

parent

var parent: View?

parentChanged

val parentChanged: PropertyObservers<View, View?>

pointerChanged

val pointerChanged: Pool<PointerListener>

pointerFilter

val pointerFilter: Pool<PointerListener>

pointerMotionChanged

val pointerMotionChanged: Pool<PointerMotionListener>

pointerMotionFilter

val pointerMotionFilter: Pool<PointerMotionListener>

pointerMotionPassedThrough

val pointerMotionPassedThrough: Pool<PointerMotionListener>

pointerPassedThrough

val pointerPassedThrough: Pool<PointerListener>

position

val position: Point

preferredSize

var preferredSize: View.(min: Size, max: Size) -> Size

progress

var progress: Double

Value from 0 to 1 representing the progress from the model's start to end

prospectiveBounds

val prospectiveBounds: Rectangle

range

var range: ClosedRange<Double>

Returns the model's range

rendered

var rendered: Boolean

size

override val size: Size

sizeAuditor

var sizeAuditor: View.SizeAuditor?

styleChanged

val styleChanged: ChangeObservers<View>

toolTipText

var toolTipText: String

transform

open var transform: AffineTransform

transformChanged

val transformChanged: PropertyObservers<View, AffineTransform>

value

var value: Double

Current progress value derived from model

visibilityChanged

val visibilityChanged: BooleanObservers

visible

var visible: Boolean

width

val width: Double

val x: Double

val y: Double

zOrder

var zOrder: Int

Functions

addedToDisplay

protected open fun addedToDisplay()

ancestorOf

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

child

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

contains

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

Delegates to behavior

protected operator fun contains(child: View): Boolean

contentDirectionChanged

protected fun contentDirectionChanged()

cursorChanged

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

doLayout

protected fun doLayout()

protected open fun doLayout(min: Size, current: Size, max: Size)

enabledChanged

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

filterKeyEvent

protected open fun filterKeyEvent(event: KeyEvent)

filterPointerEvent

protected open fun filterPointerEvent(event: PointerEvent)

filterPointerMotionEvent

protected open fun filterPointerMotionEvent(event: PointerEvent)

fromAbsolute

fun fromAbsolute(point: Point): Point

get

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

handleDisplayRectEvent

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

handleKeyEvent

protected open fun handleKeyEvent(event: KeyEvent)

handlePointerEvent

protected open fun handlePointerEvent(event: PointerEvent)

handlePointerMotionEvent

protected open fun handlePointerMotionEvent(event: PointerEvent)

intersects

open infix fun intersects(point: Point): Boolean

relayout

protected open fun relayout()

relayoutNow

protected open fun relayoutNow()

removedFromDisplay

protected open fun removedFromDisplay()

render

open override fun render(canvas: Canvas)

Delegates to behavior

rerender

fun rerender()

rerenderNow

fun rerenderNow()

revalidate

protected fun revalidate()

set

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

styleChanged

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

suggestBounds

fun suggestBounds(value: Rectangle)

fun suggestBounds(x: Double, y: Double, width: Double, height: Double)

suggestCenter

fun suggestCenter(at: Point)

suggestHeight

fun suggestHeight(value: Double)

suggestPosition

fun suggestPosition(value: Point)

fun suggestPosition(x: Double, y: Double)

suggestSize

fun suggestSize(value: Size)

fun suggestSize(width: Double, height: Double)

suggestWidth

fun suggestWidth(value: Double)

suggestX

fun suggestX(value: Double)

suggestY

fun suggestY(value: Double)

toAbsolute

fun toAbsolute(point: Point): Point

toLocal

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

toolTipText

open fun toolTipText(for: PointerEvent): String

toParent

fun toParent(point: Point): Point