controls/io.nacular.doodle.controls.table/MutableTable

MutableTable

class MutableTable<T, M : MutableListModel<T>>(model: M, selectionModel: SelectionModel<Int>? = null, scrollCache: Int = 0, block: MutableColumnFactory<T>.() -> Unit) : DynamicTable<T, M> , Editable(source)

A visual component that renders a mutable list of items of type T using a TableBehavior.

Parameters

model

that holds the data for the Table

selectionModel

that manages the Table's selection state

scrollCache

determining how many "hidden" items are rendered above and below the Table's view-port. A value of 0 means only visible items are rendered, but quick scrolling is more likely to show blank areas.

block

factory to define the set of columns for the Table

See also

Constructors

constructor(model: M, selectionModel: SelectionModel<Int>? = null, scrollCache: Int = 0, block: MutableColumnFactory<T>.() -> Unit)

Types

class Sorting<T>(val column: MutableColumn<T, *>, val order: SortOrder)

Properties

val editing: Boolean

var sorting: List<MutableTable.Sorting<T>>

current sorting for the table default is ``emptyList()``. */

val sortingChanged: PropertyObservers<MutableTable<T, M>, List<MutableTable.Sorting<T>>>

Notifies changes to sorting

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: TableBehavior<T>?

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

val columns: List<Column<*>>

columnSizePolicy

var columnSizePolicy: ColumnSizePolicy

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

protected open override val factory: ColumnFactory<T>

val firstRender: ChangeObservers<View>

firstSelectable

open override val firstSelectable: Int?

open override val firstSelection: 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?

var footerSticky: Boolean

footerVisibility

var footerVisibility: MetaRowVisibility

foregroundColor

var foregroundColor: Color?

var hasFocus: Boolean

var headerSticky: Boolean

headerVisibility

var headerVisibility: MetaRowVisibility

override var height: Double

override var idealSize: Size?

open override var insets: Insets

val isEmpty: Boolean

isFocusCycleRoot

protected open var isFocusCycleRoot: Boolean

val keyChanged: Pool<KeyListener>

val keyFilter: Pool<KeyListener>

open override val lastSelectable: Int?

open override val lastSelection: Int?

protected open var layout: Layout?

localContentDirection

var localContentDirection: ContentDirection?

override var minimumSize: Size

val mirrored: Boolean

mirrorWhenRightLeft

var mirrorWhenRightLeft: Boolean

protected val model: M

that holds the data for the Table

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

open override val selection: Set<Int>

selectionAnchor

open override val selectionAnchor: Int?

selectionChanged

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

selectionChanged_

protected open val selectionChanged_: SetObserver<SelectionModel<Int>, Int>

protected val selectionModel: SelectionModel<Int>?

that manages the Table's selection state

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

fun add(value: T)

fun add(index: Int, values: T)

fun addAll(values: Collection<T>)

fun addAll(index: Int, values: Collection<T>)

open override fun cancelEditing()

fun clear()

completeEditing

open override fun completeEditing()

fun remove(value: T)

fun removeAll(values: Collection<T>)

fun removeAt(index: Int): Result<T>

fun retainAll(values: Collection<T>)

operator fun set(index: Int, value: T)

fun sort(by: MutableColumn<T, *>)

fun sortDescending(by: MutableColumn<T, *>)

fun startEditing(index: Int, column: MutableColumn<T, *>)

fun toggleSort(by: MutableColumn<T, *>)

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 override fun contains(point: Point): Boolean

contentDirectionChanged

protected fun contentDirectionChanged()

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

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

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

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

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

protected open fun relayout()

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()

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