controls/io.nacular.doodle.controls.panels/TabbedPanel

TabbedPanel

class TabbedPanel<T>(orientation: BoxOrientation = Top, val visualizer: ItemVisualizer<T, Any>, val tabVisualizer: ItemVisualizer<T, Any>, item: T, remaining: T) : View, Iterable<T> (source)

A container that manages a set of tabs, each representing one of the items it holds. This container is intended to display a single item at a time based on which is selected. This class delegates all rendering an configuration to its TabbedPanelBehavior, which allows a high degree of flexibility regarding display and behavior.

Parameters

orientation

of the tab container

visualizer

to display each item

tabVisualizer

to display the tab for each item

item

the first item in the list

remaining

items in the lest

Constructors

constructor(visualizer: ItemVisualizer<T, Any>, tabVisualizer: ItemVisualizer<T, Any>, item: T, vararg remaining: T)

Creates a TabbedPanel with orientation == Top.

constructor(orientation: BoxOrientation = Top, visualizer: ItemVisualizer<T, Any>, tabVisualizer: ItemVisualizer<T, Any>, item: T, vararg remaining: T)

Types

object Companion

Properties

var behavior: TabbedPanelBehavior<T>?

Component responsible for controlling the presentation and behavior of the panel.

val itemsChanged: ListObservers<TabbedPanel<T>, T>

Notifies of changes to items.

val numItems: Int

The number of items (tabs) in the panel.

var orientation: BoxOrientation

The location of the tabs.

orientationChanged

val orientationChanged: PropertyObservers<TabbedPanel<T>, BoxOrientation>

Notifies of changes to orientation.

val selectedItem: T?

The currently selected item.

var selection: Int?

The currently selected item/tab. Defaults to 0.

selectionChanged

val selectionChanged: PropertyObservers<TabbedPanel<T>, Int?>

Notifies of changes to selection.

val tabVisualizer: ItemVisualizer<T, Any>

val visualizer: ItemVisualizer<T, Any>

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

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

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

override var height: Double

override var idealSize: Size?

protected open var insets: Insets

isFocusCycleRoot

protected open var isFocusCycleRoot: Boolean

val keyChanged: Pool<KeyListener>

val keyFilter: Pool<KeyListener>

protected open var layout: Layout?

localContentDirection

var localContentDirection: ContentDirection?

override var minimumSize: Size

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>

override var position: Point

var rendered: Boolean

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(item: T): Boolean

Adds an item to the panel

fun add(at: Int, item: T)

Adds an item to the panel at a particular index.

fun clear()

Removes all items from the panel

operator fun contains(item: T): Boolean

operator fun get(index: Int): T?

fun indexOf(item: T): Int

fun isEmpty(): Boolean

true if the item list is empty

open operator override fun iterator(): Iterator<T>

fun lastIndexOf(item: T): Int

fun move(item: T, to: Int): Boolean

Moves an item from to the given index.

fun remove(item: T): Boolean

Removes an item from the panel.

fun remove(at: Int): T

Removes the item at an index from the panel.

open override fun render(canvas: Canvas)

operator fun set(at: Int, item: T): T

Changes the item at a given index.

Inherited functions

protected open fun addedToDisplay()

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

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

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

handleDisplayRectEvent

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

protected open fun relayout()

removedFromDisplay

protected open fun removedFromDisplay()

fun rerenderNow()

protected fun revalidate()

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

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

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

open fun toolTipText(for: PointerEvent): String

fun toParent(point: Point): Point