controls/io.nacular.doodle.controls.range/CircularRangeSlider

CircularRangeSlider

open class CircularRangeSlider<T : Comparable<T>>(model: ConfinedRangeModel<T>, interpolator: Interpolator<T>, function: InvertibleFunction = LinearFunction) : RangeValueSlider<T> (source)

Represents a range selection slider that is circular.

Parameters

model

containing range and value

interpolator

used to map T -> Double and back

Constructors

CircularRangeSlider

constructor(model: ConfinedRangeModel<T>, interpolator: Interpolator<T>, function: InvertibleFunction = LinearFunction)

Types

Companion

object Companion

Properties

behavior

var behavior: Behavior<CircularRangeSlider<T>>?

Behavior that controls rendering and other interactions.

changed

val changed: PropertyObservers<CircularRangeSlider<T>, ClosedRange<T>>

Notifies of changes to value.

limitsChanged

val limitsChanged: PropertyObservers<CircularRangeSlider<T>, ClosedRange<T>>

Notifies of changes to value.

Inherited 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?

boundingBox

var boundingBox: Rectangle

bounds

var bounds: Rectangle

boundsChanged

val boundsChanged: PropertyObservers<View, Rectangle>

camera

var camera: Camera

cameraChanged

val cameraChanged: PropertyObservers<View, Camera>

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

displayChange

val ~~displayChange~~: BooleanObservers

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

fraction

var fraction: ClosedRange<Float>

Value of the slider as a fraction range between 0-1.

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?

localContentDirection

var localContentDirection: ContentDirection?

marker

var marker: Marker<T>?

Provides marks that should show up on the slider.

marks

val <T : Comparable<T>> RangeValueSlider<T>.marks: Sequence<Float>

The sequence of marks for a RangeValueSlider or emptySequence() if it has none.

mirrored

val mirrored: Boolean

mirrorWhenRightLeft

var mirrorWhenRightLeft: Boolean

model

var model: ConfinedRangeModel<T>

Model that represents the slider's value and range.

monitorsDisplayRect

var monitorsDisplayRect: Boolean

nextInAccessibleReadOrder

var nextInAccessibleReadOrder: View?

opacity

var opacity: Float

opacityChanged

val opacityChanged: PropertyObservers<View, Float>

parent

var parent: View?

parentChange

val ~~parentChange~~: PropertyObservers<View, 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

prospectiveBounds

val prospectiveBounds: Rectangle

range

var range: ClosedRange<T>

Slider's current range: start - end.

rendered

var rendered: Boolean

size

override val size: Size

sizeAuditor

var sizeAuditor: View.SizeAuditor?

snappingPolicy

var snappingPolicy: SnappingPolicy<T>?

Determines how the slider snaps to marks.

snapSize

var ~~snapSize~~: Double?

snapToTicks

var ~~snapToTicks~~: Boolean

Indicates whether the slider should only take on values at the specify tick interval.

styleChanged

val styleChanged: ChangeObservers<View>

ticks

var ~~ticks~~: Int

Number of ticks the slider should have.

toolTipText

var toolTipText: String

transform

open var transform: AffineTransform

transformChanged

val transformChanged: PropertyObservers<View, AffineTransform>

value

var value: ClosedRange<T>

Slider's current value.

visibilityChanged

val visibilityChanged: BooleanObservers

visible

var visible: Boolean

width

val width: Double

val x: Double

val y: Double

zOrder

var zOrder: Int

Functions

changed

protected open override fun changed(old: ClosedRange<T>, new: ClosedRange<T>)

Notifies of changes to value

contains

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

limitsChanged

protected open override fun limitsChanged(old: ClosedRange<T>, new: ClosedRange<T>)

Notifies of changes to range

render

open override fun render(canvas: Canvas)

ticksChanged

protected open override fun ticksChanged()

Notifies of changes to ticks

Inherited functions

addedToDisplay

protected open fun addedToDisplay()

ancestorOf

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

child

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

contains

protected operator fun contains(child: View): Boolean

contentDirectionChanged

protected fun contentDirectionChanged()

cursorChanged

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

decrement

fun decrement(percent: Float = 0.1f)

decrementEnd

fun decrementEnd(percent: Float = 0.1f)

decrementStart

fun decrementStart(percent: Float = 0.1f)

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)

increment

fun increment(percent: Float = 0.1f)

incrementEnd

fun incrementEnd(percent: Float = 0.1f)

incrementStart

fun incrementStart(percent: Float = 0.1f)

intersects

open infix fun intersects(point: Point): Boolean

mark

fun <T : Comparable<T>> RangeValueSlider<T>.mark(vararg using: T)

Sets the RangeValueSlider's marker based on the given values.

fun <T : Comparable<T>> RangeValueSlider<T>.mark(using: Iterable<T>)

Sets the RangeValueSlider's marker based on the given Iterable.

markerChanged

protected open fun markerChanged()

relayout

protected open fun relayout()

relayoutNow

protected open fun relayoutNow()

removedFromDisplay

protected open fun removedFromDisplay()

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