controls/io.nacular.doodle.controls.tree/MutableTree

MutableTree

class MutableTree<T, M : MutableTreeModel<T>>(model: M, itemVisualizer: ItemVisualizer<T, ExpandableItem>? = null, selectionModel: SelectionModel<Path<Int>>? = null) : DynamicTree<T, M> , Editable(source)

Constructors

MutableTree

constructor(model: M, itemVisualizer: ItemVisualizer<T, ExpandableItem>? = null, selectionModel: SelectionModel<Path<Int>>? = null)

Properties

editing

val editing: Boolean

editor

var editor: TreeEditor<T>?

Inherited properties

acceptsThemes

var acceptsThemes: Boolean

accessibilityDescriptionProvider

var accessibilityDescriptionProvider: View?

accessibilityLabel

var accessibilityLabel: String?

accessibilityLabelProvider

var accessibilityLabelProvider: View?

accessibilityRole

var accessibilityRole: AccessibilityRole?

backgroundColor

var backgroundColor: Color?

behavior

var behavior: TreeBehavior<T>?

boundingBox

var boundingBox: Rectangle

bounds

override var bounds: Rectangle

boundsChanged

val boundsChanged: PropertyObservers<View, Rectangle>

camera

var camera: Camera

cameraChanged

val cameraChanged: PropertyObservers<View, Camera>

cellAlignment

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

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

children

protected open val children: ObservableList<View>

childrenChanged

protected val childrenChanged: Pool<ChildObserver<View>>

childrenClipPath

protected var childrenClipPath: View.ClipPath?

clipCanvasToBounds

protected var clipCanvasToBounds: Boolean

collapsed

val collapsed: ExpansionObservers<T>

contentDirection

val contentDirection: ContentDirection

contentDirectionChanged

val contentDirectionChanged: ChangeObservers<View>

cursor

var cursor: Cursor?

cursorChanged

val cursorChanged: PropertyObservers<View, Cursor?>

displayChange

val displayChange: BooleanObservers

displayed

val displayed: Boolean

displayRect

val displayRect: Rectangle

displayRectHandlingChanged

val displayRectHandlingChanged: BooleanObservers

dragRecognizer

var dragRecognizer: DragRecognizer?

dropReceiver

var dropReceiver: DropReceiver?

enabled

var enabled: Boolean

enabledChanged

val enabledChanged: BooleanObservers

expanded

val expanded: ExpansionObservers<T>

firstRender

val firstRender: ChangeObservers<View>

firstSelectable

open override val firstSelectable: Path<Int>?

firstSelection

open override val firstSelection: Path<Int>?

firstVisibleRow

protected var firstVisibleRow: Int

focusabilityChanged

val focusabilityChanged: BooleanObservers

focusable

open var focusable: Boolean

focusChanged

val focusChanged: BooleanObservers

focusCycleRoot

protected val focusCycleRoot: View?

focusTraversalPolicy

protected open var focusTraversalPolicy: FocusTraversalPolicy?

font

var font: Font?

foregroundColor

var foregroundColor: Color?

hasFocus

var hasFocus: Boolean

height

override var height: Double

idealSize

override var idealSize: Size?

insets

open override var insets: Insets

isFocusCycleRoot

open override var isFocusCycleRoot: Boolean

itemsChanged

val itemsChanged: Pool<ItemsObserver<T>>

itemVisualizer

val itemVisualizer: ItemVisualizer<T, ExpandableItem>?

keyChanged

val keyChanged: Pool<KeyListener>

keyFilter

val keyFilter: Pool<KeyListener>

lastSelectable

open override val lastSelectable: Path<Int>?

lastSelection

open override val lastSelection: Path<Int>?

lastVisibleRow

protected var lastVisibleRow: Int

layout

protected open var layout: Layout?

localContentDirection

var localContentDirection: ContentDirection?

minimumSize

override var minimumSize: Size

mirrored

val mirrored: Boolean

mirrorWhenRightLeft

var mirrorWhenRightLeft: Boolean

model

protected open val model: M

monitorsDisplayRect

var monitorsDisplayRect: Boolean

nextInAccessibleReadOrder

var nextInAccessibleReadOrder: View?

numRows

open override val numRows: Int

opacity

var opacity: Float

opacityChanged

val opacityChanged: PropertyObservers<View, Float>

parent

var parent: View?

parentChange

val parentChange: PropertyObservers<View, View?>

pointerChanged

val pointerChanged: Pool<PointerListener>

pointerFilter

val pointerFilter: Pool<PointerListener>

pointerMotionChanged

val pointerMotionChanged: Pool<PointerMotionListener>

pointerMotionFilter

val pointerMotionFilter: Pool<PointerMotionListener>

pointerMotionPassedThrough

val pointerMotionPassedThrough: Pool<PointerMotionListener>

pointerPassedThrough

val pointerPassedThrough: Pool<PointerListener>

position

override var position: Point

rendered

var rendered: Boolean

rootVisible

open override var rootVisible: Boolean

rowPositioner

protected var rowPositioner: TreeBehavior.RowPositioner<T>?

selection

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

selectionAnchor

open override val selectionAnchor: Path<Int>?

selectionChanged

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

selectionModel

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

size

override var size: Size

sizePreferencesChanged

val sizePreferencesChanged: PropertyObservers<View, View.SizePreferences>

styleChanged

val styleChanged: ChangeObservers<View>

toolTipText

var toolTipText: String

transform

open var transform: AffineTransform

transformChanged

val transformChanged: PropertyObservers<View, AffineTransform>

visibilityChanged

val visibilityChanged: BooleanObservers

visible

override var visible: Boolean

width

override var width: Double

override var x: Double

override var y: Double

zOrder

var zOrder: Int

Functions

add

fun add(path: Path<Int>, values: T)

addAll

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

cancelEditing

open override fun cancelEditing()

clear

fun clear()

completeEditing

open override fun completeEditing()

handleDisplayRectEvent

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

removeAt

fun removeAt(path: Path<Int>): Result<T>

set

operator fun set(path: Path<Int>, value: T)

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

startEditing

fun startEditing(path: Path<Int>)

Inherited functions

addedToDisplay

protected open override fun addedToDisplay()

addSelection

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

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

ancestorOf

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

child

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

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

children

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

clearSelection

open override fun clearSelection()

collapse

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

@JvmName(name = "collapseRows")

fun collapse(row: Int)

fun collapse(paths: Set<Path<Int>>)

@JvmName(name = "collapseRows")

fun collapse(rows: Set<Int>)

collapseAll

open override fun collapseAll()

contains

protected operator fun contains(child: View): Boolean

open operator override fun contains(point: Point): Boolean

contentDirectionChanged

protected fun contentDirectionChanged()

cursorChanged

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

doLayout

protected open fun doLayout()

enabledChanged

protected fun enabledChanged(old: Boolean, new: Boolean, filter: (View) -> Boolean)

expand

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

@JvmName(name = "expandRows")

fun expand(row: Int)

fun expand(paths: Set<Path<Int>>)

@JvmName(name = "expandRows")

fun expand(rows: Set<Int>)

expandAll

open override fun expandAll()

expanded

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

filterKeyEvent

protected open fun filterKeyEvent(event: KeyEvent)

filterPointerEvent

protected open fun filterPointerEvent(event: PointerEvent)

filterPointerMotionEvent

protected open fun filterPointerMotionEvent(event: PointerEvent)

fromAbsolute

fun fromAbsolute(point: Point): Point

get

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

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

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

handleKeyEvent

protected open fun handleKeyEvent(event: KeyEvent)

handlePointerEvent

protected open fun handlePointerEvent(event: PointerEvent)

handlePointerMotionEvent

protected open fun handlePointerMotionEvent(event: PointerEvent)

indexOfChild

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

intersects

open infix fun intersects(point: Point): Boolean

isLeaf

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

layout

protected fun layout(view: View, node: T, path: Path<Int>, index: Int)

makeVisible

fun makeVisible(path: Path<Int>)

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

numChildren

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

pathFromRow

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

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

refreshAll

protected fun refreshAll()

relayout

protected open fun relayout()

removedFromDisplay

protected open override fun removedFromDisplay()

removeSelection

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

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

render

open override fun render(canvas: Canvas)

rerender

fun rerender()

rerenderNow

fun rerenderNow()

revalidate

protected fun revalidate()

rowFromPath

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

scrollTo

fun scrollTo(path: Path<Int>)

scrollToSelection

fun scrollToSelection()

selectAll

open override fun selectAll()

selected

open override fun selected(item: Path<Int>): Boolean

open override fun selected(row: Int): Boolean

set

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

setSelection

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

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

styleChanged

protected fun styleChanged(filter: (View) -> Boolean)

toAbsolute

fun toAbsolute(point: Point): Point

toggleSelection

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

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

toLocal

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

toolTipText

open fun toolTipText(for: PointerEvent): String

toParent

fun toParent(point: Point): Point

update

protected fun update(children: MutableList<View>, path: Path<Int>, index: Int? = rowFromPath(path)): Int?

visible

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

open override fun visible(row: Int): Boolean