korge/korlibs.korge.view/BaseView

BaseView

open class BaseView : BaseEventListener

Inheritors

View

Constructors

BaseView

constructor()

Properties

baseParent

val baseParent: BaseView?

eventListenerParent

var eventListenerParent: BaseEventListener?

extra

open override var extra: ExtraType

Functions

clearEvents

fun clearEvents()

fun <T : BEvent> clearEvents(type: EventType<T>)

dispatch

override fun <T : BEvent> dispatch(event: T): Boolean

override fun <T : BEvent> dispatch(type: EventType<T>, event: T, result: EventResult?): Boolean

open override fun <T : BEvent> dispatch(type: EventType<T>, event: T, result: EventResult?, up: Boolean, down: Boolean): Boolean

Dispatched a event of type that will execute all the handlers registered with onEvents in this object and its children.

dispatchChildren

open fun <T : BEvent> dispatchChildren(type: EventType<T>, event: T, result: EventResult?)

dispatchDown

open fun <T : BEvent> dispatchDown(type: EventType<T>, event: T, result: EventResult? = null): Boolean

dispatchDown

fun <T : BEvent> EventListener.dispatchDown(event: T): Boolean

dispatchParent

open fun <T : BEvent> dispatchParent(type: EventType<T>, event: T, result: EventResult?)

dispatchUp

open fun <T : BEvent> dispatchUp(type: EventType<T>, event: T, result: EventResult? = null): Boolean

dispatchUp

fun <T : BEvent> EventListener.dispatchUp(event: T): Boolean

dispatchWithResult

override fun <T : BEvent> dispatchWithResult(event: T, out: EventResult): EventResult

getSelfEventCount

fun getSelfEventCount(type: EventType<*>): Int

invalidateRender

open fun invalidateRender()

onEvent

override fun <T : BEvent> onEvent(type: EventType<T>, handler: (T) -> Unit): CloseableCancellable

Registers a handler block to be executed when an event of type is dispatched

onEventCount

override fun onEventCount(type: EventType<*>): Int

onEvents

open fun <T : BEvent> onEvents(vararg etypes: EventType<out T>, handler: (T) -> Unit): Closeable

onEventsCount

override fun onEventsCount(): FastIdentityMap<EventType<*>, Int>?

tween

suspend fun BaseView?.tween(vararg vs: V2<*>, time: TimeSpan = DEFAULT_TIME, easing: Easing = DEFAULT_EASING, waitTime: TimeSpan = TimeSpan.NIL, timeout: Boolean = false, autoInvalidate: Boolean = true, callback: (Float) -> Unit = { })

Creates a tween that will take a specified time to execute, with an optional easing.

tweenAsync

suspend fun BaseView?.tweenAsync(vararg vs: V2<*>, time: TimeSpan = DEFAULT_TIME, easing: Easing = DEFAULT_EASING, waitTime: TimeSpan = TimeSpan.NIL, callback: (Float) -> Unit = {}): Deferred<Unit>

fun BaseView?.tweenAsync(vararg vs: V2<*>, coroutineContext: CoroutineContext, time: TimeSpan = DEFAULT_TIME, easing: Easing = DEFAULT_EASING, waitTime: TimeSpan = TimeSpan.NIL, callback: (Float) -> Unit = {}): Deferred<Unit>

tweenNoWait

fun BaseView?.tweenNoWait(vararg vs: V2<*>, time: TimeSpan = DEFAULT_TIME, easing: Easing = DEFAULT_EASING, waitTime: TimeSpan = TimeSpan.NIL, callback: (Float) -> Unit = { }): TweenComponent?