core/dev.fritz2.core/WithEvents

WithEvents

interface WithEvents<out T : EventTarget>

Contains all javascript event types. Take a look here.

Sometimes it is necessary to use a more generic type (like Event) because the type that is offered to the listener is not always consistent (on different browsers, different actions, etc.)

Inheritors

Window

Tag

Types

Companion

object Companion

Properties

aborts

open val aborts: Listener<Event, T>

occurs when the loading of a media is aborted

abortsCaptured

open val abortsCaptured: Listener<Event, T>

occurs when the loading of a media is aborted

afterprints

open val afterprints: Listener<Event, T>

occurs when a page has started printing, or if the print dialogue box has been closed

afterprintsCaptured

open val afterprintsCaptured: Listener<Event, T>

occurs when a page has started printing, or if the print dialogue box has been closed

animationends

open val animationends: Listener<Event, T>

occurs when a CSS Animation has completed

animationendsCaptured

open val animationendsCaptured: Listener<Event, T>

occurs when a CSS Animation has completed

animationiterations

open val animationiterations: Listener<Event, T>

occurs when an iteration of a CSS Animation ends, and another one begins

animationiterationsCaptured

open val animationiterationsCaptured: Listener<Event, T>

occurs when an iteration of a CSS Animation ends, and another one begins

animationstarts

open val animationstarts: Listener<Event, T>

occurs when a CSS Animation has started

animationstartsCaptured

open val animationstartsCaptured: Listener<Event, T>

occurs when a CSS Animation has started

beforeprints

open val beforeprints: Listener<Event, T>

occurs when a page is about to be printed

beforeprintsCaptured

open val beforeprintsCaptured: Listener<Event, T>

occurs when a page is about to be printed

beforeunloads

open val beforeunloads: Listener<Event, T>

occurs before the document is about to be unloaded

beforeunloadsCaptured

open val beforeunloadsCaptured: Listener<Event, T>

occurs before the document is about to be unloaded

blurs

open val blurs: Listener<FocusEvent, T>

occurs when an element loses focus

blursCaptured

open val blursCaptured: Listener<FocusEvent, T>

occurs when an element loses focus

canplays

open val canplays: Listener<Event, T>

occurs when the browser can start playing the media (when it has buffered enough to begin)

canplaysCaptured

open val canplaysCaptured: Listener<Event, T>

occurs when the browser can start playing the media (when it has buffered enough to begin)

canplaythroughs

open val canplaythroughs: Listener<Event, T>

occurs when the browser can play through the media without stopping for buffering

canplaythroughsCaptured

open val canplaythroughsCaptured: Listener<Event, T>

occurs when the browser can play through the media without stopping for buffering

changes

open val changes: Listener<Event, T>

occurs when the content of a form element, the selection, or the checked state have changed (for <input>, <select>, and <textarea>)

changesCaptured

open val changesCaptured: Listener<Event, T>

occurs when the content of a form element, the selection, or the checked state have changed (for <input>, <select>, and <textarea>)

clicks

open val clicks: Listener<MouseEvent, T>

occurs when the user clicks on an element

clicksCaptured

open val clicksCaptured: Listener<MouseEvent, T>

occurs when the user clicks on an element

contextmenus

open val contextmenus: Listener<MouseEvent, T>

occurs when the user right-clicks on an element to open a context menu

contextmenusCaptured

open val contextmenusCaptured: Listener<MouseEvent, T>

occurs when the user right-clicks on an element to open a context menu

copys

open val copys: Listener<ClipboardEvent, T>

occurs when the user copies the content of an element

copysCaptured

open val copysCaptured: Listener<ClipboardEvent, T>

occurs when the user copies the content of an element

cuts

open val cuts: Listener<ClipboardEvent, T>

occurs when the user cuts the content of an element

cutsCaptured

open val cutsCaptured: Listener<ClipboardEvent, T>

occurs when the user cuts the content of an element

dblclicks

open val dblclicks: Listener<MouseEvent, T>

occurs when the user double-clicks on an element

dblclicksCaptured

open val dblclicksCaptured: Listener<MouseEvent, T>

occurs when the user double-clicks on an element

dragends

open val dragends: Listener<DragEvent, T>

occurs when the user has finished dragging an element

dragendsCaptured

open val dragendsCaptured: Listener<DragEvent, T>

occurs when the user has finished dragging an element

dragenters

open val dragenters: Listener<DragEvent, T>

occurs when the dragged element enters the drop target

dragentersCaptured

open val dragentersCaptured: Listener<DragEvent, T>

occurs when the dragged element enters the drop target

dragleaves

open val dragleaves: Listener<DragEvent, T>

occurs when the dragged element leaves the drop target

dragleavesCaptured

open val dragleavesCaptured: Listener<DragEvent, T>

occurs when the dragged element leaves the drop target

dragovers

open val dragovers: Listener<DragEvent, T>

occurs when the dragged element is over the drop target

dragoversCaptured

open val dragoversCaptured: Listener<DragEvent, T>

occurs when the dragged element is over the drop target

drags

open val drags: Listener<DragEvent, T>

occurs when an element is being dragged

dragsCaptured

open val dragsCaptured: Listener<DragEvent, T>

occurs when an element is being dragged

dragstarts

open val dragstarts: Listener<DragEvent, T>

occurs when the user starts to drag an element

dragstartsCaptured

open val dragstartsCaptured: Listener<DragEvent, T>

occurs when the user starts to drag an element

drops

open val drops: Listener<DragEvent, T>

occurs when the dragged element is dropped on the drop target

dropsCaptured

open val dropsCaptured: Listener<DragEvent, T>

occurs when the dragged element is dropped on the drop target

durationchanges

open val durationchanges: Listener<Event, T>

occurs when the duration of the media is changed

durationchangesCaptured

open val durationchangesCaptured: Listener<Event, T>

occurs when the duration of the media is changed

endeds

open val endeds: Listener<Event, T>

occurs when the media has reach the end (useful for messages like "thanks for listening")

endedsCaptured

open val endedsCaptured: Listener<Event, T>

occurs when the media has reach the end (useful for messages like "thanks for listening")

errors

open val errors: Listener<Event, T>

occurs when a CSS Animation has completed

errorsCaptured

open val errorsCaptured: Listener<Event, T>

occurs when a CSS Animation has completed

focusins

open val focusins: Listener<FocusEvent, T>

occurs when an element is about to get focus

focusinsCaptured

open val focusinsCaptured: Listener<FocusEvent, T>

occurs when an element is about to get focus

focusouts

open val focusouts: Listener<FocusEvent, T>

occurs when an element is about to lose focus

focusoutsCaptured

open val focusoutsCaptured: Listener<FocusEvent, T>

occurs when an element is about to lose focus

focuss

open val focuss: Listener<FocusEvent, T>

occurs when an element gets focus

focussCaptured

open val focussCaptured: Listener<FocusEvent, T>

occurs when an element gets focus

fullscreenchanges

open val fullscreenchanges: Listener<Event, T>

occurs when an element is displayed in fullscreen mode

fullscreenchangesCaptured

open val fullscreenchangesCaptured: Listener<Event, T>

occurs when an element is displayed in fullscreen mode

fullscreenerrors

open val fullscreenerrors: Listener<Event, T>

occurs when an element can not be displayed in fullscreen mode

fullscreenerrorsCaptured

open val fullscreenerrorsCaptured: Listener<Event, T>

occurs when an element can not be displayed in fullscreen mode

hashchanges

open val hashchanges: Listener<HashChangeEvent, T>

occurs when there has been changes to the anchor part of a URL

hashchangesCaptured

open val hashchangesCaptured: Listener<HashChangeEvent, T>

occurs when there has been changes to the anchor part of a URL

inputs

open val inputs: Listener<Event, T>

occurs when an element gets user input has to use Event as type because Chrome and Safari offer Events instead of InputEvents when selecting from a datalist

inputsCaptured

open val inputsCaptured: Listener<Event, T>

occurs when an element gets user input has to use Event as type because Chrome and Safari offer Events instead of InputEvents when selecting from a datalist

invalids

open val invalids: Listener<Event, T>

occurs when an element is invalid

invalidsCaptured

open val invalidsCaptured: Listener<Event, T>

occurs when an element is invalid

keydowns

open val keydowns: Listener<KeyboardEvent, T>

occurs when the user is pressing a key

keydownsCaptured

open val keydownsCaptured: Listener<KeyboardEvent, T>

occurs when the user is pressing a key

keypresss

open val keypresss: Listener<KeyboardEvent, T>

occurs when the user presses a key

keypresssCaptured

open val keypresssCaptured: Listener<KeyboardEvent, T>

occurs when the user presses a key

keyups

open val keyups: Listener<KeyboardEvent, T>

occurs when the user releases a key

keyupsCaptured

open val keyupsCaptured: Listener<KeyboardEvent, T>

occurs when the user releases a key

loadeddatas

open val loadeddatas: Listener<Event, T>

occurs when media data is loaded

loadeddatasCaptured

open val loadeddatasCaptured: Listener<Event, T>

occurs when media data is loaded

loadedmetadatas

open val loadedmetadatas: Listener<Event, T>

occurs when metadata (like dimensions and duration) are loaded

loadedmetadatasCaptured

open val loadedmetadatasCaptured: Listener<Event, T>

occurs when metadata (like dimensions and duration) are loaded

loads

open val loads: Listener<Event, T>

occurs when an object has loaded

loadsCaptured

open val loadsCaptured: Listener<Event, T>

occurs when an object has loaded

loadstarts

open val loadstarts: Listener<ProgressEvent, T>

occurs when the browser starts looking for the specified media

loadstartsCaptured

open val loadstartsCaptured: Listener<ProgressEvent, T>

occurs when the browser starts looking for the specified media

messages

open val messages: Listener<Event, T>

occurs when a message is received through the event source

messagesCaptured

open val messagesCaptured: Listener<Event, T>

occurs when a message is received through the event source

mousedowns

open val mousedowns: Listener<MouseEvent, T>

occurs when the user presses a mouse button over an element

mousedownsCaptured

open val mousedownsCaptured: Listener<MouseEvent, T>

occurs when the user presses a mouse button over an element

mouseenters

open val mouseenters: Listener<MouseEvent, T>

occurs when the pointer is moved onto an element

mouseentersCaptured

open val mouseentersCaptured: Listener<MouseEvent, T>

occurs when the pointer is moved onto an element

mouseleaves

open val mouseleaves: Listener<MouseEvent, T>

occurs when the pointer is moved out of an element

mouseleavesCaptured

open val mouseleavesCaptured: Listener<MouseEvent, T>

occurs when the pointer is moved out of an element

mousemoves

open val mousemoves: Listener<MouseEvent, T>

occurs when the pointer is moving while it is over an element

mousemovesCaptured

open val mousemovesCaptured: Listener<MouseEvent, T>

occurs when the pointer is moving while it is over an element

mouseouts

open val mouseouts: Listener<MouseEvent, T>

occurs when a user moves the mouse pointer out of an element, or out of one of its children

mouseoutsCaptured

open val mouseoutsCaptured: Listener<MouseEvent, T>

occurs when a user moves the mouse pointer out of an element, or out of one of its children

mouseovers

open val mouseovers: Listener<MouseEvent, T>

occurs when the pointer is moved onto an element, or onto one of its children

mouseoversCaptured

open val mouseoversCaptured: Listener<MouseEvent, T>

occurs when the pointer is moved onto an element, or onto one of its children

mouseups

open val mouseups: Listener<MouseEvent, T>

occurs when a user releases a mouse button over an element

mouseupsCaptured

open val mouseupsCaptured: Listener<MouseEvent, T>

occurs when a user releases a mouse button over an element

offlines

open val offlines: Listener<Event, T>

occurs when the browser starts to work offline

offlinesCaptured

open val offlinesCaptured: Listener<Event, T>

occurs when the browser starts to work offline

onlines

open val onlines: Listener<Event, T>

occurs when the browser starts to work online

onlinesCaptured

open val onlinesCaptured: Listener<Event, T>

occurs when the browser starts to work online

opens

open val opens: Listener<Event, T>

occurs when a connection with the event source is opened

opensCaptured

open val opensCaptured: Listener<Event, T>

occurs when a connection with the event source is opened

pagehides

open val pagehides: Listener<PageTransitionEvent, T>

occurs when the user navigates away from a webpage

pagehidesCaptured

open val pagehidesCaptured: Listener<PageTransitionEvent, T>

occurs when the user navigates away from a webpage

pageshows

open val pageshows: Listener<PageTransitionEvent, T>

occurs when the user navigates to a webpage

pageshowsCaptured

open val pageshowsCaptured: Listener<PageTransitionEvent, T>

occurs when the user navigates to a webpage

pastes

open val pastes: Listener<ClipboardEvent, T>

occurs when the user pastes some content in an element

pastesCaptured

open val pastesCaptured: Listener<ClipboardEvent, T>

occurs when the user pastes some content in an element

pauses

open val pauses: Listener<Event, T>

occurs when the media is paused either by the user or programmatically

pausesCaptured

open val pausesCaptured: Listener<Event, T>

occurs when the media is paused either by the user or programmatically

playings

open val playings: Listener<Event, T>

occurs when the media is playing after having been paused or stopped for buffering

playingsCaptured

open val playingsCaptured: Listener<Event, T>

occurs when the media is playing after having been paused or stopped for buffering

plays

open val plays: Listener<Event, T>

occurs when the media has been started or is no longer paused

playsCaptured

open val playsCaptured: Listener<Event, T>

occurs when the media has been started or is no longer paused

popstates

open val popstates: Listener<PopStateEvent, T>

occurs when the window's history changes

popstatesCaptured

open val popstatesCaptured: Listener<PopStateEvent, T>

occurs when the window's history changes

progresss

open val progresss: Listener<Event, T>

occurs when the browser is in the process of getting the media data (downloading the media)

progresssCaptured

open val progresssCaptured: Listener<Event, T>

occurs when the browser is in the process of getting the media data (downloading the media)

ratechanges

open val ratechanges: Listener<Event, T>

occurs when the playing speed of the media is changed

ratechangesCaptured

open val ratechangesCaptured: Listener<Event, T>

occurs when the playing speed of the media is changed

resets

open val resets: Listener<Event, T>

occurs when a form is reset

resetsCaptured

open val resetsCaptured: Listener<Event, T>

occurs when a form is reset

resizes

open val resizes: Listener<Event, T>

occurs when the document view is resized

resizesCaptured

open val resizesCaptured: Listener<Event, T>

occurs when the document view is resized

scrolls

open val scrolls: Listener<Event, T>

occurs when an element's scrollbar is being scrolled

scrollsCaptured

open val scrollsCaptured: Listener<Event, T>

occurs when an element's scrollbar is being scrolled

searchs

open val searchs: Listener<Event, T>

occurs when the user writes something in a search field (for )

searchsCaptured

open val searchsCaptured: Listener<Event, T>

occurs when the user writes something in a search field (for )

seekeds

open val seekeds: Listener<Event, T>

occurs when the user is finished moving/skipping to a new position in the media

seekedsCaptured

open val seekedsCaptured: Listener<Event, T>

occurs when the user is finished moving/skipping to a new position in the media

seekings

open val seekings: Listener<Event, T>

occurs when the user starts moving/skipping to a new position in the media

seekingsCaptured

open val seekingsCaptured: Listener<Event, T>

occurs when the user starts moving/skipping to a new position in the media

selects

open val selects: Listener<Event, T>

occurs after the user selects some text (for and )</p></div></div> </div> </div> </div> </div> </div>

selectsCaptured

open val selectsCaptured: Listener<Event, T>

occurs after the user selects some text (for and )</p></div></div> </div> </div> </div> </div> </div>

shows

open val shows: Listener<Event, T>

occurs when a

element is shown as a context menu

showsCaptured

open val showsCaptured: Listener<Event, T>

occurs when a

element is shown as a context menu

stalleds

open val stalleds: Listener<Event, T>

occurs when the browser is trying to get media data, but data is not available

stalledsCaptured

open val stalledsCaptured: Listener<Event, T>

occurs when the browser is trying to get media data, but data is not available

storages

open val storages: Listener<StorageEvent, T>

occurs when a Web Storage area is updated

storagesCaptured

open val storagesCaptured: Listener<StorageEvent, T>

occurs when a Web Storage area is updated

submits

open val submits: Listener<Event, T>

occurs when a form is submitted

submitsCaptured

open val submitsCaptured: Listener<Event, T>

occurs when a form is submitted

suspends

open val suspends: Listener<Event, T>

occurs when the browser is intentionally not getting media data

suspendsCaptured

open val suspendsCaptured: Listener<Event, T>

occurs when the browser is intentionally not getting media data

timeupdates

open val timeupdates: Listener<Event, T>

occurs when the playing position has changed (like when the user fast forwards to a different point in the media)

timeupdatesCaptured

open val timeupdatesCaptured: Listener<Event, T>

occurs when the playing position has changed (like when the user fast forwards to a different point in the media)

toggles

open val toggles: Listener<Event, T>

occurs when the user opens or closes the

element

togglesCaptured

open val togglesCaptured: Listener<Event, T>

occurs when the user opens or closes the

element

touchcancels

open val touchcancels: Listener<TouchEvent, T>

occurs when the touch is interrupted

touchcancelsCaptured

open val touchcancelsCaptured: Listener<TouchEvent, T>

occurs when the touch is interrupted

touchends

open val touchends: Listener<TouchEvent, T>

occurs when a finger is removed from a touch screen

touchendsCaptured

open val touchendsCaptured: Listener<TouchEvent, T>

occurs when a finger is removed from a touch screen

touchmoves

open val touchmoves: Listener<TouchEvent, T>

occurs when a finger is dragged across the screen

touchmovesCaptured

open val touchmovesCaptured: Listener<TouchEvent, T>

occurs when a finger is dragged across the screen

touchstarts

open val touchstarts: Listener<TouchEvent, T>

occurs when a finger is placed on a touch screen

touchstartsCaptured

open val touchstartsCaptured: Listener<TouchEvent, T>

occurs when a finger is placed on a touch screen

transitionends

open val transitionends: Listener<Event, T>

occurs when a CSS transition has completed

transitionendsCaptured

open val transitionendsCaptured: Listener<Event, T>

occurs when a CSS transition has completed

unloads

open val unloads: Listener<Event, T>

occurs once a page has unloaded (for )

unloadsCaptured

open val unloadsCaptured: Listener<Event, T>

occurs once a page has unloaded (for )

volumechanges

open val volumechanges: Listener<Event, T>

occurs when the volume of the media has changed (includes setting the volume to "mute")

volumechangesCaptured

open val volumechangesCaptured: Listener<Event, T>

occurs when the volume of the media has changed (includes setting the volume to "mute")

waitings

open val waitings: Listener<Event, T>

occurs when the media has paused but is expected to resume (like when the media pauses to buffer more data)

waitingsCaptured

open val waitingsCaptured: Listener<Event, T>

occurs when the media has paused but is expected to resume (like when the media pauses to buffer more data)

wheels

open val wheels: Listener<WheelEvent, T>

occurs when the mouse wheel rolls up or down over an element

wheelsCaptured

open val wheelsCaptured: Listener<WheelEvent, T>

occurs when the mouse wheel rolls up or down over an element

Functions

aborts

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

occurs when the loading of a media is aborted

abortsCaptured

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

occurs when the loading of a media is aborted

abortsCapturedIf

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

occurs when the loading of a media is aborted

abortsIf

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

occurs when the loading of a media is aborted

afterprints

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

occurs when a page has started printing, or if the print dialogue box has been closed

afterprintsCaptured

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

occurs when a page has started printing, or if the print dialogue box has been closed

afterprintsCapturedIf

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

occurs when a page has started printing, or if the print dialogue box has been closed

afterprintsIf

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

occurs when a page has started printing, or if the print dialogue box has been closed

animationends

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

occurs when a CSS Animation has completed

animationendsCaptured

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

occurs when a CSS Animation has completed

animationendsCapturedIf

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

occurs when a CSS Animation has completed

animationendsIf

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

occurs when a CSS Animation has completed

animationiterations

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

occurs when an iteration of a CSS Animation ends, and another one begins

animationiterationsCaptured

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

occurs when an iteration of a CSS Animation ends, and another one begins

animationiterationsCapturedIf

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

occurs when an iteration of a CSS Animation ends, and another one begins

animationiterationsIf

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

occurs when an iteration of a CSS Animation ends, and another one begins

animationstarts

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

occurs when a CSS Animation has completed

animationstartsCaptured

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

occurs when a CSS Animation has completed

animationstartsCapturedIf

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

occurs when a CSS Animation has started

animationstartsIf

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

occurs when a CSS Animation has started

beforeprints

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

occurs when a page is about to be printed

beforeprintsCaptured

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

occurs when a page is about to be printed

beforeprintsCapturedIf

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

occurs when a page is about to be printed

beforeprintsIf

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

occurs when a page is about to be printed

beforeunloads

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

occurs before the document is about to be unloaded

beforeunloadsCaptured

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

occurs before the document is about to be unloaded

beforeunloadsCapturedIf

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

occurs before the document is about to be unloaded

beforeunloadsIf

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

occurs before the document is about to be unloaded

blurs

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

occurs when an element loses focus

blursCaptured

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

occurs when an element loses focus

blursCapturedIf

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

occurs when an element loses focus

blursIf

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

occurs when an element loses focus

canplays

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

occurs when the browser can start playing the media (when it has buffered enough to begin)

canplaysCaptured

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

occurs when the browser can start playing the media (when it has buffered enough to begin)

canplaysCapturedIf

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

occurs when the browser can start playing the media (when it has buffered enough to begin)

canplaysIf

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

occurs when the browser can start playing the media (when it has buffered enough to begin)

canplaythroughs

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

occurs when the browser can play through the media without stopping for buffering

canplaythroughsCaptured

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

occurs when the browser can play through the media without stopping for buffering

canplaythroughsCapturedIf

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

occurs when the browser can play through the media without stopping for buffering

canplaythroughsIf

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

occurs when the browser can play through the media without stopping for buffering

changes

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

occurs when the content of a form element, the selection, or the checked state have changed (for <input>, <select>, and <textarea>)

changesCaptured

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

occurs when the content of a form element, the selection, or the checked state have changed (for <input>, <select>, and <textarea>)

changesCapturedIf

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

occurs when the content of a form element, the selection, or the checked state have changed (for <input>, <select>, and <textarea>)

changesIf

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

occurs when the content of a form element, the selection, or the checked state have changed (for <input>, <select>, and <textarea>)

clicks

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

occurs when the user clicks on an element

clicksCaptured

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

occurs when the user clicks on an element

clicksCapturedIf

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

occurs when the user clicks on an element

clicksIf

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

occurs when the user clicks on an element

contextmenus

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

occurs when the user right-clicks on an element to open a context menu

contextmenusCaptured

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

occurs when the user right-clicks on an element to open a context menu

contextmenusCapturedIf

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

occurs when the user right-clicks on an element to open a context menu

contextmenusIf

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

occurs when the user right-clicks on an element to open a context menu

copys

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

occurs when the user copies the content of an element

copysCaptured

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

occurs when the user copies the content of an element

copysCapturedIf

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

occurs when the user copies the content of an element

copysIf

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

occurs when the user copies the content of an element

cuts

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

occurs when the user cuts the content of an element

cutsCaptured

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

occurs when the user cuts the content of an element

cutsCapturedIf

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

occurs when the user cuts the content of an element

cutsIf

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

occurs when the user cuts the content of an element

dblclicks

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

occurs when the user double-clicks on an element

dblclicksCaptured

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

occurs when the user double-clicks on an element

dblclicksCapturedIf

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

occurs when the user double-clicks on an element

dblclicksIf

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

occurs when the user double-clicks on an element

dragends

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

occurs when the user has finished dragging an element

dragendsCaptured

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

occurs when the user has finished dragging an element

dragendsCapturedIf

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

occurs when the user has finished dragging an element

dragendsIf

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

occurs when the user has finished dragging an element

dragenters

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

occurs when the dragged element enters the drop target

dragentersCaptured

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

occurs when the dragged element enters the drop target

dragentersCapturedIf

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

occurs when the dragged element enters the drop target

dragentersIf

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

occurs when the dragged element enters the drop target

dragleaves

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

occurs when the dragged element leaves the drop target

dragleavesCaptured

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

occurs when the dragged element leaves the drop target

dragleavesCapturedIf

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

occurs when the dragged element leaves the drop target

dragleavesIf

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

occurs when the dragged element leaves the drop target

dragovers

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

occurs when the dragged element is over the drop target

dragoversCaptured

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

occurs when the dragged element is over the drop target

dragoversCapturedIf

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

occurs when the dragged element is over the drop target

dragoversIf

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

occurs when the dragged element is over the drop target

drags

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

occurs when an element is being dragged

dragsCaptured

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

occurs when an element is being dragged

dragsCapturedIf

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

occurs when an element is being dragged

dragsIf

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

occurs when an element is being dragged

dragstarts

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

occurs when the user starts to drag an element

dragstartsCaptured

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

occurs when the user starts to drag an element

dragstartsCapturedIf

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

occurs when the user starts to drag an element

dragstartsIf

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

occurs when the user starts to drag an element

drops

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

occurs when the dragged element is dropped on the drop target

dropsCaptured

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

occurs when the dragged element is dropped on the drop target

dropsCapturedIf

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

occurs when the dragged element is dropped on the drop target

dropsIf

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

occurs when the dragged element is dropped on the drop target

durationchanges

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

occurs when the duration of the media is changed

durationchangesCaptured

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

occurs when the duration of the media is changed

durationchangesCapturedIf

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

occurs when the duration of the media is changed

durationchangesIf

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

occurs when the duration of the media is changed

endeds

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

occurs when the media has reach the end (useful for messages like "thanks for listening")

endedsCaptured

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

occurs when the media has reach the end (useful for messages like "thanks for listening")

endedsCapturedIf

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

occurs when the media has reach the end (useful for messages like "thanks for listening")

endedsIf

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

occurs when the media has reach the end (useful for messages like "thanks for listening")

errors

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

occurs when there is an error while loading an external file (e.g. a document or an image).

errorsCaptured

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

occurs when there is an error while loading an external file (e.g. a document or an image).

errorsCapturedIf

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

occurs when there is an error while loading an external file (e.g. a document or an image).

errorsIf

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

occurs when there is an error while loading an external file (e.g. a document or an image).

focusins

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

occurs when an element is about to get focus

focusinsCaptured

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

occurs when an element is about to get focus

focusinsCapturedIf

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

occurs when an element is about to get focus

focusinsIf

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

occurs when an element is about to get focus

focusouts

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

occurs when an element is about to lose focus

focusoutsCaptured

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

occurs when an element is about to lose focus

focusoutsCapturedIf

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

occurs when an element is about to lose focus

focusoutsIf

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

occurs when an element is about to lose focus

focuss

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

occurs when an element gets focus

focussCaptured

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

occurs when an element gets focus

focussCapturedIf

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

occurs when an element gets focus

focussIf

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

occurs when an element gets focus

fullscreenchanges

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

occurs when an element is displayed in fullscreen mode

fullscreenchangesCaptured

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

occurs when an element is displayed in fullscreen mode

fullscreenchangesCapturedIf

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

occurs when an element is displayed in fullscreen mode

fullscreenchangesIf

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

occurs when an element is displayed in fullscreen mode

fullscreenerrors

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

occurs when an element can not be displayed in fullscreen mode

fullscreenerrorsCaptured

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

occurs when an element can not be displayed in fullscreen mode

fullscreenerrorsCapturedIf

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

occurs when an element can not be displayed in fullscreen mode

fullscreenerrorsIf

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

occurs when an element can not be displayed in fullscreen mode

hashchanges

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

occurs when there has been changes to the anchor part of a URL

hashchangesCaptured

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

occurs when there has been changes to the anchor part of a URL

hashchangesCapturedIf

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

occurs when there has been changes to the anchor part of a URL

hashchangesIf

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

occurs when there has been changes to the anchor part of a URL

inputs

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

occurs when an element gets user input has to use Event as type because Chrome and Safari offer Events instead of InputEvents when selecting from a datalist

inputsCaptured

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

occurs when an element gets user input has to use Event as type because Chrome and Safari offer Events instead of InputEvents when selecting from a datalist

inputsCapturedIf

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

occurs when an element gets user input has to use Event as type because Chrome and Safari offer Events instead of InputEvents when selecting from a datalist

inputsIf

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

occurs when an element gets user input has to use Event as type because Chrome and Safari offer Events instead of InputEvents when selecting from a datalist

invalids

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

occurs when an element is invalid

invalidsCaptured

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

occurs when an element is invalid

invalidsCapturedIf

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

occurs when an element is invalid

invalidsIf

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

occurs when an element is invalid

keydowns

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

occurs when the user is pressing a key

keydownsCaptured

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

occurs when the user is pressing a key

keydownsCapturedIf

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

occurs when the user is pressing a key

keydownsIf

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

occurs when the user is pressing a key

keypresss

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

occurs when the user presses a key

keypresssCaptured

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

occurs when the user presses a key

keypresssCapturedIf

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

occurs when the user presses a key

keypresssIf

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

occurs when the user presses a key

keyups

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

occurs when the user releases a key

keyupsCaptured

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

occurs when the user releases a key

keyupsCapturedIf

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

occurs when the user releases a key

keyupsIf

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

occurs when the user releases a key

loadeddatas

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

occurs when media data is loaded

loadeddatasCaptured

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

occurs when media data is loaded

loadeddatasCapturedIf

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

occurs when media data is loaded

loadeddatasIf

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

occurs when media data is loaded

loadedmetadatas

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

occurs when metadata (like dimensions and duration) are loaded

loadedmetadatasCaptured

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

occurs when metadata (like dimensions and duration) are loaded

loadedmetadatasCapturedIf

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

occurs when metadata (like dimensions and duration) are loaded

loadedmetadatasIf

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

occurs when metadata (like dimensions and duration) are loaded

loads

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

occurs when an object has loaded

loadsCaptured

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

occurs when an object has loaded

loadsCapturedIf

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

occurs when an object has loaded

loadsIf

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

occurs when an object has loaded

loadstarts

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

occurs when the browser starts looking for the specified media

loadstartsCaptured

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

occurs when the browser starts looking for the specified media

loadstartsCapturedIf

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

occurs when the browser starts looking for the specified media

loadstartsIf

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

occurs when the browser starts looking for the specified media

messages

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

occurs when a message is received through the event source

messagesCaptured

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

occurs when a message is received through the event source

messagesCapturedIf

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

occurs when a message is received through the event source

messagesIf

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

occurs when a message is received through the event source

mousedowns

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

occurs when the user presses a mouse button over an element

mousedownsCaptured

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

occurs when the user presses a mouse button over an element

mousedownsCapturedIf

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

occurs when the user presses a mouse button over an element

mousedownsIf

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

occurs when the user presses a mouse button over an element

mouseenters

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

occurs when the pointer is moved onto an element

mouseentersCaptured

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

occurs when the pointer is moved onto an element

mouseentersCapturedIf

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

occurs when the pointer is moved onto an element

mouseentersIf

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

occurs when the pointer is moved onto an element

mouseleaves

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

occurs when the pointer is moved out of an element

mouseleavesCaptured

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

occurs when the pointer is moved out of an element

mouseleavesCapturedIf

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

occurs when the pointer is moved out of an element

mouseleavesIf

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

occurs when the pointer is moved out of an element

mousemoves

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

occurs when the pointer is moving while it is over an element

mousemovesCaptured

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

occurs when the pointer is moving while it is over an element

mousemovesCapturedIf

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

occurs when the pointer is moving while it is over an element

mousemovesIf

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

occurs when the pointer is moving while it is over an element

mouseouts

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

occurs when a user moves the mouse pointer out of an element, or out of one of its children

mouseoutsCaptured

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

occurs when a user moves the mouse pointer out of an element, or out of one of its children

mouseoutsCapturedIf

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

occurs when a user moves the mouse pointer out of an element, or out of one of its children

mouseoutsIf

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

occurs when a user moves the mouse pointer out of an element, or out of one of its children

mouseovers

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

occurs when the pointer is moved onto an element, or onto one of its children

mouseoversCaptured

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

occurs when the pointer is moved onto an element, or onto one of its children

mouseoversCapturedIf

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

occurs when the pointer is moved onto an element, or onto one of its children

mouseoversIf

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

occurs when the pointer is moved onto an element, or onto one of its children

mouseups

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

occurs when a user releases a mouse button over an element

mouseupsCaptured

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

occurs when a user releases a mouse button over an element

mouseupsCapturedIf

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

occurs when a user releases a mouse button over an element

mouseupsIf

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

occurs when a user releases a mouse button over an element

offlines

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

occurs when the browser starts to work offline

offlinesCaptured

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

occurs when the browser starts to work offline

offlinesCapturedIf

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

occurs when the browser starts to work offline

offlinesIf

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

occurs when the browser starts to work offline

onlines

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

occurs when the browser starts to work online

onlinesCaptured

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

occurs when the browser starts to work online

onlinesCapturedIf

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

occurs when the browser starts to work online

onlinesIf

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

occurs when the browser starts to work online

opens

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

occurs when a connection with the event source is opened

opensCaptured

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

occurs when a connection with the event source is opened

opensCapturedIf

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

occurs when a connection with the event source is opened

opensIf

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

occurs when a connection with the event source is opened

pagehides

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

occurs when the user navigates away from a webpage

pagehidesCaptured

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

occurs when the user navigates away from a webpage

pagehidesCapturedIf

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

occurs when the user navigates away from a webpage

pagehidesIf

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

occurs when the user navigates away from a webpage

pageshows

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

occurs when the user navigates to a webpage

pageshowsCaptured

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

occurs when the user navigates to a webpage

pageshowsCapturedIf

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

occurs when the user navigates to a webpage

pageshowsIf

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

occurs when the user navigates to a webpage

pastes

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

occurs when the user pastes some content in an element

pastesCaptured

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

occurs when the user pastes some content in an element

pastesCapturedIf

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

occurs when the user pastes some content in an element

pastesIf

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

occurs when the user pastes some content in an element

pauses

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

occurs when the media is paused either by the user or programmatically

pausesCaptured

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

occurs when the media is paused either by the user or programmatically

pausesCapturedIf

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

occurs when the media is paused either by the user or programmatically

pausesIf

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

occurs when the media is paused either by the user or programmatically

playings

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

occurs when the media is playing after having been paused or stopped for buffering

playingsCaptured

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

occurs when the media is playing after having been paused or stopped for buffering

playingsCapturedIf

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

occurs when the media is playing after having been paused or stopped for buffering

playingsIf

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

occurs when the media is playing after having been paused or stopped for buffering

plays

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

occurs when the media has been started or is no longer paused

playsCaptured

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

occurs when the media has been started or is no longer paused

playsCapturedIf

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

occurs when the media has been started or is no longer paused

playsIf

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

occurs when the media has been started or is no longer paused

popstates

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

occurs when the window's history changes

popstatesCaptured

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

occurs when the window's history changes

popstatesCapturedIf

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

occurs when the window's history changes

popstatesIf

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

occurs when the window's history changes

progresss

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

occurs when the browser is in the process of getting the media data (downloading the media)

progresssCaptured

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

occurs when the browser is in the process of getting the media data (downloading the media)

progresssCapturedIf

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

occurs when the browser is in the process of getting the media data (downloading the media)

progresssIf

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

occurs when the browser is in the process of getting the media data (downloading the media)

ratechanges

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

occurs when the playing speed of the media is changed

ratechangesCaptured

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

occurs when the playing speed of the media is changed

ratechangesCapturedIf

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

occurs when the playing speed of the media is changed

ratechangesIf

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

occurs when the playing speed of the media is changed

resets

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

occurs when a form is reset

resetsCaptured

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

occurs when a form is reset

resetsCapturedIf

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

occurs when a form is reset

resetsIf

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

occurs when a form is reset

resizes

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

occurs when the document view is resized

resizesCaptured

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

occurs when the document view is resized

resizesCapturedIf

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

occurs when the document view is resized

resizesIf

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

occurs when the document view is resized

scrolls

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

occurs when an element's scrollbar is being scrolled

scrollsCaptured

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

occurs when an element's scrollbar is being scrolled

scrollsCapturedIf

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

occurs when an element's scrollbar is being scrolled

scrollsIf

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

occurs when an element's scrollbar is being scrolled

searchs

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

occurs when the user writes something in a search field (for )

searchsCaptured

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

occurs when the user writes something in a search field (for )

searchsCapturedIf

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

occurs when the user writes something in a search field (for )

searchsIf

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

occurs when the user writes something in a search field (for )

seekeds

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

occurs when the user is finished moving/skipping to a new position in the media

seekedsCaptured

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

occurs when the user is finished moving/skipping to a new position in the media

seekedsCapturedIf

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

occurs when the user is finished moving/skipping to a new position in the media

seekedsIf

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

occurs when the user is finished moving/skipping to a new position in the media

seekings

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

occurs when the user starts moving/skipping to a new position in the media

seekingsCaptured

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

occurs when the user starts moving/skipping to a new position in the media

seekingsCapturedIf

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

occurs when the user starts moving/skipping to a new position in the media

seekingsIf

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

occurs when the user starts moving/skipping to a new position in the media

selects

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

occurs after the user selects some text (for and )</p></div></div> </div> </div> </div> </div> </div>

selectsCaptured

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

occurs after the user selects some text (for and )</p></div></div> </div> </div> </div> </div> </div>

selectsCapturedIf

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

occurs after the user selects some text (for and )</p></div></div> </div> </div> </div> </div> </div>

selectsIf

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

occurs after the user selects some text (for and )</p></div></div> </div> </div> </div> </div> </div>

shows

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

occurs when a

element is shown as a context menu

showsCaptured

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

occurs when a

element is shown as a context menu

showsCapturedIf

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

occurs when a

element is shown as a context menu

showsIf

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

occurs when a

element is shown as a context menu

stalleds

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

occurs when the browser is trying to get media data, but data is not available

stalledsCaptured

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

occurs when the browser is trying to get media data, but data is not available

stalledsCapturedIf

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

occurs when the browser is trying to get media data, but data is not available

stalledsIf

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

occurs when the browser is trying to get media data, but data is not available

storages

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

occurs when a Web Storage area is updated

storagesCaptured

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

occurs when a Web Storage area is updated

storagesCapturedIf

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

occurs when a Web Storage area is updated

storagesIf

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

occurs when a Web Storage area is updated

submits

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

occurs when a form is submitted

submitsCaptured

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

occurs when a form is submitted

submitsCapturedIf

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

occurs when a form is submitted

submitsIf

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

occurs when a form is submitted

abstract fun <X : Event> subscribe(eventName: String, capture: Boolean = false, selector: X.() -> Boolean = { true }): Listener<X, T>

Creates an Listener for the given event eventName.

suspends

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

occurs when the browser is intentionally not getting media data

suspendsCaptured

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

occurs when the browser is intentionally not getting media data

suspendsCapturedIf

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

occurs when the browser is intentionally not getting media data

suspendsIf

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

occurs when the browser is intentionally not getting media data

timeupdates

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

occurs when the playing position has changed (like when the user fast forwards to a different point in the media)

timeupdatesCaptured

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

occurs when the playing position has changed (like when the user fast forwards to a different point in the media)

timeupdatesCapturedIf

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

occurs when the playing position has changed (like when the user fast forwards to a different point in the media)

timeupdatesIf

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

occurs when the playing position has changed (like when the user fast forwards to a different point in the media)

toggles

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

occurs when the user opens or closes the

element

togglesCaptured

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

occurs when the user opens or closes the

element

togglesCapturedIf

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

occurs when the user opens or closes the

element

togglesIf

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

occurs when the user opens or closes the

element

touchcancels

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

occurs when the touch is interrupted

touchcancelsCaptured

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

occurs when the touch is interrupted

touchcancelsCapturedIf

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

occurs when the touch is interrupted

touchcancelsIf

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

occurs when the touch is interrupted

touchends

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

occurs when a finger is removed from a touch screen

touchendsCaptured

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

occurs when a finger is removed from a touch screen

touchendsCapturedIf

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

occurs when a finger is removed from a touch screen

touchendsIf

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

occurs when a finger is removed from a touch screen

touchmoves

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

occurs when a finger is dragged across the screen

touchmovesCaptured

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

occurs when a finger is dragged across the screen

touchmovesCapturedIf

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

occurs when a finger is dragged across the screen

touchmovesIf

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

occurs when a finger is dragged across the screen

touchstarts

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

occurs when a finger is placed on a touch screen

touchstartsCaptured

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

occurs when a finger is placed on a touch screen

touchstartsCapturedIf

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

occurs when a finger is placed on a touch screen

touchstartsIf

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

occurs when a finger is placed on a touch screen

transitionends

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

occurs when a CSS transition has completed

transitionendsCaptured

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

occurs when a CSS transition has completed

transitionendsCapturedIf

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

occurs when a CSS transition has completed

transitionendsIf

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

occurs when a CSS transition has completed

unloads

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

occurs once a page has unloaded (for )

unloadsCaptured

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

occurs once a page has unloaded (for )

unloadsCapturedIf

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

occurs once a page has unloaded (for )

unloadsIf

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

occurs once a page has unloaded (for )

volumechanges

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

occurs when the volume of the media has changed (includes setting the volume to "mute")

volumechangesCaptured

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

occurs when the volume of the media has changed (includes setting the volume to "mute")

volumechangesCapturedIf

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

occurs when the volume of the media has changed (includes setting the volume to "mute")

volumechangesIf

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

occurs when the volume of the media has changed (includes setting the volume to "mute")

waitings

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

occurs when the media has paused but is expected to resume (like when the media pauses to buffer more data)

waitingsCaptured

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

occurs when the media has paused but is expected to resume (like when the media pauses to buffer more data)

waitingsCapturedIf

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

occurs when the media has paused but is expected to resume (like when the media pauses to buffer more data)

waitingsIf

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

occurs when the media has paused but is expected to resume (like when the media pauses to buffer more data)

wheels

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

occurs when the mouse wheel rolls up or down over an element

wheelsCaptured

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

occurs when the mouse wheel rolls up or down over an element

wheelsCapturedIf

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

occurs when the mouse wheel rolls up or down over an element

wheelsIf

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

occurs when the mouse wheel rolls up or down over an element