controls/io.nacular.doodle.controls.list/HorizontalDynamicList

HorizontalDynamicList

class HorizontalDynamicList<T, M : DynamicListModel<T>>( model: M, itemVisualizer: ItemVisualizer<T, IndexedItem>? = null, selectionModel: SelectionModel<Int>? = null, numRows: Int = 1, scrollCache: Int = 0) : DynamicList<T, M> (source)

DynamicList that is intended to display contents horizontally with a configurable number of rows.

Parameters

model

that holds the data for this List

itemVisualizer

that maps T to View for each item in the List

selectionModel

that manages the List's selection state

numRows

to organize the items into

scrollCache

determining how many "hidden" rows are rendered above and below the List's view-port. A value of 0 means

Constructors

HorizontalDynamicList

constructor( model: M, itemVisualizer: ItemVisualizer<T, IndexedItem>? = null, selectionModel: SelectionModel<Int>? = null, numRows: Int = 1, scrollCache: Int = 0)

Types

object Companion

Properties

val numRows: Int

to organize the items into

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 behavior: ListBehavior<T>?

Controls how the List behaves and how its items are rendered. A List will not render without a behavior specified.

var boundingBox: Rectangle

var bounds: Rectangle

val boundsChanged: PropertyObservers<View, Rectangle>

var camera: Camera

val cameraChanged: PropertyObservers<View, Camera>

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

Defines how the contents of an item should be aligned within it.

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 displayChanged: 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>

firstSelectable

open override val firstSelectable: Int?

open override val firstSelection: Int?

firstVisibleItem

protected var firstVisibleItem: Int

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

val height: Double

val idealSize: Size

open override var insets: Insets

val isEmpty: Boolean

isFocusCycleRoot

open override var isFocusCycleRoot: Boolean

val itemsChanged: Pool<ItemsObserver<T>>

Notifies of changes to the list

val itemVisualizer: ItemVisualizer<T, IndexedItem>?

that maps T to View for each item in the List

val keyChanged: Pool<KeyListener>

val keyFilter: Pool<KeyListener>

open override val lastSelectable: Int?

open override val lastSelection: Int?

lastVisibleItem

protected var lastVisibleItem: Int

protected open var layout: Layout?

localContentDirection

var localContentDirection: ContentDirection?

val mirrored: Boolean

mirrorWhenRightLeft

var mirrorWhenRightLeft: Boolean

protected open val model: M

that holds the data for this List

monitorsDisplayRect

var monitorsDisplayRect: Boolean

nextInAccessibleReadOrder

var nextInAccessibleReadOrder: View?

open override val numItems: Int

var opacity: Float

val opacityChanged: PropertyObservers<View, Float>

var parent: View?

val ~~parentChange~~: PropertyObservers<View, View?>

val parentChanged: 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>

val position: Point

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

prospectiveBounds

val prospectiveBounds: Rectangle

var rendered: Boolean

open override val selection: Set<Int>

selectionAnchor

open override val selectionAnchor: Int?

selectionChanged

val selectionChanged: SetObservers<List<T, M>, Int>

Notifies of changes to the List's selection.

protected val selectionModel: SelectionModel<Int>?

that manages the List's selection state only visible items are rendered, but quick scrolling is more likely to show blank areas.

override val size: Size

var sizeAuditor: View.SizeAuditor?

val styleChanged: ChangeObservers<View>

var toolTipText: String

open var transform: AffineTransform

transformChanged

val transformChanged: PropertyObservers<View, AffineTransform>

visibilityChanged

val visibilityChanged: BooleanObservers

var visible: Boolean

val width: Double

var zOrder: Int

Inherited functions

protected open override fun addedToDisplay()

open override fun addSelection(items: Set<Int>)

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

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

open override fun clearSelection()

fun contains(value: T): Boolean

protected operator fun contains(child: View): Boolean

open operator fun contains(point: Point): Boolean

contentDirectionChanged

protected fun contentDirectionChanged()

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

protected fun doLayout()

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

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(index: Int): Result<T>

Returns the item at index if one exists, null otherwise.

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

handleDisplayRectEvent

protected open override 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 fun layout(view: View, item: T, index: Int): Rectangle?

open override fun next(after: Int): Int?

open override fun previous(before: Int): Int?

protected open fun relayout()

protected open fun relayoutNow()

removedFromDisplay

protected open override fun removedFromDisplay()

removeSelection

open override fun removeSelection(items: Set<Int>)

open override fun render(canvas: Canvas)

fun rerenderNow()

protected fun revalidate()

fun scrollTo(item: Int)

Scrolls item into view if the List is within a ScrollPanel.

scrollToSelection

fun scrollToSelection()

Scrolls the last selected item into view if the List is within a ScrollPanel.

open override fun selectAll()

open override fun selected(item: Int): Boolean

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

open override fun setSelection(items: Set<Int>)

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 suggestBounds(value: Rectangle)

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

fun suggestCenter(at: Point)

fun suggestHeight(value: Double)

suggestPosition

fun suggestPosition(value: Point)

fun suggestPosition(x: Double, y: Double)

fun suggestSize(value: Size)

fun suggestSize(width: Double, height: Double)

fun suggestWidth(value: Double)

fun suggestX(value: Double)

fun suggestY(value: Double)

fun toAbsolute(point: Point): Point

toggleSelection

open override fun toggleSelection(items: Set<Int>)

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

open fun toolTipText(for: PointerEvent): String

fun toParent(point: Point): Point

protected fun update(children: MutableList<View>, index: Int)

updateVisibleHeight

protected fun updateVisibleHeight()