controls/io.nacular.doodle.controls.table/TreeTable

TreeTable

open class TreeTable<T, M : TreeModel<T>>( model: M, val selectionModel: SelectionModel<Path<Int>>? = null, scrollCache: Int = 0, columns: ColumnFactory<T>.() -> Unit) : View, TreeLike(source)

A visual component that renders an immutable list of items of type T using a TreeTableBehavior. Items are obtained via the model and selection is managed via the optional selectionModel. Large ("infinite") lists are supported efficiently, since Table recycles the Views generated to render its items.

Note that this class assumes the given TreeModel is immutable and will not automatically respond to changes in the model.

TreeTable provides vertical scrolling internally, so it does not need to be embedded in a ScrollPanel or similar component, unless horizontal scrolling is desired.

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.

columns

factory to define the set of columns for the Table

Constructors

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

Properties

var behavior: TreeTableBehavior<T>?

val collapsed: ExpansionObservers<T>

val columns: List<Column<*>>

columnSizePolicy

var columnSizePolicy: ColumnSizePolicy

val expanded: ExpansionObservers<T>

protected open val factory: ColumnFactory<T>

firstSelectable

open override val firstSelectable: Path<Int>?

open override val firstSelection: Path<Int>?

var footerSticky: Boolean

footerVisibility

var footerVisibility: MetaRowVisibility

var headerSticky: Boolean

headerVisibility

var headerVisibility: MetaRowVisibility

open override var insets: Insets

open override val lastSelectable: Path<Int>?

open override val lastSelection: Path<Int>?

var model: M

that holds the data for the Table

open override val numRows: Int

open override val rootVisible: Boolean

open override val selection: Set<Path<Int>>

selectionAnchor

open override val selectionAnchor: Path<Int>?

selectionChanged

val selectionChanged: SetObservers<TreeTable<T, M>, Path<Int>>

selectionChanged_

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

protected val selectionModel: SelectionModel<Path<Int>>? = null

that manages the Table's selection state

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

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

val firstRender: ChangeObservers<View>

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

isFocusCycleRoot

protected open var isFocusCycleRoot: Boolean

val keyChanged: Pool<KeyListener>

val keyFilter: Pool<KeyListener>

protected open var layout: Layout?

localContentDirection

var localContentDirection: ContentDirection?

val mirrored: Boolean

mirrorWhenRightLeft

var mirrorWhenRightLeft: Boolean

monitorsDisplayRect

var monitorsDisplayRect: Boolean

nextInAccessibleReadOrder

var nextInAccessibleReadOrder: View?

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>

val position: Point

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

prospectiveBounds

val prospectiveBounds: Rectangle

var rendered: Boolean

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

Functions

protected open override fun addedToDisplay()

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

fun child(of: Path<Int>, path: Int): Result<T>

fun children(parent: Path<Int>): Iterator<T>

open override fun clearSelection()

open override fun collapse(path: Path<Int>)

open override fun collapseAll()

open override fun expand(path: Path<Int>)

open override fun expandAll()

open override fun expanded(path: Path<Int>): Boolean

operator fun get(path: Path<Int>): Result<T>

operator fun get(row: Int): Result<T>

handleDisplayRectEvent

protected open override fun handleDisplayRectEvent(old: Rectangle, new: Rectangle)

fun indexOfChild(parent: Path<Int>, child: T): Int

open override fun isLeaf(path: Path<Int>): Boolean

open override fun next(after: Path<Int>): Path<Int>?

fun numChildren(of: Path<Int>): Int

open override fun pathFromRow(index: Int): Path<Int>?

open override fun previous(before: Path<Int>): Path<Int>?

removedFromDisplay

protected open override fun removedFromDisplay()

removeSelection

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

open override fun rowFromPath(path: Path<Int>): Int?

fun scrollTo(item: Path<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: Path<Int>): Boolean

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

toggleSelection

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

open override fun visible(path: Path<Int>): Boolean

open override fun visible(row: Int): Boolean

Inherited functions

open fun addSelection(rows: Set<Int>, jvmWorkaround: Int = 0)

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

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

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(traversalType: FocusTraversalPolicy.TraversalType): Set<KeyState>?

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 open fun relayout()

protected open fun relayoutNow()

removeSelection

open fun removeSelection(rows: Set<Int>, jvmWorkaround: Int = 0)

open override fun render(canvas: Canvas)

fun rerenderNow()

protected fun revalidate()

open fun selected(row: Int): Boolean

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

open fun setSelection(rows: Set<Int>, jvmWorkaround: Int = 0)

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 fun toggleSelection(rows: Set<Int>, jvmWorkaround: Int = 0)

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

open fun toolTipText(for: PointerEvent): String

fun toParent(point: Point): Point