controls/io.nacular.doodle.controls.table/DynamicTable

DynamicTable

open class DynamicTable<T, M : DynamicListModel<T>>( model: M, selectionModel: SelectionModel<Int>? = null, scrollCache: Int = 0, block: ColumnFactory<T>.() -> Unit) : Table<T, M> (source)

Inheritors

Constructors

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

Types

object Companion

Properties

protected open override val factory: ColumnFactory<T>

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

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

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

val height: Double

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

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

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

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 Table is within a ScrollPanel.

scrollToSelection

fun scrollToSelection()

Scrolls the last selected item into view if the Table 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