DocumentEventProps

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def getClass(): Class[_]

lazy val gotPointerCapture: EP[TypedTargetPointerEvent[Element]]

fired when an element receives pointer capture.

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

lazy val lostPointerCapture: EP[TypedTargetPointerEvent[Element]]

Fired after pointer capture is released for a pointer.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

lazy val onAbort: EP[Event]

Script to be run on abort

lazy val onAnimationEnd: EP[AnimationEvent]

The animationend event is event fires when a CSS animation reaches the end of its active period.

lazy val onAnimationIteration: EP[AnimationEvent]

The animationiteration event is sent when a CSS animation reaches the end of an iteration.

lazy val onAnimationStart: EP[AnimationEvent]

The animationstart event is sent when a CSS Animation starts to play.

lazy val onBlur: EP[TypedTargetFocusEvent[Element]]

The blur event is raised when an element loses focus.

lazy val onCanPlay: EP[Event]

Script to be run when a file is ready to start playing (when it has buffered enough to begin)

lazy val onCanPlayThrough: EP[Event]

Script to be run when a file can be played all the way to the end without pausing for buffering

lazy val onChange: EP[TypedTargetEvent[Element]]

The change event is fired for input, select, and textarea elements when a change to the element's value is committed by the user.

lazy val onClick: EP[TypedTargetMouseEvent[Element]]

The click event is raised when the user clicks on an element.

lazy val onContextMenu: EP[MouseEvent]

Script to be run when a context menu is triggered

lazy val onCopy: EP[ClipboardEvent]

Fires when the user copies the content of an element

lazy val onCueChange: EP[Event]

Script to be run when the cue changes in a <track> element

lazy val onCut: EP[ClipboardEvent]

Fires when the user cuts the content of an element

lazy val onDblClick: EP[TypedTargetMouseEvent[Element]]

The dblclick event is fired when a pointing device button (usually a mouse button) is clicked twice on a single element.

lazy val onDomContentLoaded: EP[Event]

The DOMContentLoaded event is fired when the initial HTML document has been completely loaded and parsed, without waiting for stylesheets, images, and subframes to finish loading.

lazy val onDrag: EP[DragEvent]

Script to be run when an element is dragged

lazy val onDragEnd: EP[DragEvent]

Script to be run at the end of a drag operation

lazy val onDragEnter: EP[DragEvent]

Script to be run when an element has been dragged to a valid drop target

lazy val onDragLeave: EP[DragEvent]

Script to be run when an element leaves a valid drop target

lazy val onDragOver: EP[DragEvent]

Script to be run when an element is being dragged over a valid drop target

lazy val onDragStart: EP[DragEvent]

Script to be run at the start of a drag operation

lazy val onDrop: EP[DragEvent]

Script to be run when dragged element is being dropped

lazy val onDurationChange: EP[Event]

Script to be run when the length of the media changes

lazy val onEmptied: EP[Event]

Script to be run when something bad happens and the file is suddenly unavailable (like unexpectedly disconnects)

lazy val onEnded: EP[Event]

Script to be run when the media has reach the end (a useful event for messages like "thanks for listening")

lazy val onError: EP[ErrorEvent]

Script to be run when an error occurs when the file is being loaded

lazy val onFocus: EP[TypedTargetFocusEvent[Element]]

The focus event is raised when the user sets focus on the given element.

lazy val onFullScreenChange: EP[Event]

The fullscreenchange event is fired immediately after the browser switches into or out of full-screen mode.

lazy val onFullScreenError: EP[Event]

The fullscreenerror event is fired when the browser cannot switch to full-screen mode.

lazy val onInput: EP[TypedTargetEvent[Element]]

The input event is fired for input, select, textarea, and contentEditable elements when it gets user input.

lazy val onInvalid: EP[TypedTargetEvent[Element]]

Script to be run when an element is invalid

lazy val onKeyDown: EP[KeyboardEvent]

The keydown event is raised when the user presses a keyboard key.

lazy val onKeyPress: EP[KeyboardEvent]

The keypress event should be raised when the user presses a key on the keyboard.

lazy val onKeyUp: EP[KeyboardEvent]

The keyup event is raised when the user releases a key that's been pressed.

lazy val onLoad: EP[UIEvent]

The onload property of the GlobalEventHandlers mixin is an event handler for the load event of a Window, XMLHttpRequest, element, etc., which fires when the resource has loaded.

lazy val onLoadStart: EP[Event]

Script to be run just as the file begins to load before anything is actually loaded

lazy val onLoadedData: EP[Event]

Script to be run when media data is loaded

lazy val onLoadedMetadata: EP[Event]

Script to be run when meta data (like dimensions and duration) are loaded

lazy val onMouseDown: EP[TypedTargetMouseEvent[Element]]

The mousedown event is raised when the user presses the mouse button.

lazy val onMouseEnter: EP[TypedTargetMouseEvent[Element]]

The mouseenter event is fired when a pointing device (usually a mouse) is moved over the element that has the listener attached.

lazy val onMouseLeave: EP[TypedTargetMouseEvent[Element]]

The mouseleave event is fired when the pointer of a pointing device (usually a mouse) is moved out of an element.

lazy val onMouseMove: EP[TypedTargetMouseEvent[Element]]

The mousemove event is raised when the user moves the mouse.

lazy val onMouseOut: EP[TypedTargetMouseEvent[Element]]

The mouseout event is raised when the mouse leaves an element (e.g, when the mouse moves off of an image in the web page, the mouseout event is raised for that image element).

lazy val onMouseOver: EP[TypedTargetMouseEvent[Element]]

The mouseover event is raised when the user moves the mouse over a particular element.

lazy val onMouseUp: EP[TypedTargetMouseEvent[Element]]

The mouseup event is raised when the user releases the mouse button.

lazy val onPaste: EP[ClipboardEvent]

Fires when the user pastes some content in an element

lazy val onPause: EP[Event]

Script to be run when the media is paused either by the user or programmatically

lazy val onPlay: EP[Event]

Script to be run when the media is ready to start playing

lazy val onPlaying: EP[Event]

Script to be run when the media actually has started playing

lazy val onPointerCancel: EP[TypedTargetPointerEvent[Element]]

a browser fires this event if it concludes the pointer will no longer be able to generate events (for example the related device is deactived).

lazy val onPointerDown: EP[TypedTargetPointerEvent[Element]]

fired when a pointer becomes active.

lazy val onPointerEnter: EP[TypedTargetPointerEvent[Element]]

fired when a pointing device is moved into the hit test boundaries of an element or one of its descendants, including as a result of a pointerdown event from a device that does not support hover (see pointerdown).

lazy val onPointerLeave: EP[TypedTargetPointerEvent[Element]]

fired when a pointing device is moved out of the hit test boundaries of an element.

lazy val onPointerMove: EP[TypedTargetPointerEvent[Element]]

fired when a pointer changes coordinates.

lazy val onPointerOut: EP[TypedTargetPointerEvent[Element]]

fired for several reasons including: pointing device is moved out of the hit test boundaries of an element; firing the pointerup event for a device that does not support hover (see pointerup); after firing the pointercancel event (see pointercancel); when a pen stylus leaves the hover range detectable by the digitizer.

lazy val onPointerOver: EP[TypedTargetPointerEvent[Element]]

fired when a pointing device is moved into an element's hit test boundaries.

lazy val onPointerUp: EP[TypedTargetPointerEvent[Element]]

fired when a pointer is no longer active.

lazy val onProgress: EP[Event]

Script to be run when the browser is in the process of getting the media data

lazy val onRateChange: EP[Event]

Script to be run each time the playback rate changes (like when a user switches to a slow motion or fast forward mode)

lazy val onReset: EP[TypedTargetEvent[Form]]

The reset event is fired when a form is reset.

lazy val onResize: EP[UIEvent]

The GlobalEventHandlers.onresize property contains an EventHandler triggered when a resize event is received.

lazy val onScroll: EP[UIEvent]

An event handler for scroll events on element.

lazy val onSearch: EP[TypedTargetEvent[Input]]

Fires when the user writes something in a search field (for <input="search">)

lazy val onSeeked: EP[Event]

Script to be run when the seeking attribute is set to false indicating that seeking has ended

lazy val onSeeking: EP[Event]

Script to be run when the seeking attribute is set to true indicating that seeking is active

lazy val onSelect: EP[TypedTargetEvent[Element]]

The select event only fires when text inside a text input or textarea is selected.

lazy val onShow: EP[Event]

Fires when a <menu> element is shown as a context menu

lazy val onStalled: EP[Event]

Script to be run when the browser is unable to fetch the media data for whatever reason

lazy val onSubmit: EP[TypedTargetEvent[Form]]

The submit event is fired when the user clicks a submit button in a form (). MDN

lazy val onSuspend: EP[Event]

Script to be run when fetching the media data is stopped before it is completely loaded for whatever reason

lazy val onTimeUpdate: EP[Event]

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

lazy val onToggle: EP[Event]

Fires when the user opens or closes the <details> element

lazy val onTransitionEnd: EP[Event]

The transitionend event is sent to when a CSS transition completes.

lazy val onVisibilityChange: EP[Event]

The visibilitychange event is fired when the content of a tab has become visible or has been hidden.

lazy val onVolumeChange: EP[Event]

Script to be run each time the volume is changed which (includes setting the volume to "mute")

lazy val onWaiting: EP[Event]

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

lazy val onWheel: EP[MouseEvent]

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

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit