controls/io.nacular.doodle.controls.carousel/Carousel

Carousel

open class Carousel<T, M : ListModel<T>>(model: M, itemVisualizer: ItemVisualizer<T, CarouselItem>) : View(source)

A visual component that renders and cycles through a list of items of type T using a CarouselBehavior. Items are obtained via the model and presented such that a single item is "selected" at any time. Large ("infinite") lists of items are supported efficiently, since Carousel recycles the Views generated to render its items.

Carousel relies heavily on the Presenter provided by its behavior for the positioning and visual treatment of its underlying data. Different StageManagers can radically change the way a Carousel looks and functions.

Parameters

model

that holds the data for this Carousel

itemVisualizer

that maps T to View for each item in the List

Inheritors

DynamicCarousel

Constructors

constructor(model: M, itemVisualizer: ItemVisualizer<T, CarouselItem>)

Types

class ItemMarkers

Data structure defining where the previous and next items are located relative to their Carousel's origin. This data is provided to Transitioners at the end of a Carousel's manual movement, so they can decide which item to stop at.

class PresentedItem

An item bound to some data (and a View) within a Carousel that will be displayed. Presenters create these during Presenter.present to decide what is shown within a Carousel.

Properties

var behavior: CarouselBehavior<T>?

CarouselBehavior that governs the way this Carousel behaves.

val nearestItem: Int

The index the Carousel is closest to displaying in the "selected" slot at this moment. This value changes as the Carousel animates to a new targetItem.

nearestItemChanged

val nearestItemChanged: PropertyObservers<Carousel<T, M>, Int>

Notifies of changes to the Carousel's nearestItem.

val numItems: Int

Number of items in the Carousel

previousSelectedItem

val previousSelectedItem: Int

The previous item selected by the Carousel.

progressChanged

val progressChanged: ChangeObservers<Carousel<T, M>>

Notifies of changes to the Carousel's progress to its target. Listeners can then check nearestItem, progressToTargetItem and progressToNextItem to figure out exactly how the Carousel is positioned.

progressToNextItem

var progressToNextItem: Float

Where the Carousel is between nearestItem and the next index as it travels to targetItem. This value is always within [0-1].

progressToTargetItem

var progressToTargetItem: Float

Where the Carousel is between previousSelectedItem and targetItem as it travels to the latter. This value is always within [0-1].

val targetItem: Int

The item being selected by the Carousel, even if that selection is in progress.

var wrapAtEnds: Boolean

Determines whether the Carousel will wrap its values at the start and end.

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

completeManualMove

fun completeManualMove()

Finishes an ongoing manual move and indicates that the Carousel should return to a state where it has selected an item.

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

Gets the value at the given index.

fun moveManually(to: Vector2D)

Manually moves the Carousel's contents to some to. This will stop any current transition and update the selected item as the values change.

fun moveManually(x: Double, y: Double)

fun next()

Moves to the next item if one exists.

Moves to the previous item if one exists.

open override fun render(canvas: Canvas)

fun skip(amount: Int)

Skips forward/backward by amount to select the item there.

startManualMove

fun startManualMove()

Initiates manual movement of the Carousel. This will interrupt any other movement and get the Carousel ready for subsequent calls to moveManually.

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