headless/dev.fritz2.headless.components/Menu/MenuItems/MenuItem

MenuItem

inner class MenuItem<CM : HTMLElement>(tag: Tag<CM>, val index: Int) : Tag<CM>

Constructors

MenuItem

constructor(tag: Tag<CM>, index: Int)

Properties

aborts

open override val aborts: Listener<Event, CM>

abortsCaptured

open override val abortsCaptured: Listener<Event, CM>

active

val active: Flow<Boolean>

afterprints

open override val afterprints: Listener<Event, CM>

afterprintsCaptured

open override val afterprintsCaptured: Listener<Event, CM>

animationends

open override val animationends: Listener<Event, CM>

animationendsCaptured

open override val animationendsCaptured: Listener<Event, CM>

animationiterations

open override val animationiterations: Listener<Event, CM>

animationiterationsCaptured

open override val animationiterationsCaptured: Listener<Event, CM>

animationstarts

open override val animationstarts: Listener<Event, CM>

animationstartsCaptured

open override val animationstartsCaptured: Listener<Event, CM>

annex

open override val annex: RenderContext

baseClass

open override val baseClass: String?

beforeprints

open override val beforeprints: Listener<Event, CM>

beforeprintsCaptured

open override val beforeprintsCaptured: Listener<Event, CM>

beforeunloads

open override val beforeunloads: Listener<Event, CM>

beforeunloadsCaptured

open override val beforeunloadsCaptured: Listener<Event, CM>

blurs

open override val blurs: Listener<FocusEvent, CM>

blursCaptured

open override val blursCaptured: Listener<FocusEvent, CM>

canplays

open override val canplays: Listener<Event, CM>

canplaysCaptured

open override val canplaysCaptured: Listener<Event, CM>

canplaythroughs

open override val canplaythroughs: Listener<Event, CM>

canplaythroughsCaptured

open override val canplaythroughsCaptured: Listener<Event, CM>

changes

open override val changes: Listener<Event, CM>

changesCaptured

open override val changesCaptured: Listener<Event, CM>

clicks

open override val clicks: Listener<MouseEvent, CM>

clicksCaptured

open override val clicksCaptured: Listener<MouseEvent, CM>

contextmenus

open override val contextmenus: Listener<MouseEvent, CM>

contextmenusCaptured

open override val contextmenusCaptured: Listener<MouseEvent, CM>

copys

open override val copys: Listener<ClipboardEvent, CM>

copysCaptured

open override val copysCaptured: Listener<ClipboardEvent, CM>

cuts

open override val cuts: Listener<ClipboardEvent, CM>

cutsCaptured

open override val cutsCaptured: Listener<ClipboardEvent, CM>

dblclicks

open override val dblclicks: Listener<MouseEvent, CM>

dblclicksCaptured

open override val dblclicksCaptured: Listener<MouseEvent, CM>

disable

val disable: SimpleHandler<Boolean>

disabled

val disabled: Flow<Boolean>

domNode

open override val domNode: CM

dragends

open override val dragends: Listener<DragEvent, CM>

dragendsCaptured

open override val dragendsCaptured: Listener<DragEvent, CM>

dragenters

open override val dragenters: Listener<DragEvent, CM>

dragentersCaptured

open override val dragentersCaptured: Listener<DragEvent, CM>

dragleaves

open override val dragleaves: Listener<DragEvent, CM>

dragleavesCaptured

open override val dragleavesCaptured: Listener<DragEvent, CM>

dragovers

open override val dragovers: Listener<DragEvent, CM>

dragoversCaptured

open override val dragoversCaptured: Listener<DragEvent, CM>

drags

open override val drags: Listener<DragEvent, CM>

dragsCaptured

open override val dragsCaptured: Listener<DragEvent, CM>

dragstarts

open override val dragstarts: Listener<DragEvent, CM>

dragstartsCaptured

open override val dragstartsCaptured: Listener<DragEvent, CM>

drops

open override val drops: Listener<DragEvent, CM>

dropsCaptured

open override val dropsCaptured: Listener<DragEvent, CM>

durationchanges

open override val durationchanges: Listener<Event, CM>

durationchangesCaptured

open override val durationchangesCaptured: Listener<Event, CM>

endeds

open override val endeds: Listener<Event, CM>

endedsCaptured

open override val endedsCaptured: Listener<Event, CM>

errors

open override val errors: Listener<Event, CM>

errorsCaptured

open override val errorsCaptured: Listener<Event, CM>

focusins

open override val focusins: Listener<FocusEvent, CM>

focusinsCaptured

open override val focusinsCaptured: Listener<FocusEvent, CM>

focusouts

open override val focusouts: Listener<FocusEvent, CM>

focusoutsCaptured

open override val focusoutsCaptured: Listener<FocusEvent, CM>

focuss

open override val focuss: Listener<FocusEvent, CM>

focussCaptured

open override val focussCaptured: Listener<FocusEvent, CM>

fullscreenchanges

open override val fullscreenchanges: Listener<Event, CM>

fullscreenchangesCaptured

open override val fullscreenchangesCaptured: Listener<Event, CM>

fullscreenerrors

open override val fullscreenerrors: Listener<Event, CM>

fullscreenerrorsCaptured

open override val fullscreenerrorsCaptured: Listener<Event, CM>

hashchanges

open override val hashchanges: Listener<HashChangeEvent, CM>

hashchangesCaptured

open override val hashchangesCaptured: Listener<HashChangeEvent, CM>

open override val id: String?

index

val index: Int

inputs

open override val inputs: Listener<Event, CM>

inputsCaptured

open override val inputsCaptured: Listener<Event, CM>

invalids

open override val invalids: Listener<Event, CM>

invalidsCaptured

open override val invalidsCaptured: Listener<Event, CM>

job

open override val job: Job

keydowns

open override val keydowns: Listener<KeyboardEvent, CM>

keydownsCaptured

open override val keydownsCaptured: Listener<KeyboardEvent, CM>

keypresss

open override val keypresss: Listener<KeyboardEvent, CM>

keypresssCaptured

open override val keypresssCaptured: Listener<KeyboardEvent, CM>

keyups

open override val keyups: Listener<KeyboardEvent, CM>

keyupsCaptured

open override val keyupsCaptured: Listener<KeyboardEvent, CM>

loadeddatas

open override val loadeddatas: Listener<Event, CM>

loadeddatasCaptured

open override val loadeddatasCaptured: Listener<Event, CM>

loadedmetadatas

open override val loadedmetadatas: Listener<Event, CM>

loadedmetadatasCaptured

open override val loadedmetadatasCaptured: Listener<Event, CM>

loads

open override val loads: Listener<Event, CM>

loadsCaptured

open override val loadsCaptured: Listener<Event, CM>

loadstarts

open override val loadstarts: Listener<ProgressEvent, CM>

loadstartsCaptured

open override val loadstartsCaptured: Listener<ProgressEvent, CM>

messages

open override val messages: Listener<Event, CM>

messagesCaptured

open override val messagesCaptured: Listener<Event, CM>

mousedowns

open override val mousedowns: Listener<MouseEvent, CM>

mousedownsCaptured

open override val mousedownsCaptured: Listener<MouseEvent, CM>

mouseenters

open override val mouseenters: Listener<MouseEvent, CM>

mouseentersCaptured

open override val mouseentersCaptured: Listener<MouseEvent, CM>

mouseleaves

open override val mouseleaves: Listener<MouseEvent, CM>

mouseleavesCaptured

open override val mouseleavesCaptured: Listener<MouseEvent, CM>

mousemoves

open override val mousemoves: Listener<MouseEvent, CM>

mousemovesCaptured

open override val mousemovesCaptured: Listener<MouseEvent, CM>

mouseouts

open override val mouseouts: Listener<MouseEvent, CM>

mouseoutsCaptured

open override val mouseoutsCaptured: Listener<MouseEvent, CM>

mouseovers

open override val mouseovers: Listener<MouseEvent, CM>

mouseoversCaptured

open override val mouseoversCaptured: Listener<MouseEvent, CM>

mouseups

open override val mouseups: Listener<MouseEvent, CM>

mouseupsCaptured

open override val mouseupsCaptured: Listener<MouseEvent, CM>

offlines

open override val offlines: Listener<Event, CM>

offlinesCaptured

open override val offlinesCaptured: Listener<Event, CM>

onlines

open override val onlines: Listener<Event, CM>

onlinesCaptured

open override val onlinesCaptured: Listener<Event, CM>

opens

open override val opens: Listener<Event, CM>

opensCaptured

open override val opensCaptured: Listener<Event, CM>

pagehides

open override val pagehides: Listener<PageTransitionEvent, CM>

pagehidesCaptured

open override val pagehidesCaptured: Listener<PageTransitionEvent, CM>

pageshows

open override val pageshows: Listener<PageTransitionEvent, CM>

pageshowsCaptured

open override val pageshowsCaptured: Listener<PageTransitionEvent, CM>

pastes

open override val pastes: Listener<ClipboardEvent, CM>

pastesCaptured

open override val pastesCaptured: Listener<ClipboardEvent, CM>

pauses

open override val pauses: Listener<Event, CM>

pausesCaptured

open override val pausesCaptured: Listener<Event, CM>

playings

open override val playings: Listener<Event, CM>

playingsCaptured

open override val playingsCaptured: Listener<Event, CM>

plays

open override val plays: Listener<Event, CM>

playsCaptured

open override val playsCaptured: Listener<Event, CM>

popstates

open override val popstates: Listener<PopStateEvent, CM>

popstatesCaptured

open override val popstatesCaptured: Listener<PopStateEvent, CM>

progresss

open override val progresss: Listener<Event, CM>

progresssCaptured

open override val progresssCaptured: Listener<Event, CM>

ratechanges

open override val ratechanges: Listener<Event, CM>

ratechangesCaptured

open override val ratechangesCaptured: Listener<Event, CM>

resets

open override val resets: Listener<Event, CM>

resetsCaptured

open override val resetsCaptured: Listener<Event, CM>

resizes

open override val resizes: Listener<Event, CM>

resizesCaptured

open override val resizesCaptured: Listener<Event, CM>

scope

open override val scope: Scope

scrolls

open override val scrolls: Listener<Event, CM>

scrollsCaptured

open override val scrollsCaptured: Listener<Event, CM>

searchs

open override val searchs: Listener<Event, CM>

searchsCaptured

open override val searchsCaptured: Listener<Event, CM>

seekeds

open override val seekeds: Listener<Event, CM>

seekedsCaptured

open override val seekedsCaptured: Listener<Event, CM>

seekings

open override val seekings: Listener<Event, CM>

seekingsCaptured

open override val seekingsCaptured: Listener<Event, CM>

selected

val selected: Flow<Unit>

selects

open override val selects: Listener<Event, CM>

selectsCaptured

open override val selectsCaptured: Listener<Event, CM>

shows

open override val shows: Listener<Event, CM>

showsCaptured

open override val showsCaptured: Listener<Event, CM>

stalleds

open override val stalleds: Listener<Event, CM>

stalledsCaptured

open override val stalledsCaptured: Listener<Event, CM>

storages

open override val storages: Listener<StorageEvent, CM>

storagesCaptured

open override val storagesCaptured: Listener<StorageEvent, CM>

submits

open override val submits: Listener<Event, CM>

submitsCaptured

open override val submitsCaptured: Listener<Event, CM>

suspends

open override val suspends: Listener<Event, CM>

suspendsCaptured

open override val suspendsCaptured: Listener<Event, CM>

timeupdates

open override val timeupdates: Listener<Event, CM>

timeupdatesCaptured

open override val timeupdatesCaptured: Listener<Event, CM>

toggles

open override val toggles: Listener<Event, CM>

togglesCaptured

open override val togglesCaptured: Listener<Event, CM>

touchcancels

open override val touchcancels: Listener<TouchEvent, CM>

touchcancelsCaptured

open override val touchcancelsCaptured: Listener<TouchEvent, CM>

touchends

open override val touchends: Listener<TouchEvent, CM>

touchendsCaptured

open override val touchendsCaptured: Listener<TouchEvent, CM>

touchmoves

open override val touchmoves: Listener<TouchEvent, CM>

touchmovesCaptured

open override val touchmovesCaptured: Listener<TouchEvent, CM>

touchstarts

open override val touchstarts: Listener<TouchEvent, CM>

touchstartsCaptured

open override val touchstartsCaptured: Listener<TouchEvent, CM>

transitionends

open override val transitionends: Listener<Event, CM>

transitionendsCaptured

open override val transitionendsCaptured: Listener<Event, CM>

unloads

open override val unloads: Listener<Event, CM>

unloadsCaptured

open override val unloadsCaptured: Listener<Event, CM>

volumechanges

open override val volumechanges: Listener<Event, CM>

volumechangesCaptured

open override val volumechangesCaptured: Listener<Event, CM>

waitings

open override val waitings: Listener<Event, CM>

waitingsCaptured

open override val waitingsCaptured: Listener<Event, CM>

wheels

open override val wheels: Listener<WheelEvent, CM>

wheelsCaptured

open override val wheelsCaptured: Listener<WheelEvent, CM>

Functions

open override fun a(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLAnchorElement>.() -> Unit): HtmlTag<HTMLAnchorElement>

abbr

open override fun abbr(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

aborts

open override fun aborts(init: Event.() -> Unit): Listener<Event, CM>

abortsCaptured

open override fun abortsCaptured(init: Event.() -> Unit): Listener<Event, CM>

abortsCapturedIf

open override fun abortsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

abortsIf

open override fun abortsIf(selector: Event.() -> Boolean): Listener<Event, CM>

address

open override fun address(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

afterprints

open override fun afterprints(init: Event.() -> Unit): Listener<Event, CM>

afterprintsCaptured

open override fun afterprintsCaptured(init: Event.() -> Unit): Listener<Event, CM>

afterprintsCapturedIf

open override fun afterprintsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

afterprintsIf

open override fun afterprintsIf(selector: Event.() -> Boolean): Listener<Event, CM>

animationends

open override fun animationends(init: Event.() -> Unit): Listener<Event, CM>

animationendsCaptured

open override fun animationendsCaptured(init: Event.() -> Unit): Listener<Event, CM>

animationendsCapturedIf

open override fun animationendsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

animationendsIf

open override fun animationendsIf(selector: Event.() -> Boolean): Listener<Event, CM>

animationiterations

open override fun animationiterations(init: Event.() -> Unit): Listener<Event, CM>

animationiterationsCaptured

open override fun animationiterationsCaptured(init: Event.() -> Unit): Listener<Event, CM>

animationiterationsCapturedIf

open override fun animationiterationsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

animationiterationsIf

open override fun animationiterationsIf(selector: Event.() -> Boolean): Listener<Event, CM>

animationstarts

open override fun animationstarts(init: Event.() -> Unit): Listener<Event, CM>

animationstartsCaptured

open override fun animationstartsCaptured(init: Event.() -> Unit): Listener<Event, CM>

animationstartsCapturedIf

open override fun animationstartsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

animationstartsIf

open override fun animationstartsIf(selector: Event.() -> Boolean): Listener<Event, CM>

area

open override fun area(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLAreaElement>.() -> Unit): HtmlTag<HTMLAreaElement>

article

open override fun article(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

asDataAttr

open override fun Scope.asDataAttr()

open override fun <T : Any> Scope.asDataAttr(key: Scope.Key<T>)

aside

open override fun aside(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

asString

open override fun <T> Flow<T>.asString(): Flow<String>

attr

open override fun <T> attr(name: String, value: T)

open override fun attr(name: String, value: String)

open override fun attr(name: String, value: String?)

open override fun <T> attr(name: String, value: Flow<T>)

open override fun attr(name: String, value: Flow<String?>)

open override fun attr(name: String, value: Flow<String>)

open override fun attr(name: String, value: Boolean, trueValue: String)

open override fun attr(name: String, value: Boolean?, trueValue: String)

open override fun attr(name: String, value: Flow<Boolean?>, trueValue: String)

open override fun attr(name: String, value: Flow<Boolean>, trueValue: String)

attrIfNotSet

fun <N : Element> Tag<N>.attrIfNotSet(name: String, value: String)

Sets an attribute only if it is not present yet.

audio

open override fun audio(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLAudioElement>.() -> Unit): HtmlTag<HTMLAudioElement>

open override fun b(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

bdi

open override fun bdi(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

bdo

open override fun bdo(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

beforeprints

open override fun beforeprints(init: Event.() -> Unit): Listener<Event, CM>

beforeprintsCaptured

open override fun beforeprintsCaptured(init: Event.() -> Unit): Listener<Event, CM>

beforeprintsCapturedIf

open override fun beforeprintsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

beforeprintsIf

open override fun beforeprintsIf(selector: Event.() -> Boolean): Listener<Event, CM>

beforeunloads

open override fun beforeunloads(init: Event.() -> Unit): Listener<Event, CM>

beforeunloadsCaptured

open override fun beforeunloadsCaptured(init: Event.() -> Unit): Listener<Event, CM>

beforeunloadsCapturedIf

open override fun beforeunloadsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

beforeunloadsIf

open override fun beforeunloadsIf(selector: Event.() -> Boolean): Listener<Event, CM>

blockquote

open override fun blockquote(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLQuoteElement>.() -> Unit): HtmlTag<HTMLQuoteElement>

blurs

open override fun blurs(init: FocusEvent.() -> Unit): Listener<FocusEvent, CM>

blursCaptured

open override fun blursCaptured(init: FocusEvent.() -> Unit): Listener<FocusEvent, CM>

blursCapturedIf

open override fun blursCapturedIf(selector: FocusEvent.() -> Boolean): Listener<FocusEvent, CM>

blursIf

open override fun blursIf(selector: FocusEvent.() -> Boolean): Listener<FocusEvent, CM>

open override fun br(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLBRElement>.() -> Unit): HtmlTag<HTMLBRElement>

button

open override fun button(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLButtonElement>.() -> Unit): HtmlTag<HTMLButtonElement>

canplays

open override fun canplays(init: Event.() -> Unit): Listener<Event, CM>

canplaysCaptured

open override fun canplaysCaptured(init: Event.() -> Unit): Listener<Event, CM>

canplaysCapturedIf

open override fun canplaysCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

canplaysIf

open override fun canplaysIf(selector: Event.() -> Boolean): Listener<Event, CM>

canplaythroughs

open override fun canplaythroughs(init: Event.() -> Unit): Listener<Event, CM>

canplaythroughsCaptured

open override fun canplaythroughsCaptured(init: Event.() -> Unit): Listener<Event, CM>

canplaythroughsCapturedIf

open override fun canplaythroughsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

canplaythroughsIf

open override fun canplaythroughsIf(selector: Event.() -> Boolean): Listener<Event, CM>

canvas

open override fun canvas(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLCanvasElement>.() -> Unit): HtmlTag<HTMLCanvasElement>

caption

open override fun caption(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTableCaptionElement>.() -> Unit): HtmlTag<HTMLTableCaptionElement>

changes

open override fun changes(init: Event.() -> Unit): Listener<Event, CM>

changesCaptured

open override fun changesCaptured(init: Event.() -> Unit): Listener<Event, CM>

changesCapturedIf

open override fun changesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

changesIf

open override fun changesIf(selector: Event.() -> Boolean): Listener<Event, CM>

checkboxGroup

fun <T> RenderContext.checkboxGroup(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: CheckboxGroup<HTMLDivElement, T>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a CheckboxGroup with a HTMLDivElement as default root Tag.

fun <C : HTMLElement, T> RenderContext.checkboxGroup(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: CheckboxGroup<C, T>.() -> Unit): Tag<C>

Factory function to create a CheckboxGroup.

cite

open override fun cite(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

classList

open override fun classList(values: List<String>)

open override fun classList(values: Flow<List<String>>)

classMap

open override fun classMap(values: Map<String, Boolean>)

open override fun classMap(values: Flow<Map<String, Boolean>>)

className

open override fun className(value: String)

open override fun className(value: Flow<String>, initial: String)

open override fun <T> className(value: Flow<T>, initial: T, transform: (T) -> String)

clicks

open override fun clicks(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

clicksCaptured

open override fun clicksCaptured(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

clicksCapturedIf

open override fun clicksCapturedIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

clicksIf

open override fun clicksIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

code

open override fun code(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

col

open override fun col(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTableColElement>.() -> Unit): HtmlTag<HTMLTableColElement>

colgroup

open override fun colgroup(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTableColElement>.() -> Unit): HtmlTag<HTMLTableColElement>

combobox

fun <T> RenderContext.combobox(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: Combobox<HTMLDivElement, T>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a Combobox with an HTMLDivElement as default root Tag.

fun <E : HTMLElement, T> RenderContext.combobox(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<E>>, initialize: Combobox<E, T>.() -> Unit): Tag<E>

Factory function to create a Combobox.

command

open override fun command(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

contextmenus

open override fun contextmenus(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

contextmenusCaptured

open override fun contextmenusCaptured(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

contextmenusCapturedIf

open override fun contextmenusCapturedIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

contextmenusIf

open override fun contextmenusIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

copys

open override fun copys(init: ClipboardEvent.() -> Unit): Listener<ClipboardEvent, CM>

copysCaptured

open override fun copysCaptured(init: ClipboardEvent.() -> Unit): Listener<ClipboardEvent, CM>

copysCapturedIf

open override fun copysCapturedIf(selector: ClipboardEvent.() -> Boolean): Listener<ClipboardEvent, CM>

copysIf

open override fun copysIf(selector: ClipboardEvent.() -> Boolean): Listener<ClipboardEvent, CM>

custom

open override fun custom(tagName: String, baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<Element>.() -> Unit): HtmlTag<Element>

cuts

open override fun cuts(init: ClipboardEvent.() -> Unit): Listener<ClipboardEvent, CM>

cutsCaptured

open override fun cutsCaptured(init: ClipboardEvent.() -> Unit): Listener<ClipboardEvent, CM>

cutsCapturedIf

open override fun cutsCapturedIf(selector: ClipboardEvent.() -> Boolean): Listener<ClipboardEvent, CM>

cutsIf

open override fun cutsIf(selector: ClipboardEvent.() -> Boolean): Listener<ClipboardEvent, CM>

data

open override fun data(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLDataElement>.() -> Unit): HtmlTag<HTMLDataElement>

dataCollection

fun <T> RenderContext.dataCollection(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: DataCollection<T, HTMLDivElement>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a DataCollection with a HTMLDivElement as default root Tag.

fun <T, C : HTMLElement> RenderContext.dataCollection(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: DataCollection<T, C>.() -> Unit): Tag<C>

Factory function to create a DataCollection.

datalist

open override fun datalist(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLDataListElement>.() -> Unit): HtmlTag<HTMLDataListElement>

dblclicks

open override fun dblclicks(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

dblclicksCaptured

open override fun dblclicksCaptured(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

dblclicksCapturedIf

open override fun dblclicksCapturedIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

dblclicksIf

open override fun dblclicksIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

open override fun dd(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLSpanElement>.() -> Unit): HtmlTag<HTMLSpanElement>

del

open override fun del(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLModElement>.() -> Unit): HtmlTag<HTMLModElement>

details

open override fun details(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLDetailsElement>.() -> Unit): HtmlTag<HTMLDetailsElement>

dfn

open override fun dfn(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

dialog

open override fun dialog(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLDialogElement>.() -> Unit): HtmlTag<HTMLDialogElement>

disclosure

fun RenderContext.disclosure(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: Disclosure<HTMLDivElement>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a Disclosure with a HTMLDivElement as default root Tag.

fun <C : HTMLElement> RenderContext.disclosure(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: Disclosure<C>.() -> Unit): Tag<C>

Factory function to create a Disclosure.

div

open override fun div(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLDivElement>.() -> Unit): HtmlTag<HTMLDivElement>

open override fun dl(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLDListElement>.() -> Unit): HtmlTag<HTMLDListElement>

dragends

open override fun dragends(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragendsCaptured

open override fun dragendsCaptured(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragendsCapturedIf

open override fun dragendsCapturedIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

dragendsIf

open override fun dragendsIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

dragenters

open override fun dragenters(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragentersCaptured

open override fun dragentersCaptured(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragentersCapturedIf

open override fun dragentersCapturedIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

dragentersIf

open override fun dragentersIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

dragleaves

open override fun dragleaves(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragleavesCaptured

open override fun dragleavesCaptured(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragleavesCapturedIf

open override fun dragleavesCapturedIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

dragleavesIf

open override fun dragleavesIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

dragovers

open override fun dragovers(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragoversCaptured

open override fun dragoversCaptured(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragoversCapturedIf

open override fun dragoversCapturedIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

dragoversIf

open override fun dragoversIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

drags

open override fun drags(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragsCaptured

open override fun dragsCaptured(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragsCapturedIf

open override fun dragsCapturedIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

dragsIf

open override fun dragsIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

dragstarts

open override fun dragstarts(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragstartsCaptured

open override fun dragstartsCaptured(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dragstartsCapturedIf

open override fun dragstartsCapturedIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

dragstartsIf

open override fun dragstartsIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

drops

open override fun drops(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dropsCaptured

open override fun dropsCaptured(init: DragEvent.() -> Unit): Listener<DragEvent, CM>

dropsCapturedIf

open override fun dropsCapturedIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

dropsIf

open override fun dropsIf(selector: DragEvent.() -> Boolean): Listener<DragEvent, CM>

open override fun dt(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLSpanElement>.() -> Unit): HtmlTag<HTMLSpanElement>

durationchanges

open override fun durationchanges(init: Event.() -> Unit): Listener<Event, CM>

durationchangesCaptured

open override fun durationchangesCaptured(init: Event.() -> Unit): Listener<Event, CM>

durationchangesCapturedIf

open override fun durationchangesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

durationchangesIf

open override fun durationchangesIf(selector: Event.() -> Boolean): Listener<Event, CM>

open override fun em(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

embed

open override fun embed(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLEmbedElement>.() -> Unit): HtmlTag<HTMLEmbedElement>

endeds

open override fun endeds(init: Event.() -> Unit): Listener<Event, CM>

endedsCaptured

open override fun endedsCaptured(init: Event.() -> Unit): Listener<Event, CM>

endedsCapturedIf

open override fun endedsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

endedsIf

open override fun endedsIf(selector: Event.() -> Boolean): Listener<Event, CM>

errorHandler

open override fun errorHandler(cause: Throwable)

errors

open override fun errors(init: Event.() -> Unit): Listener<Event, CM>

errorsCaptured

open override fun errorsCaptured(init: Event.() -> Unit): Listener<Event, CM>

errorsCapturedIf

open override fun errorsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

errorsIf

open override fun errorsIf(selector: Event.() -> Boolean): Listener<Event, CM>

fieldset

open override fun fieldset(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLFieldSetElement>.() -> Unit): HtmlTag<HTMLFieldSetElement>

figcaption

open override fun figcaption(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

figure

open override fun figure(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

focusins

open override fun focusins(init: FocusEvent.() -> Unit): Listener<FocusEvent, CM>

focusinsCaptured

open override fun focusinsCaptured(init: FocusEvent.() -> Unit): Listener<FocusEvent, CM>

focusinsCapturedIf

open override fun focusinsCapturedIf(selector: FocusEvent.() -> Boolean): Listener<FocusEvent, CM>

focusinsIf

open override fun focusinsIf(selector: FocusEvent.() -> Boolean): Listener<FocusEvent, CM>

focusouts

open override fun focusouts(init: FocusEvent.() -> Unit): Listener<FocusEvent, CM>

focusoutsCaptured

open override fun focusoutsCaptured(init: FocusEvent.() -> Unit): Listener<FocusEvent, CM>

focusoutsCapturedIf

open override fun focusoutsCapturedIf(selector: FocusEvent.() -> Boolean): Listener<FocusEvent, CM>

focusoutsIf

open override fun focusoutsIf(selector: FocusEvent.() -> Boolean): Listener<FocusEvent, CM>

focuss

open override fun focuss(init: FocusEvent.() -> Unit): Listener<FocusEvent, CM>

focussCaptured

open override fun focussCaptured(init: FocusEvent.() -> Unit): Listener<FocusEvent, CM>

focussCapturedIf

open override fun focussCapturedIf(selector: FocusEvent.() -> Boolean): Listener<FocusEvent, CM>

focussIf

open override fun focussIf(selector: FocusEvent.() -> Boolean): Listener<FocusEvent, CM>

footer

open override fun footer(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

form

open override fun form(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLFormElement>.() -> Unit): HtmlTag<HTMLFormElement>

fullscreenchanges

open override fun fullscreenchanges(init: Event.() -> Unit): Listener<Event, CM>

fullscreenchangesCaptured

open override fun fullscreenchangesCaptured(init: Event.() -> Unit): Listener<Event, CM>

fullscreenchangesCapturedIf

open override fun fullscreenchangesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

fullscreenchangesIf

open override fun fullscreenchangesIf(selector: Event.() -> Boolean): Listener<Event, CM>

fullscreenerrors

open override fun fullscreenerrors(init: Event.() -> Unit): Listener<Event, CM>

fullscreenerrorsCaptured

open override fun fullscreenerrorsCaptured(init: Event.() -> Unit): Listener<Event, CM>

fullscreenerrorsCapturedIf

open override fun fullscreenerrorsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

fullscreenerrorsIf

open override fun fullscreenerrorsIf(selector: Event.() -> Boolean): Listener<Event, CM>

open override fun h1(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLHeadingElement>.() -> Unit): HtmlTag<HTMLHeadingElement>

open override fun h2(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLHeadingElement>.() -> Unit): HtmlTag<HTMLHeadingElement>

open override fun h3(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLHeadingElement>.() -> Unit): HtmlTag<HTMLHeadingElement>

open override fun h4(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLHeadingElement>.() -> Unit): HtmlTag<HTMLHeadingElement>

open override fun h5(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLHeadingElement>.() -> Unit): HtmlTag<HTMLHeadingElement>

open override fun h6(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLHeadingElement>.() -> Unit): HtmlTag<HTMLHeadingElement>

handledBy

open infix override fun <A> Flow<A>.handledBy(handler: Handler<A>)

open infix override fun <A> Flow<A>.handledBy(execute: suspend (A) -> Unit): Job

open infix override fun <E : Event> Flow<E>.handledBy(handler: Handler<Unit>)

open infix override fun <E : Event> Flow<E>.handledBy(execute: suspend (E) -> Unit): Job

hashchanges

open override fun hashchanges(init: HashChangeEvent.() -> Unit): Listener<HashChangeEvent, CM>

hashchangesCaptured

open override fun hashchangesCaptured(init: HashChangeEvent.() -> Unit): Listener<HashChangeEvent, CM>

hashchangesCapturedIf

open override fun hashchangesCapturedIf(selector: HashChangeEvent.() -> Boolean): Listener<HashChangeEvent, CM>

hashchangesIf

open override fun hashchangesIf(selector: HashChangeEvent.() -> Boolean): Listener<HashChangeEvent, CM>

header

open override fun header(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

open override fun hr(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLHRElement>.() -> Unit): HtmlTag<HTMLHRElement>

open override fun i(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

iframe

open override fun iframe(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLIFrameElement>.() -> Unit): HtmlTag<HTMLIFrameElement>

img

open override fun img(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLImageElement>.() -> Unit): HtmlTag<HTMLImageElement>

inlineStyle

open override fun inlineStyle(value: String)

open override fun inlineStyle(value: Flow<String>)

input

open override fun input(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLInputElement>.() -> Unit): HtmlTag<HTMLInputElement>

inputField

fun RenderContext.inputField(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: InputField<HTMLDivElement>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a InputField with a HTMLDivElement as default root Tag.

fun <C : HTMLElement> RenderContext.inputField(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: InputField<C>.() -> Unit): Tag<C>

Factory function to create a InputField.

inputs

open override fun inputs(init: Event.() -> Unit): Listener<Event, CM>

inputsCaptured

open override fun inputsCaptured(init: Event.() -> Unit): Listener<Event, CM>

inputsCapturedIf

open override fun inputsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

inputsIf

open override fun inputsIf(selector: Event.() -> Boolean): Listener<Event, CM>

ins

open override fun ins(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLModElement>.() -> Unit): HtmlTag<HTMLModElement>

invalids

open override fun invalids(init: Event.() -> Unit): Listener<Event, CM>

invalidsCaptured

open override fun invalidsCaptured(init: Event.() -> Unit): Listener<Event, CM>

invalidsCapturedIf

open override fun invalidsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

invalidsIf

open override fun invalidsIf(selector: Event.() -> Boolean): Listener<Event, CM>

kbd

open override fun kbd(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

keydowns

open override fun keydowns(init: KeyboardEvent.() -> Unit): Listener<KeyboardEvent, CM>

keydownsCaptured

open override fun keydownsCaptured(init: KeyboardEvent.() -> Unit): Listener<KeyboardEvent, CM>

keydownsCapturedIf

open override fun keydownsCapturedIf(selector: KeyboardEvent.() -> Boolean): Listener<KeyboardEvent, CM>

keydownsIf

open override fun keydownsIf(selector: KeyboardEvent.() -> Boolean): Listener<KeyboardEvent, CM>

keypresss

open override fun keypresss(init: KeyboardEvent.() -> Unit): Listener<KeyboardEvent, CM>

keypresssCaptured

open override fun keypresssCaptured(init: KeyboardEvent.() -> Unit): Listener<KeyboardEvent, CM>

keypresssCapturedIf

open override fun keypresssCapturedIf(selector: KeyboardEvent.() -> Boolean): Listener<KeyboardEvent, CM>

keypresssIf

open override fun keypresssIf(selector: KeyboardEvent.() -> Boolean): Listener<KeyboardEvent, CM>

keyups

open override fun keyups(init: KeyboardEvent.() -> Unit): Listener<KeyboardEvent, CM>

keyupsCaptured

open override fun keyupsCaptured(init: KeyboardEvent.() -> Unit): Listener<KeyboardEvent, CM>

keyupsCapturedIf

open override fun keyupsCapturedIf(selector: KeyboardEvent.() -> Boolean): Listener<KeyboardEvent, CM>

keyupsIf

open override fun keyupsIf(selector: KeyboardEvent.() -> Boolean): Listener<KeyboardEvent, CM>

label

open override fun label(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLLabelElement>.() -> Unit): HtmlTag<HTMLLabelElement>

legend

open override fun legend(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLLegendElement>.() -> Unit): HtmlTag<HTMLLegendElement>

open override fun li(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLLIElement>.() -> Unit): HtmlTag<HTMLLIElement>

listbox

fun <T> RenderContext.listbox(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: Listbox<T, HTMLDivElement>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a Listbox with a HTMLDivElement as default root Tag.

fun <T, C : HTMLElement> RenderContext.listbox(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: Listbox<T, C>.() -> Unit): Tag<C>

Factory function to create a Listbox.

loadeddatas

open override fun loadeddatas(init: Event.() -> Unit): Listener<Event, CM>

loadeddatasCaptured

open override fun loadeddatasCaptured(init: Event.() -> Unit): Listener<Event, CM>

loadeddatasCapturedIf

open override fun loadeddatasCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

loadeddatasIf

open override fun loadeddatasIf(selector: Event.() -> Boolean): Listener<Event, CM>

loadedmetadatas

open override fun loadedmetadatas(init: Event.() -> Unit): Listener<Event, CM>

loadedmetadatasCaptured

open override fun loadedmetadatasCaptured(init: Event.() -> Unit): Listener<Event, CM>

loadedmetadatasCapturedIf

open override fun loadedmetadatasCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

loadedmetadatasIf

open override fun loadedmetadatasIf(selector: Event.() -> Boolean): Listener<Event, CM>

loads

open override fun loads(init: Event.() -> Unit): Listener<Event, CM>

loadsCaptured

open override fun loadsCaptured(init: Event.() -> Unit): Listener<Event, CM>

loadsCapturedIf

open override fun loadsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

loadsIf

open override fun loadsIf(selector: Event.() -> Boolean): Listener<Event, CM>

loadstarts

open override fun loadstarts(init: ProgressEvent.() -> Unit): Listener<ProgressEvent, CM>

loadstartsCaptured

open override fun loadstartsCaptured(init: ProgressEvent.() -> Unit): Listener<ProgressEvent, CM>

loadstartsCapturedIf

open override fun loadstartsCapturedIf(selector: ProgressEvent.() -> Boolean): Listener<ProgressEvent, CM>

loadstartsIf

open override fun loadstartsIf(selector: ProgressEvent.() -> Boolean): Listener<ProgressEvent, CM>

main

open override fun main(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

map

open override fun map(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLMapElement>.() -> Unit): HtmlTag<HTMLMapElement>

mark

open override fun mark(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

fun RenderContext.menu(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: Menu<HTMLDivElement>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a Menu with a HTMLDivElement as default root Tag.

fun <C : HTMLElement> RenderContext.menu(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: Menu<C>.() -> Unit): Tag<C>

Factory function to create a Menu.

messages

open override fun messages(init: Event.() -> Unit): Listener<Event, CM>

messagesCaptured

open override fun messagesCaptured(init: Event.() -> Unit): Listener<Event, CM>

messagesCapturedIf

open override fun messagesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

messagesIf

open override fun messagesIf(selector: Event.() -> Boolean): Listener<Event, CM>

meter

open override fun meter(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLMeterElement>.() -> Unit): HtmlTag<HTMLMeterElement>

mousedowns

open override fun mousedowns(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mousedownsCaptured

open override fun mousedownsCaptured(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mousedownsCapturedIf

open override fun mousedownsCapturedIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mousedownsIf

open override fun mousedownsIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mouseenters

open override fun mouseenters(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mouseentersCaptured

open override fun mouseentersCaptured(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mouseentersCapturedIf

open override fun mouseentersCapturedIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mouseentersIf

open override fun mouseentersIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mouseleaves

open override fun mouseleaves(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mouseleavesCaptured

open override fun mouseleavesCaptured(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mouseleavesCapturedIf

open override fun mouseleavesCapturedIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mouseleavesIf

open override fun mouseleavesIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mousemoves

open override fun mousemoves(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mousemovesCaptured

open override fun mousemovesCaptured(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mousemovesCapturedIf

open override fun mousemovesCapturedIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mousemovesIf

open override fun mousemovesIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mouseouts

open override fun mouseouts(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mouseoutsCaptured

open override fun mouseoutsCaptured(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mouseoutsCapturedIf

open override fun mouseoutsCapturedIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mouseoutsIf

open override fun mouseoutsIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mouseovers

open override fun mouseovers(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mouseoversCaptured

open override fun mouseoversCaptured(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mouseoversCapturedIf

open override fun mouseoversCapturedIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mouseoversIf

open override fun mouseoversIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mouseups

open override fun mouseups(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mouseupsCaptured

open override fun mouseupsCaptured(init: MouseEvent.() -> Unit): Listener<MouseEvent, CM>

mouseupsCapturedIf

open override fun mouseupsCapturedIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

mouseupsIf

open override fun mouseupsIf(selector: MouseEvent.() -> Boolean): Listener<MouseEvent, CM>

nav

open override fun nav(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

noscript

open override fun noscript(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

not

open operator override fun String.not(): Node

object

open override fun object(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLObjectElement>.() -> Unit): HtmlTag<HTMLObjectElement>

offlines

open override fun offlines(init: Event.() -> Unit): Listener<Event, CM>

offlinesCaptured

open override fun offlinesCaptured(init: Event.() -> Unit): Listener<Event, CM>

offlinesCapturedIf

open override fun offlinesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

offlinesIf

open override fun offlinesIf(selector: Event.() -> Boolean): Listener<Event, CM>

open override fun ol(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLOListElement>.() -> Unit): HtmlTag<HTMLOListElement>

onlines

open override fun onlines(init: Event.() -> Unit): Listener<Event, CM>

onlinesCaptured

open override fun onlinesCaptured(init: Event.() -> Unit): Listener<Event, CM>

onlinesCapturedIf

open override fun onlinesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

onlinesIf

open override fun onlinesIf(selector: Event.() -> Boolean): Listener<Event, CM>

opens

open override fun opens(init: Event.() -> Unit): Listener<Event, CM>

opensCaptured

open override fun opensCaptured(init: Event.() -> Unit): Listener<Event, CM>

opensCapturedIf

open override fun opensCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

opensIf

open override fun opensIf(selector: Event.() -> Boolean): Listener<Event, CM>

optgroup

open override fun optgroup(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLOptGroupElement>.() -> Unit): HtmlTag<HTMLOptGroupElement>

option

open override fun option(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLOptionElement>.() -> Unit): HtmlTag<HTMLOptionElement>

output

open override fun output(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLOutputElement>.() -> Unit): HtmlTag<HTMLOutputElement>

open override fun p(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLParagraphElement>.() -> Unit): HtmlTag<HTMLParagraphElement>

pagehides

open override fun pagehides(init: PageTransitionEvent.() -> Unit): Listener<PageTransitionEvent, CM>

pagehidesCaptured

open override fun pagehidesCaptured(init: PageTransitionEvent.() -> Unit): Listener<PageTransitionEvent, CM>

pagehidesCapturedIf

open override fun pagehidesCapturedIf(selector: PageTransitionEvent.() -> Boolean): Listener<PageTransitionEvent, CM>

pagehidesIf

open override fun pagehidesIf(selector: PageTransitionEvent.() -> Boolean): Listener<PageTransitionEvent, CM>

pageshows

open override fun pageshows(init: PageTransitionEvent.() -> Unit): Listener<PageTransitionEvent, CM>

pageshowsCaptured

open override fun pageshowsCaptured(init: PageTransitionEvent.() -> Unit): Listener<PageTransitionEvent, CM>

pageshowsCapturedIf

open override fun pageshowsCapturedIf(selector: PageTransitionEvent.() -> Boolean): Listener<PageTransitionEvent, CM>

pageshowsIf

open override fun pageshowsIf(selector: PageTransitionEvent.() -> Boolean): Listener<PageTransitionEvent, CM>

param

open override fun param(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLParamElement>.() -> Unit): HtmlTag<HTMLParamElement>

pastes

open override fun pastes(init: ClipboardEvent.() -> Unit): Listener<ClipboardEvent, CM>

pastesCaptured

open override fun pastesCaptured(init: ClipboardEvent.() -> Unit): Listener<ClipboardEvent, CM>

pastesCapturedIf

open override fun pastesCapturedIf(selector: ClipboardEvent.() -> Boolean): Listener<ClipboardEvent, CM>

pastesIf

open override fun pastesIf(selector: ClipboardEvent.() -> Boolean): Listener<ClipboardEvent, CM>

path

open override fun path(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: SvgTag.() -> Unit): SvgTag

pauses

open override fun pauses(init: Event.() -> Unit): Listener<Event, CM>

pausesCaptured

open override fun pausesCaptured(init: Event.() -> Unit): Listener<Event, CM>

pausesCapturedIf

open override fun pausesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

pausesIf

open override fun pausesIf(selector: Event.() -> Boolean): Listener<Event, CM>

picture

open override fun picture(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLPictureElement>.() -> Unit): HtmlTag<HTMLPictureElement>

playings

open override fun playings(init: Event.() -> Unit): Listener<Event, CM>

playingsCaptured

open override fun playingsCaptured(init: Event.() -> Unit): Listener<Event, CM>

playingsCapturedIf

open override fun playingsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

playingsIf

open override fun playingsIf(selector: Event.() -> Boolean): Listener<Event, CM>

plays

open override fun plays(init: Event.() -> Unit): Listener<Event, CM>

playsCaptured

open override fun playsCaptured(init: Event.() -> Unit): Listener<Event, CM>

playsCapturedIf

open override fun playsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

playsIf

open override fun playsIf(selector: Event.() -> Boolean): Listener<Event, CM>

popOver

fun RenderContext.popOver(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: PopOver<HTMLDivElement>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a PopOver with a HTMLDivElement as default root Tag.

fun <C : HTMLElement> RenderContext.popOver(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: PopOver<C>.() -> Unit): Tag<C>

Factory function to create a PopOver.

popstates

open override fun popstates(init: PopStateEvent.() -> Unit): Listener<PopStateEvent, CM>

popstatesCaptured

open override fun popstatesCaptured(init: PopStateEvent.() -> Unit): Listener<PopStateEvent, CM>

popstatesCapturedIf

open override fun popstatesCapturedIf(selector: PopStateEvent.() -> Boolean): Listener<PopStateEvent, CM>

popstatesIf

open override fun popstatesIf(selector: PopStateEvent.() -> Boolean): Listener<PopStateEvent, CM>

portal

fun RenderContext.portal(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, content: Tag<HTMLDivElement>.(close: suspend (Unit) -> Unit) -> Unit)

fun <C : HTMLElement> RenderContext.portal(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, content: Tag<C>.(close: suspend (Unit) -> Unit) -> Unit = {})

With Portalling a rendered overlay will be rendered outside of the clipping ancestors to avoid clipping. Therefore, a portalRoot is needed as last element in the document.body.

portalRoot

fun RenderContext.portalRoot(scopeContext: ScopeContext.() -> Unit = {}): RenderContext

A portalRoot is needed to use floating components like modal, toast and popupPanel.

pre

open override fun pre(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLPreElement>.() -> Unit): HtmlTag<HTMLPreElement>

progress

open override fun progress(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLProgressElement>.() -> Unit): HtmlTag<HTMLProgressElement>

progresss

open override fun progresss(init: Event.() -> Unit): Listener<Event, CM>

progresssCaptured

open override fun progresssCaptured(init: Event.() -> Unit): Listener<Event, CM>

progresssCapturedIf

open override fun progresssCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

progresssIf

open override fun progresssIf(selector: Event.() -> Boolean): Listener<Event, CM>

open override fun q(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLQuoteElement>.() -> Unit): HtmlTag<HTMLQuoteElement>

quote

open override fun quote(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLQuoteElement>.() -> Unit): HtmlTag<HTMLQuoteElement>

radioGroup

fun <T> RenderContext.radioGroup(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: RadioGroup<HTMLDivElement, T>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a RadioGroup with a HTMLDivElement as default root Tag.

fun <C : HTMLElement, T> RenderContext.radioGroup(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: RadioGroup<C, T>.() -> Unit): Tag<C>

Factory function to create a RadioGroup.

ratechanges

open override fun ratechanges(init: Event.() -> Unit): Listener<Event, CM>

ratechangesCaptured

open override fun ratechangesCaptured(init: Event.() -> Unit): Listener<Event, CM>

ratechangesCapturedIf

open override fun ratechangesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

ratechangesIf

open override fun ratechangesIf(selector: Event.() -> Boolean): Listener<Event, CM>

open override fun <N : Node, W : WithDomNode<N>> register(element: W, content: (W) -> Unit): W

render

fun render()

render

open override fun <V> Flow<V>.render(into: Tag<HTMLElement>?, content: Tag<*>.(V) -> Unit)

renderEach

open override fun <V> Store<List<V>>.renderEach(idProvider: IdProvider<V, *>, into: Tag<HTMLElement>?, content: RenderContext.(Store<V>) -> HtmlTag<HTMLElement>)

open override fun <V> Flow<List<V>>.renderEach(idProvider: IdProvider<V, *>?, into: Tag<HTMLElement>?, batch: Boolean, content: RenderContext.(V) -> Tag<HTMLElement>)

renderFalse

open override fun Flow<Boolean>.renderFalse(into: Tag<HTMLElement>?, content: Tag<*>.() -> Unit)

renderIf

open override fun <V> Flow<V>.renderIf(predicate: (V) -> Boolean, into: Tag<HTMLElement>?, content: Tag<*>.(V) -> Unit)

renderIs

open override fun <W : Any> Flow<*>.renderIs(klass: KClass<W>, into: Tag<HTMLElement>?, content: Tag<*>.(W) -> Unit)

renderNotNull

open override fun <V> Flow<V?>.renderNotNull(into: Tag<HTMLElement>?, content: Tag<*>.(V) -> Unit)

renderText

open override fun <T> Flow<T>.renderText(into: Tag<*>?)

open override fun Flow<String>.renderText(into: Tag<*>?)

renderTrue

open override fun Flow<Boolean>.renderTrue(into: Tag<HTMLElement>?, content: Tag<*>.() -> Unit)

resets

open override fun resets(init: Event.() -> Unit): Listener<Event, CM>

resetsCaptured

open override fun resetsCaptured(init: Event.() -> Unit): Listener<Event, CM>

resetsCapturedIf

open override fun resetsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

resetsIf

open override fun resetsIf(selector: Event.() -> Boolean): Listener<Event, CM>

resizes

open override fun resizes(init: Event.() -> Unit): Listener<Event, CM>

resizesCaptured

open override fun resizesCaptured(init: Event.() -> Unit): Listener<Event, CM>

resizesCapturedIf

open override fun resizesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

resizesIf

open override fun resizesIf(selector: Event.() -> Boolean): Listener<Event, CM>

open override fun rp(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

open override fun rt(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

ruby

open override fun ruby(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

open override fun s(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

samp

open override fun samp(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

script

open override fun script(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLScriptElement>.() -> Unit): HtmlTag<HTMLScriptElement>

scrolls

open override fun scrolls(init: Event.() -> Unit): Listener<Event, CM>

scrollsCaptured

open override fun scrollsCaptured(init: Event.() -> Unit): Listener<Event, CM>

scrollsCapturedIf

open override fun scrollsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

scrollsIf

open override fun scrollsIf(selector: Event.() -> Boolean): Listener<Event, CM>

searchs

open override fun searchs(init: Event.() -> Unit): Listener<Event, CM>

searchsCaptured

open override fun searchsCaptured(init: Event.() -> Unit): Listener<Event, CM>

searchsCapturedIf

open override fun searchsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

searchsIf

open override fun searchsIf(selector: Event.() -> Boolean): Listener<Event, CM>

section

open override fun section(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

seekeds

open override fun seekeds(init: Event.() -> Unit): Listener<Event, CM>

seekedsCaptured

open override fun seekedsCaptured(init: Event.() -> Unit): Listener<Event, CM>

seekedsCapturedIf

open override fun seekedsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

seekedsIf

open override fun seekedsIf(selector: Event.() -> Boolean): Listener<Event, CM>

seekings

open override fun seekings(init: Event.() -> Unit): Listener<Event, CM>

seekingsCaptured

open override fun seekingsCaptured(init: Event.() -> Unit): Listener<Event, CM>

seekingsCapturedIf

open override fun seekingsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

seekingsIf

open override fun seekingsIf(selector: Event.() -> Boolean): Listener<Event, CM>

select

open override fun select(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLSelectElement>.() -> Unit): HtmlTag<HTMLSelectElement>

selects

open override fun selects(init: Event.() -> Unit): Listener<Event, CM>

selectsCaptured

open override fun selectsCaptured(init: Event.() -> Unit): Listener<Event, CM>

selectsCapturedIf

open override fun selectsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

selectsIf

open override fun selectsIf(selector: Event.() -> Boolean): Listener<Event, CM>

setFocus

suspend fun Tag<HTMLElement>.setFocus(maxRetries: Int = 10)

Sets focus on the Tag it is called on. Continues to try setting the focus until it was successful or the maximum number of retries is reached. Use this function for example to set the focus on an element that just becomes visible.

setInitialFocus

fun Tag<HTMLElement>.setInitialFocus()

Mark some Tag with a data-attribute INITIAL_FOCUS_DATA_ATTR so that the trapFocusInMountpoint function can find this Tag and set the initial focus to it.

shows

open override fun shows(init: Event.() -> Unit): Listener<Event, CM>

showsCaptured

open override fun showsCaptured(init: Event.() -> Unit): Listener<Event, CM>

showsCapturedIf

open override fun showsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

showsIf

open override fun showsIf(selector: Event.() -> Boolean): Listener<Event, CM>

span

open override fun span(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLSpanElement>.() -> Unit): HtmlTag<HTMLSpanElement>

stalleds

open override fun stalleds(init: Event.() -> Unit): Listener<Event, CM>

stalledsCaptured

open override fun stalledsCaptured(init: Event.() -> Unit): Listener<Event, CM>

stalledsCapturedIf

open override fun stalledsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

stalledsIf

open override fun stalledsIf(selector: Event.() -> Boolean): Listener<Event, CM>

storages

open override fun storages(init: StorageEvent.() -> Unit): Listener<StorageEvent, CM>

storagesCaptured

open override fun storagesCaptured(init: StorageEvent.() -> Unit): Listener<StorageEvent, CM>

storagesCapturedIf

open override fun storagesCapturedIf(selector: StorageEvent.() -> Boolean): Listener<StorageEvent, CM>

storagesIf

open override fun storagesIf(selector: StorageEvent.() -> Boolean): Listener<StorageEvent, CM>

strong

open override fun strong(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

sub

open override fun sub(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

submits

open override fun submits(init: Event.() -> Unit): Listener<Event, CM>

submitsCaptured

open override fun submitsCaptured(init: Event.() -> Unit): Listener<Event, CM>

submitsCapturedIf

open override fun submitsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

submitsIf

open override fun submitsIf(selector: Event.() -> Boolean): Listener<Event, CM>

open override fun <X : Event> subscribe(eventName: String, capture: Boolean, selector: X.() -> Boolean): Listener<X, CM>

summary

open override fun summary(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

sup

open override fun sup(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

suspends

open override fun suspends(init: Event.() -> Unit): Listener<Event, CM>

suspendsCaptured

open override fun suspendsCaptured(init: Event.() -> Unit): Listener<Event, CM>

suspendsCapturedIf

open override fun suspendsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

suspendsIf

open override fun suspendsIf(selector: Event.() -> Boolean): Listener<Event, CM>

svg

open override fun svg(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: SvgTag.() -> Unit): SvgTag

switch

fun RenderContext.switch(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: Switch<HTMLButtonElement>.() -> Unit): Tag<HTMLButtonElement>

Factory function to create a Switch with a HTMLButtonElement as default root Tag.

fun <C : HTMLElement> RenderContext.switch(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: Switch<C>.() -> Unit): Tag<C>

Factory function to create a Switch.

switchWithLabel

fun RenderContext.switchWithLabel(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: SwitchWithLabel<HTMLDivElement>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a SwitchWithLabel with a HTMLDivElement as default root Tag.

fun <C : HTMLElement> RenderContext.switchWithLabel(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: SwitchWithLabel<C>.() -> Unit): Tag<C>

Factory function to create a SwitchWithLabel.

tabGroup

fun RenderContext.tabGroup(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: TabGroup<HTMLDivElement>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a TabGroup with a HTMLDivElement as default root Tag.

fun <C : HTMLElement> RenderContext.tabGroup(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: TabGroup<C>.() -> Unit): Tag<C>

Factory function to create a TabGroup.

table

open override fun table(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTableElement>.() -> Unit): HtmlTag<HTMLTableElement>

tbody

open override fun tbody(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTableSectionElement>.() -> Unit): HtmlTag<HTMLTableSectionElement>

open override fun td(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTableCellElement>.() -> Unit): HtmlTag<HTMLTableCellElement>

textArea

fun RenderContext.textArea(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, initialize: TextArea<HTMLDivElement>.() -> Unit): Tag<HTMLDivElement>

Factory function to create a TextArea with a HTMLDivElement as default root Tag.

fun <C : HTMLElement> RenderContext.textArea(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: TextArea<C>.() -> Unit): Tag<C>

Factory function to create a TextArea.

textarea

open override fun textarea(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTextAreaElement>.() -> Unit): HtmlTag<HTMLTextAreaElement>

tfoot

open override fun tfoot(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTableSectionElement>.() -> Unit): HtmlTag<HTMLTableSectionElement>

open override fun th(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTableCellElement>.() -> Unit): HtmlTag<HTMLTableCellElement>

thead

open override fun thead(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTableSectionElement>.() -> Unit): HtmlTag<HTMLTableSectionElement>

time

open override fun time(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTimeElement>.() -> Unit): HtmlTag<HTMLTimeElement>

timeupdates

open override fun timeupdates(init: Event.() -> Unit): Listener<Event, CM>

timeupdatesCaptured

open override fun timeupdatesCaptured(init: Event.() -> Unit): Listener<Event, CM>

timeupdatesCapturedIf

open override fun timeupdatesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

timeupdatesIf

open override fun timeupdatesIf(selector: Event.() -> Boolean): Listener<Event, CM>

toggles

open override fun toggles(init: Event.() -> Unit): Listener<Event, CM>

togglesCaptured

open override fun togglesCaptured(init: Event.() -> Unit): Listener<Event, CM>

togglesCapturedIf

open override fun togglesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

togglesIf

open override fun togglesIf(selector: Event.() -> Boolean): Listener<Event, CM>

tooltip

fun Tag<HTMLElement>.tooltip(classes: String? = null, id: String? = null, internalScope: ScopeContext.() -> Unit = {}, initialize: Tooltip<HTMLDivElement>.() -> Unit)

Factory function to create a tooltip with a HTMLDivElement as default Tag.

fun <C : HTMLElement> Tag<HTMLElement>.tooltip(classes: String? = null, id: String? = null, scope: ScopeContext.() -> Unit = {}, tag: TagFactory<Tag<C>>, initialize: Tooltip<C>.() -> Unit)

Factory function to create a tooltip.

touchcancels

open override fun touchcancels(init: TouchEvent.() -> Unit): Listener<TouchEvent, CM>

touchcancelsCaptured

open override fun touchcancelsCaptured(init: TouchEvent.() -> Unit): Listener<TouchEvent, CM>

touchcancelsCapturedIf

open override fun touchcancelsCapturedIf(selector: TouchEvent.() -> Boolean): Listener<TouchEvent, CM>

touchcancelsIf

open override fun touchcancelsIf(selector: TouchEvent.() -> Boolean): Listener<TouchEvent, CM>

touchends

open override fun touchends(init: TouchEvent.() -> Unit): Listener<TouchEvent, CM>

touchendsCaptured

open override fun touchendsCaptured(init: TouchEvent.() -> Unit): Listener<TouchEvent, CM>

touchendsCapturedIf

open override fun touchendsCapturedIf(selector: TouchEvent.() -> Boolean): Listener<TouchEvent, CM>

touchendsIf

open override fun touchendsIf(selector: TouchEvent.() -> Boolean): Listener<TouchEvent, CM>

touchmoves

open override fun touchmoves(init: TouchEvent.() -> Unit): Listener<TouchEvent, CM>

touchmovesCaptured

open override fun touchmovesCaptured(init: TouchEvent.() -> Unit): Listener<TouchEvent, CM>

touchmovesCapturedIf

open override fun touchmovesCapturedIf(selector: TouchEvent.() -> Boolean): Listener<TouchEvent, CM>

touchmovesIf

open override fun touchmovesIf(selector: TouchEvent.() -> Boolean): Listener<TouchEvent, CM>

touchstarts

open override fun touchstarts(init: TouchEvent.() -> Unit): Listener<TouchEvent, CM>

touchstartsCaptured

open override fun touchstartsCaptured(init: TouchEvent.() -> Unit): Listener<TouchEvent, CM>

touchstartsCapturedIf

open override fun touchstartsCapturedIf(selector: TouchEvent.() -> Boolean): Listener<TouchEvent, CM>

touchstartsIf

open override fun touchstartsIf(selector: TouchEvent.() -> Boolean): Listener<TouchEvent, CM>

open override fun tr(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTableRowElement>.() -> Unit): HtmlTag<HTMLTableRowElement>

track

open override fun track(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLTrackElement>.() -> Unit): HtmlTag<HTMLTrackElement>

transitionends

open override fun transitionends(init: Event.() -> Unit): Listener<Event, CM>

transitionendsCaptured

open override fun transitionendsCaptured(init: Event.() -> Unit): Listener<Event, CM>

transitionendsCapturedIf

open override fun transitionendsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

transitionendsIf

open override fun transitionendsIf(selector: Event.() -> Boolean): Listener<Event, CM>

trapFocusInMountpoint

fun Tag<HTMLElement>.trapFocusInMountpoint(restoreFocus: Boolean = true, setInitialFocus: InitialFocus = TryToSet)

This function enables a so called focus-trap. This enforces the specific behaviour within the receiver Tag, that switching the focus is only possible on elements that are inside the receiver. No other focusable elements outside the enclosing container will get the focus.

trapFocusWhenever

fun Tag<HTMLElement>.trapFocusWhenever(condition: Flow<Boolean>, restoreFocus: Boolean = true, setInitialFocus: InitialFocus = TryToSet)

This variant of trapFocusInMountpoint allows to reactively trap a focus based on a conditional Flow of Boolean. This should be applied in all situations, where the DOM subtree of the trap is not inside a mount-point, but only activated or disabled by some Flow.

open override fun u(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

open override fun ul(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLUListElement>.() -> Unit): HtmlTag<HTMLUListElement>

unaryPlus

open operator override fun String.unaryPlus(): Node

unloads

open override fun unloads(init: Event.() -> Unit): Listener<Event, CM>

unloadsCaptured

open override fun unloadsCaptured(init: Event.() -> Unit): Listener<Event, CM>

unloadsCapturedIf

open override fun unloadsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

unloadsIf

open override fun unloadsIf(selector: Event.() -> Boolean): Listener<Event, CM>

var

open override fun var(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

video

open override fun video(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLVideoElement>.() -> Unit): HtmlTag<HTMLVideoElement>

volumechanges

open override fun volumechanges(init: Event.() -> Unit): Listener<Event, CM>

volumechangesCaptured

open override fun volumechangesCaptured(init: Event.() -> Unit): Listener<Event, CM>

volumechangesCapturedIf

open override fun volumechangesCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

volumechangesIf

open override fun volumechangesIf(selector: Event.() -> Boolean): Listener<Event, CM>

waitings

open override fun waitings(init: Event.() -> Unit): Listener<Event, CM>

waitingsCaptured

open override fun waitingsCaptured(init: Event.() -> Unit): Listener<Event, CM>

waitingsCapturedIf

open override fun waitingsCapturedIf(selector: Event.() -> Boolean): Listener<Event, CM>

waitingsIf

open override fun waitingsIf(selector: Event.() -> Boolean): Listener<Event, CM>

wbr

open override fun wbr(baseClass: String?, id: String?, scope: ScopeContext.() -> Unit, content: HtmlTag<HTMLElement>.() -> Unit): HtmlTag<HTMLElement>

wheels

open override fun wheels(init: WheelEvent.() -> Unit): Listener<WheelEvent, CM>

wheelsCaptured

open override fun wheelsCaptured(init: WheelEvent.() -> Unit): Listener<WheelEvent, CM>

wheelsCapturedIf

open override fun wheelsCapturedIf(selector: WheelEvent.() -> Boolean): Listener<WheelEvent, CM>

wheelsIf

open override fun wheelsIf(selector: WheelEvent.() -> Boolean): Listener<WheelEvent, CM>