controls/io.nacular.doodle.controls.dropdown/MutableSelectBox

MutableSelectBox

class MutableSelectBox<T, M : MutableListModel<T>>(model: M, boxItemVisualizer: ItemVisualizer<T, IndexedItem>? = null, listItemVisualizer: ItemVisualizer<T, IndexedItem>? = boxItemVisualizer) : SelectBox<T, M> , Editable(source)

A dropdown control that can be edited.

Parameters

model

used to represent the underlying choices

boxItemVisualizer

to render the selected item within the select box

listItemVisualizer

to render each item within the list of choices

Constructors

MutableSelectBox

constructor(model: M, boxItemVisualizer: ItemVisualizer<T, IndexedItem>? = null, listItemVisualizer: ItemVisualizer<T, IndexedItem>? = boxItemVisualizer)

Properties

editing

val editing: Boolean

Indicates whether there is an ongoing edit operation

editor

var editor: SelectBoxEditor<T>?

Controls how editing is done

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?

behavior

var behavior: SelectBoxBehavior<T, M>?

Controls the SelectBox's look and behavior.

boundingBox

var boundingBox: Rectangle

bounds

override var bounds: Rectangle

boundsChanged

val boundsChanged: PropertyObservers<View, Rectangle>

boxCellAlignment

var boxCellAlignment: ConstraintDslContext.(Bounds) -> Unit?

Defines how the contents within the drop-down box should be aligned.

boxItemVisualizer

val boxItemVisualizer: ItemVisualizer<T, IndexedItem>?

to render the selected item within the select box

camera

var camera: Camera

cameraChanged

val cameraChanged: PropertyObservers<View, Camera>

changed

val changed: ChangeObservers<SelectBox<T, M>>

Broadcasts changes SelectBox

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

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?

hasFocus

var hasFocus: Boolean

height

override var height: Double

idealSize

override var idealSize: Size?

insets

protected open var insets: Insets

isEmpty

val isEmpty: Boolean

Indicates whether the option list is empty

isFocusCycleRoot

protected open var isFocusCycleRoot: Boolean

keyChanged

val keyChanged: Pool<KeyListener>

keyFilter

val keyFilter: Pool<KeyListener>

layout

protected open var layout: Layout?

listCellAlignment

var listCellAlignment: ConstraintDslContext.(Bounds) -> Unit?

Defines how the contents of each choice be aligned.

listItemVisualizer

val listItemVisualizer: ItemVisualizer<T, IndexedItem>?

to render each item within the list of choices

localContentDirection

var localContentDirection: ContentDirection?

minimumSize

override var minimumSize: Size

mirrored

val mirrored: Boolean

mirrorWhenRightLeft

var mirrorWhenRightLeft: Boolean

model

protected open val model: M

used to represent the underlying choices

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

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

override var position: Point

rendered

var rendered: Boolean

selection

var selection: Int

Index of currently selected value

size

override var size: Size

sizePreferencesChanged

val sizePreferencesChanged: PropertyObservers<View, View.SizePreferences>

styleChanged

val styleChanged: ChangeObservers<View>

toolTipText

var toolTipText: String

transform

open var transform: AffineTransform

transformChanged

val transformChanged: PropertyObservers<View, AffineTransform>

value

open val value: Result<T>

Currently selected value

visibilityChanged

val visibilityChanged: BooleanObservers

visible

override var visible: Boolean

width

override var width: Double

override var x: Double

override var y: Double

zOrder

var zOrder: Int

Functions

cancelEditing

open override fun cancelEditing()

Requests that the existing edit operation be canceled. This will discard the current process and retain the underlying value before editing started.

completeEditing

open override fun completeEditing()

Requests that the existing edit operation be completed. This will try to fetch a valid result and update the underlying value if possible.

set

fun set(value: T)

startEditing

fun startEditing()

Initiate editing of the control. This will notify the Behavior that editing is starting. The behavior can then use the editor to control the process.