controls/io.nacular.doodle.controls.table

Package-level declarations

Types

AbstractTableBehavior

interface AbstractTableBehavior<T : View> : Behavior<T>

CellInfo

interface CellInfo<T, R> : IndexedItem

CellVisualizer

typealias CellVisualizer<Item, Field> = ItemVisualizer<Field, CellInfo<Item, Field>>

Column

interface Column<T>

ColumnBuilder

interface ColumnBuilder

ColumnFactory

interface ColumnFactory<T>

ColumnInfo

data class ColumnInfo<K, V, T>(val header: View? = null, val visualizer: CellVisualizer<Pair<K, V>, T>, val footer: View? = null, val builder: ColumnBuilder.() -> Unit)

Data describing a KeyValueTable column.

ColumnSizePolicy

interface ColumnSizePolicy

Defines how columns within Table and related controls are sized.

ConstrainedSizePolicy

object ConstrainedSizePolicy : ColumnSizePolicy

DynamicTable

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

EqualSizePolicy

object EqualSizePolicy : ColumnSizePolicy

ExpansionObserver

typealias ExpansionObserver<T> = (source: TreeTable<T, *>, paths: Set<Path<Int>>) -> Unit

Created by Nicholas Eddy on 5/5/19.

ExpansionObservers

typealias ExpansionObservers<T> = SetPool<ExpansionObserver<T>>

KeyValueModel

interface KeyValueModel<K, V> : ListModel<Pair<K, V>>

Map based model used with KeyValueTable.

KeyValueTable

class KeyValueTable<K, V>(model: KeyValueModel<K, V>, keyColumn: ColumnInfo<K, V, K>, valueColumn: ColumnInfo<K, V, V>, selectionModel: SelectionModel<Int>? = null, scrollCache: Int = 0) : Table<Pair<K, V>, KeyValueModel<K, V>>

A visual component that renders an immutable list of key (K) - value (V) pairs using a TableBehavior. 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.

MetaRowGeometry

class MetaRowGeometry(val insetTop: Double = 0.0, val insetBottom: Double = 0.0, val height: Double = 0.0)

Indicates the y-offset and height of a table's header.

MetaRowVisibility

enum MetaRowVisibility : Enum<MetaRowVisibility>

MutableColumn

interface MutableColumn<T, R> : Column<R>

MutableColumnBuilder

interface MutableColumnBuilder<T, R> : ColumnBuilder

MutableColumnFactory

interface MutableColumnFactory<T>

MutableTable

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

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

ProportionalSizePolicy

object ProportionalSizePolicy : ColumnSizePolicy

SimpleKeyValueModel

class SimpleKeyValueModel<K, V>(map: Map<K, V>) : SimpleListModel<Pair<K, V>> , KeyValueModel<K, V>

KeyValueModel that simply wraps a Map

Sorter

typealias Sorter<T, S> = Extractor<T, S>

Table

open class Table<T, M : ListModel<T>>(val model: M, val selectionModel: SelectionModel<Int>? = null, scrollCache: Int = 0, columns: ColumnFactory<T>.() -> Unit) : View, ListLike, Selectable<Int>

A visual component that renders an immutable list of items of type T using a TableBehavior. 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.

TableBehavior

abstract class TableBehavior<T> : AbstractTableBehavior<Table<T, *>>

Controls the look and feel for a Table.

TableCellEditor

interface TableCellEditor<T, R>

Defines how cells in a MutableTable are edited.

TreeTable

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

TreeTableBehavior

abstract class TreeTableBehavior<T> : AbstractTableBehavior<TreeTable<T, *>>

Controls the look and feel for a TreeTable.

Functions

footerCellGenerator

fun <T> footerCellGenerator(block: (table: T, column: Column<*>) -> View): AbstractTableBehavior.FooterCellGenerator<T>

Creates a FooterCellGenerator based on the given lambda.

headerCellGenerator

fun <T, A> headerCellGenerator(block: (table: T, column: Column<*>) -> View): AbstractTableBehavior.HeaderCellGenerator<T>

Creates a HeaderCellGenerator based on the given lambda.

map

fun <T, R> TreeModel<T>.map(mapper: (T) -> R): TreeModel<R>

fun <T, R> Iterator<T>.map(mapper: (T) -> R): Iterator<R>

fun <T : Any, R : Any> SelectionModel<T>.map(mapper: (T) -> R?, unmapper: (R) -> T?): SelectionModel<R>

mapNotNull

fun <T, R : Any> Iterator<T>.mapNotNull(mapper: (T) -> R?): Iterator<R>

metaRowPositioner

fun <T> metaRowPositioner(block: (table: T) -> MetaRowGeometry): AbstractTableBehavior.MetaRowPositioner<T>

Creates a MetaRowPositioner based on the given lambda.

simpleTableCellEditor

fun <T, R> simpleTableCellEditor(cell: T.() -> R, result: T.(updatedCell: R) -> T, cellEditor: (table: MutableTable<T, *>, column: MutableColumn<T, R>, cell: R, index: Int, current: View, result: (R) -> T) -> EditOperation<R>): TableCellEditor<T, R>

Creates a TableCellEditor that modifies a single cell R within a row T.

tableCellEditor

fun <T, R> tableCellEditor(block: (table: MutableTable<T, *>, row: T, column: MutableColumn<T, R>, index: Int, current: View) -> EditOperation<T>): TableCellEditor<T, R>

DSL for creating TableCellEditor from a lambda.