Documentation

Overview

    Package event defines markup to bind DOM events.

    Generated from "Event reference" by Mozilla Contributors, https://developer.mozilla.org/en-US/docs/Web/Events, licensed under CC-BY-SA 2.5.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func Abort

    func Abort(listener func(*vecty.Event)) *vecty.EventListener

      Abort is an event fired when a transaction has been aborted.

      https://developer.mozilla.org/docs/Web/Reference/Events/abort_indexedDB

      func AfterPrint

      func AfterPrint(listener func(*vecty.Event)) *vecty.EventListener

        AfterPrint is an event fired when the associated document has started printing or the print preview has been closed.

        https://developer.mozilla.org/docs/Web/Events/afterprint

        func AnimationEnd

        func AnimationEnd(listener func(*vecty.Event)) *vecty.EventListener

          AnimationEnd is an event fired when a CSS animation has completed.

          https://developer.mozilla.org/docs/Web/Events/animationend

          func AnimationIteration

          func AnimationIteration(listener func(*vecty.Event)) *vecty.EventListener

            AnimationIteration is an event fired when a CSS animation is repeated.

            https://developer.mozilla.org/docs/Web/Events/animationiteration

            func AnimationStart

            func AnimationStart(listener func(*vecty.Event)) *vecty.EventListener

              AnimationStart is an event fired when a CSS animation has started.

              https://developer.mozilla.org/docs/Web/Events/animationstart

              func ApplicationInstalled

              func ApplicationInstalled(listener func(*vecty.Event)) *vecty.EventListener

                ApplicationInstalled is an event fired when a web application is successfully installed as a progressive web app.

                https://developer.mozilla.org/docs/Web/Events/appinstalled

                func AudioEnd

                func AudioEnd(listener func(*vecty.Event)) *vecty.EventListener

                  AudioEnd is an event fired when the user agent has finished capturing audio for speech recognition.

                  https://developer.mozilla.org/docs/Web/Events/audioend

                  func AudioStart

                  func AudioStart(listener func(*vecty.Event)) *vecty.EventListener

                    AudioStart is an event fired when the user agent has started to capture audio for speech recognition.

                    https://developer.mozilla.org/docs/Web/Events/audiostart

                    func BeforePrint

                    func BeforePrint(listener func(*vecty.Event)) *vecty.EventListener

                      BeforePrint is an event fired when the associated document is about to be printed or previewed for printing.

                      https://developer.mozilla.org/docs/Web/Events/beforeprint

                      func BeforeUnload

                      func BeforeUnload(listener func(*vecty.Event)) *vecty.EventListener

                        BeforeUnload is an event fired when the window, the document and its resources are about to be unloaded.

                        https://developer.mozilla.org/docs/Web/Events/beforeunload

                        func BeginEvent

                        func BeginEvent(listener func(*vecty.Event)) *vecty.EventListener

                          BeginEvent is an event fired when a SMIL animation element begins.

                          https://developer.mozilla.org/docs/Web/Events/beginEvent

                          func Blocked

                          func Blocked(listener func(*vecty.Event)) *vecty.EventListener

                            Blocked is an event fired when an open connection to a database is blocking a versionchange transaction on the same database.

                            https://developer.mozilla.org/docs/Web/Reference/Events/blocked_indexedDB

                            func Blur

                            func Blur(listener func(*vecty.Event)) *vecty.EventListener

                              Blur is an event fired when an element has lost focus (does not bubble).

                              https://developer.mozilla.org/docs/Web/Events/blur

                              func Boundary

                              func Boundary(listener func(*vecty.Event)) *vecty.EventListener

                                Boundary is an event fired when the spoken utterance reaches a word or sentence boundary

                                https://developer.mozilla.org/docs/Web/Events/boundary

                                func Cached

                                func Cached(listener func(*vecty.Event)) *vecty.EventListener

                                  Cached is an event fired when the resources listed in the manifest have been downloaded, and the application is now cached.

                                  https://developer.mozilla.org/docs/Web/Events/cached

                                  func CanPlay

                                  func CanPlay(listener func(*vecty.Event)) *vecty.EventListener

                                    CanPlay is an event fired when the user agent can play the media, but estimates that not enough data has been loaded to play the media up to its end without having to stop for further buffering of content.

                                    https://developer.mozilla.org/docs/Web/Events/canplay

                                    func CanPlayThrough

                                    func CanPlayThrough(listener func(*vecty.Event)) *vecty.EventListener

                                      CanPlayThrough is an event fired when the user agent can play the media up to its end without having to stop for further buffering of content.

                                      https://developer.mozilla.org/docs/Web/Events/canplaythrough

                                      func Change

                                      func Change(listener func(*vecty.Event)) *vecty.EventListener

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

                                        https://developer.mozilla.org/docs/Web/Events/change

                                        func ChargingChange

                                        func ChargingChange(listener func(*vecty.Event)) *vecty.EventListener

                                          ChargingChange is an event fired when the battery begins or stops charging.

                                          https://developer.mozilla.org/docs/Web/Events/chargingchange

                                          func ChargingTimeChange

                                          func ChargingTimeChange(listener func(*vecty.Event)) *vecty.EventListener

                                            ChargingTimeChange is an event fired when the chargingTime attribute has been updated.

                                            https://developer.mozilla.org/docs/Web/Events/chargingtimechange

                                            func Checking

                                            func Checking(listener func(*vecty.Event)) *vecty.EventListener

                                              Checking is an event fired when the user agent is checking for an update, or attempting to download the cache manifest for the first time.

                                              https://developer.mozilla.org/docs/Web/Events/checking

                                              func Click

                                              func Click(listener func(*vecty.Event)) *vecty.EventListener

                                                Click is an event fired when a pointing device button has been pressed and released on an element.

                                                https://developer.mozilla.org/docs/Web/Events/click

                                                func Close

                                                func Close(listener func(*vecty.Event)) *vecty.EventListener

                                                  Close is an event fired when a WebSocket connection has been closed.

                                                  https://developer.mozilla.org/docs/Web/Reference/Events/close_websocket

                                                  func Complete

                                                  func Complete(listener func(*vecty.Event)) *vecty.EventListener

                                                    Complete is an event fired when a transaction successfully completed.

                                                    https://developer.mozilla.org/docs/Web/Reference/Events/complete_indexedDB

                                                    func CompositionEnd

                                                    func CompositionEnd(listener func(*vecty.Event)) *vecty.EventListener

                                                      CompositionEnd is an event fired when the composition of a passage of text has been completed or canceled.

                                                      https://developer.mozilla.org/docs/Web/Events/compositionend

                                                      func CompositionStart

                                                      func CompositionStart(listener func(*vecty.Event)) *vecty.EventListener

                                                        CompositionStart is an event fired when the composition of a passage of text is prepared (similar to keydown for a keyboard input, but works with other inputs such as speech recognition).

                                                        https://developer.mozilla.org/docs/Web/Events/compositionstart

                                                        func CompositionUpdate

                                                        func CompositionUpdate(listener func(*vecty.Event)) *vecty.EventListener

                                                          CompositionUpdate is an event fired when a character is added to a passage of text being composed.

                                                          https://developer.mozilla.org/docs/Web/Events/compositionupdate

                                                          func ContextMenu

                                                          func ContextMenu(listener func(*vecty.Event)) *vecty.EventListener

                                                            ContextMenu is an event fired when the right button of the mouse is clicked (before the context menu is displayed).

                                                            https://developer.mozilla.org/docs/Web/Events/contextmenu

                                                            func Copy

                                                            func Copy(listener func(*vecty.Event)) *vecty.EventListener

                                                              Copy is an event fired when the text selection has been added to the clipboard.

                                                              https://developer.mozilla.org/docs/Web/Events/copy

                                                              func Cut

                                                              func Cut(listener func(*vecty.Event)) *vecty.EventListener

                                                                Cut is an event fired when the text selection has been removed from the document and added to the clipboard.

                                                                https://developer.mozilla.org/docs/Web/Events/cut

                                                                func DOMContentLoaded

                                                                func DOMContentLoaded(listener func(*vecty.Event)) *vecty.EventListener

                                                                  DOMContentLoaded is an event fired when the document has finished loading (but not its dependent resources).

                                                                  https://developer.mozilla.org/docs/Web/Events/DOMContentLoaded

                                                                  func DeviceChange

                                                                  func DeviceChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                    DeviceChange is an event fired when a media device such as a camera, microphone, or speaker is connected or removed from the system.

                                                                    https://developer.mozilla.org/docs/Web/Events/devicechange

                                                                    func DeviceLight

                                                                    func DeviceLight(listener func(*vecty.Event)) *vecty.EventListener

                                                                      DeviceLight is an event fired when fresh data is available from a light sensor.

                                                                      https://developer.mozilla.org/docs/Web/Events/devicelight

                                                                      func DeviceMotion

                                                                      func DeviceMotion(listener func(*vecty.Event)) *vecty.EventListener

                                                                        DeviceMotion is an event fired when fresh data is available from a motion sensor.

                                                                        https://developer.mozilla.org/docs/Web/Events/devicemotion

                                                                        func DeviceOrientation

                                                                        func DeviceOrientation(listener func(*vecty.Event)) *vecty.EventListener

                                                                          DeviceOrientation is an event fired when fresh data is available from an orientation sensor.

                                                                          https://developer.mozilla.org/docs/Web/Events/deviceorientation

                                                                          func DeviceProximity

                                                                          func DeviceProximity(listener func(*vecty.Event)) *vecty.EventListener

                                                                            DeviceProximity is an event fired when fresh data is available from a proximity sensor (indicates an approximated distance between the device and a nearby object).

                                                                            https://developer.mozilla.org/docs/Web/Events/deviceproximity

                                                                            func DischargingTimeChange

                                                                            func DischargingTimeChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                              DischargingTimeChange is an event fired when the dischargingTime attribute has been updated.

                                                                              https://developer.mozilla.org/docs/Web/Events/dischargingtimechange

                                                                              func DoubleClick

                                                                              func DoubleClick(listener func(*vecty.Event)) *vecty.EventListener

                                                                                DoubleClick is an event fired when a pointing device button is clicked twice on an element.

                                                                                https://developer.mozilla.org/docs/Web/Events/dblclick

                                                                                func Downloading

                                                                                func Downloading(listener func(*vecty.Event)) *vecty.EventListener

                                                                                  Downloading is an event fired when the user agent has found an update and is fetching it, or is downloading the resources listed by the cache manifest for the first time.

                                                                                  https://developer.mozilla.org/docs/Web/Events/downloading

                                                                                  func Drag

                                                                                  func Drag(listener func(*vecty.Event)) *vecty.EventListener

                                                                                    Drag is an event fired when an element or text selection is being dragged (every 350ms).

                                                                                    https://developer.mozilla.org/docs/Web/Events/drag

                                                                                    func DragEnd

                                                                                    func DragEnd(listener func(*vecty.Event)) *vecty.EventListener

                                                                                      DragEnd is an event fired when a drag operation is being ended (by releasing a mouse button or hitting the escape key).

                                                                                      https://developer.mozilla.org/docs/Web/Events/dragend

                                                                                      func DragEnter

                                                                                      func DragEnter(listener func(*vecty.Event)) *vecty.EventListener

                                                                                        DragEnter is an event fired when a dragged element or text selection enters a valid drop target.

                                                                                        https://developer.mozilla.org/docs/Web/Events/dragenter

                                                                                        func DragLeave

                                                                                        func DragLeave(listener func(*vecty.Event)) *vecty.EventListener

                                                                                          DragLeave is an event fired when a dragged element or text selection leaves a valid drop target.

                                                                                          https://developer.mozilla.org/docs/Web/Events/dragleave

                                                                                          func DragOver

                                                                                          func DragOver(listener func(*vecty.Event)) *vecty.EventListener

                                                                                            DragOver is an event fired when an element or text selection is being dragged over a valid drop target (every 350ms).

                                                                                            https://developer.mozilla.org/docs/Web/Events/dragover

                                                                                            func DragStart

                                                                                            func DragStart(listener func(*vecty.Event)) *vecty.EventListener

                                                                                              DragStart is an event fired when the user starts dragging an element or text selection.

                                                                                              https://developer.mozilla.org/docs/Web/Events/dragstart

                                                                                              func Drop

                                                                                              func Drop(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                Drop is an event fired when an element is dropped on a valid drop target.

                                                                                                https://developer.mozilla.org/docs/Web/Events/drop

                                                                                                func DurationChange

                                                                                                func DurationChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                  DurationChange is an event fired when the duration attribute has been updated.

                                                                                                  https://developer.mozilla.org/docs/Web/Events/durationchange

                                                                                                  func Emptied

                                                                                                  func Emptied(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                    Emptied is an event fired when the media has become empty; for example, this event is sent if the media has already been loaded (or partially loaded), and the load() method is called to reload it.

                                                                                                    https://developer.mozilla.org/docs/Web/Events/emptied

                                                                                                    func End

                                                                                                    func End(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                      End is an event fired when the utterance has finished being spoken.

                                                                                                      https://developer.mozilla.org/docs/Web/Events/end_(SpeechSynthesis)

                                                                                                      func EndEvent

                                                                                                      func EndEvent(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                        EndEvent is an event fired when a SMIL animation element ends.

                                                                                                        https://developer.mozilla.org/docs/Web/Events/endEvent

                                                                                                        func Ended

                                                                                                        func Ended(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                          Ended is an event fired when playback has stopped because the end of the media was reached.

                                                                                                          https://developer.mozilla.org/docs/Web/Events/ended_(Web_Audio)

                                                                                                          func Error

                                                                                                          func Error(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                            Error is an event fired when an error occurs that prevents the utterance from being successfully spoken.

                                                                                                            https://developer.mozilla.org/docs/Web/Events/error_(SpeechSynthesisError)

                                                                                                            func Focus

                                                                                                            func Focus(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                              Focus is an event fired when an element has received focus (does not bubble).

                                                                                                              https://developer.mozilla.org/docs/Web/Events/focus

                                                                                                              func FocusIn

                                                                                                              func FocusIn(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                FocusIn is an event fired when an element is about to receive focus (bubbles).

                                                                                                                https://developer.mozilla.org/docs/Web/Events/focusin

                                                                                                                func FocusOut

                                                                                                                func FocusOut(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                  FocusOut is an event fired when an element is about to lose focus (bubbles).

                                                                                                                  https://developer.mozilla.org/docs/Web/Events/focusout

                                                                                                                  func FullScreenChange

                                                                                                                  func FullScreenChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                    FullScreenChange is an event fired when an element was turned to fullscreen mode or back to normal mode.

                                                                                                                    https://developer.mozilla.org/docs/Web/Events/fullscreenchange

                                                                                                                    func FullScreenError

                                                                                                                    func FullScreenError(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                      FullScreenError is an event fired when it was impossible to switch to fullscreen mode for technical reasons or because the permission was denied.

                                                                                                                      https://developer.mozilla.org/docs/Web/Events/fullscreenerror

                                                                                                                      func GamepadConnected

                                                                                                                      func GamepadConnected(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                        GamepadConnected is an event fired when a gamepad has been connected.

                                                                                                                        https://developer.mozilla.org/docs/Web/Events/gamepadconnected

                                                                                                                        func GamepadDisconnected

                                                                                                                        func GamepadDisconnected(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                          GamepadDisconnected is an event fired when a gamepad has been disconnected.

                                                                                                                          https://developer.mozilla.org/docs/Web/Events/gamepaddisconnected

                                                                                                                          func GotPointerCapture

                                                                                                                          func GotPointerCapture(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                            GotPointerCapture is an event fired when element receives pointer capture.

                                                                                                                            https://developer.mozilla.org/docs/Web/Events/gotpointercapture

                                                                                                                            func HashChange

                                                                                                                            func HashChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                              HashChange is an event fired when the fragment identifier of the URL has changed (the part of the URL after the #).

                                                                                                                              https://developer.mozilla.org/docs/Web/Events/hashchange

                                                                                                                              func Input

                                                                                                                              func Input(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                Input is an event fired when the value of an element changes or the content of an element with the attribute contenteditable is modified.

                                                                                                                                https://developer.mozilla.org/docs/Web/Events/input

                                                                                                                                func Invalid

                                                                                                                                func Invalid(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                  Invalid is an event fired when a submittable element has been checked and doesn't satisfy its constraints.

                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/invalid

                                                                                                                                  func KeyDown

                                                                                                                                  func KeyDown(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                    KeyDown is an event fired when a key is pressed down.

                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/keydown

                                                                                                                                    func KeyPress

                                                                                                                                    func KeyPress(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                      KeyPress is an event fired when a key is pressed down and that key normally produces a character value (use input instead).

                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/keypress

                                                                                                                                      func KeyUp

                                                                                                                                      func KeyUp(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                        KeyUp is an event fired when a key is released.

                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/keyup

                                                                                                                                        func LanguageChange

                                                                                                                                        func LanguageChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                          LanguageChange is an event fired when the user's preferred languages have changed.

                                                                                                                                          https://developer.mozilla.org/docs/Web/Events/languagechange

                                                                                                                                          func LevelChange

                                                                                                                                          func LevelChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                            LevelChange is an event fired when the level attribute has been updated.

                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/levelchange

                                                                                                                                            func Load

                                                                                                                                            func Load(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                              Load is an event fired when progression has been successful.

                                                                                                                                              https://developer.mozilla.org/docs/Web/Reference/Events/load_(ProgressEvent)

                                                                                                                                              func LoadEnd

                                                                                                                                              func LoadEnd(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                LoadEnd is an event fired when progress has stopped (after "error", "abort" or "load" have been dispatched).

                                                                                                                                                https://developer.mozilla.org/docs/Web/Events/loadend

                                                                                                                                                func LoadStart

                                                                                                                                                func LoadStart(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                  LoadStart is an event fired when progress has begun.

                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/loadstart

                                                                                                                                                  func LoadedData

                                                                                                                                                  func LoadedData(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                    LoadedData is an event fired when the first frame of the media has finished loading.

                                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/loadeddata

                                                                                                                                                    func LoadedMetadata

                                                                                                                                                    func LoadedMetadata(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                      LoadedMetadata is an event fired when the metadata has been loaded.

                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/loadedmetadata

                                                                                                                                                      func LostPointerCapture

                                                                                                                                                      func LostPointerCapture(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                        LostPointerCapture is an event fired when element lost pointer capture.

                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/lostpointercapture

                                                                                                                                                        func Mark

                                                                                                                                                        func Mark(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                          Mark is an event fired when the spoken utterance reaches a named SSML "mark" tag.

                                                                                                                                                          https://developer.mozilla.org/docs/Web/Events/mark

                                                                                                                                                          func Message

                                                                                                                                                          func Message(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                            Message is an event fired when a message is received from a service worker, or a message is received in a service worker from another context.

                                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/message_(ServiceWorker)

                                                                                                                                                            func MessageError

                                                                                                                                                            func MessageError(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                              MessageError is an event fired when a message error is raised when a message is received by an object.

                                                                                                                                                              https://developer.mozilla.org/docs/Web/Events/messageerror

                                                                                                                                                              func MouseDown

                                                                                                                                                              func MouseDown(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                MouseDown is an event fired when a pointing device button (usually a mouse) is pressed on an element.

                                                                                                                                                                https://developer.mozilla.org/docs/Web/Events/mousedown

                                                                                                                                                                func MouseEnter

                                                                                                                                                                func MouseEnter(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                  MouseEnter is an event fired when a pointing device is moved onto the element that has the listener attached.

                                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/mouseenter

                                                                                                                                                                  func MouseLeave

                                                                                                                                                                  func MouseLeave(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                    MouseLeave is an event fired when a pointing device is moved off the element that has the listener attached.

                                                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/mouseleave

                                                                                                                                                                    func MouseMove

                                                                                                                                                                    func MouseMove(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                      MouseMove is an event fired when a pointing device is moved over an element.

                                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/mousemove

                                                                                                                                                                      func MouseOut

                                                                                                                                                                      func MouseOut(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                        MouseOut is an event fired when a pointing device is moved off the element that has the listener attached or off one of its children.

                                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/mouseout

                                                                                                                                                                        func MouseOver

                                                                                                                                                                        func MouseOver(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                          MouseOver is an event fired when a pointing device is moved onto the element that has the listener attached or onto one of its children.

                                                                                                                                                                          https://developer.mozilla.org/docs/Web/Events/mouseover

                                                                                                                                                                          func MouseUp

                                                                                                                                                                          func MouseUp(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                            MouseUp is an event fired when a pointing device button is released over an element.

                                                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/mouseup

                                                                                                                                                                            func NoMatch

                                                                                                                                                                            func NoMatch(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                              NoMatch is an event fired when the speech recognition service returns a final result with no significant recognition.

                                                                                                                                                                              https://developer.mozilla.org/docs/Web/Events/nomatch

                                                                                                                                                                              func NoUpdate

                                                                                                                                                                              func NoUpdate(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                NoUpdate is an event fired when the manifest hadn't changed.

                                                                                                                                                                                https://developer.mozilla.org/docs/Web/Events/noupdate

                                                                                                                                                                                func NotificationClick

                                                                                                                                                                                func NotificationClick(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                  NotificationClick is an event fired when a system notification spawned by ServiceWorkerRegistration.showNotification() has been clicked.

                                                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/notificationclick

                                                                                                                                                                                  func Obsolete

                                                                                                                                                                                  func Obsolete(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                    Obsolete is an event fired when the manifest was found to have become a 404 or 410 page, so the application cache is being deleted.

                                                                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/obsolete

                                                                                                                                                                                    func Offline

                                                                                                                                                                                    func Offline(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                      Offline is an event fired when the browser has lost access to the network.

                                                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/offline

                                                                                                                                                                                      func Online

                                                                                                                                                                                      func Online(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                        Online is an event fired when the browser has gained access to the network (but particular websites might be unreachable).

                                                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/online

                                                                                                                                                                                        func Open

                                                                                                                                                                                        func Open(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                          Open is an event fired when an event source connection has been established.

                                                                                                                                                                                          https://developer.mozilla.org/docs/Web/Reference/Events/open_serversentevents

                                                                                                                                                                                          func OrientationChange

                                                                                                                                                                                          func OrientationChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                            OrientationChange is an event fired when the orientation of the device (portrait/landscape) has changed

                                                                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/orientationchange

                                                                                                                                                                                            func PageHide

                                                                                                                                                                                            func PageHide(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                              PageHide is an event fired when a session history entry is being traversed from.

                                                                                                                                                                                              https://developer.mozilla.org/docs/Web/Events/pagehide

                                                                                                                                                                                              func PageShow

                                                                                                                                                                                              func PageShow(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                PageShow is an event fired when a session history entry is being traversed to.

                                                                                                                                                                                                https://developer.mozilla.org/docs/Web/Events/pageshow

                                                                                                                                                                                                func Paste

                                                                                                                                                                                                func Paste(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                  Paste is an event fired when data has been transferred from the system clipboard to the document.

                                                                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/paste

                                                                                                                                                                                                  func Pause

                                                                                                                                                                                                  func Pause(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                    Pause is an event fired when the utterance is paused part way through.

                                                                                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/pause_(SpeechSynthesis)

                                                                                                                                                                                                    func Play

                                                                                                                                                                                                    func Play(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                      Play is an event fired when playback has begun.

                                                                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/play

                                                                                                                                                                                                      func Playing

                                                                                                                                                                                                      func Playing(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                        Playing is an event fired when playback is ready to start after having been paused or delayed due to lack of data.

                                                                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/playing

                                                                                                                                                                                                        func PointerCancel

                                                                                                                                                                                                        func PointerCancel(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                          PointerCancel is an event fired when the pointer is unlikely to produce any more events.

                                                                                                                                                                                                          https://developer.mozilla.org/docs/Web/Events/pointercancel

                                                                                                                                                                                                          func PointerDown

                                                                                                                                                                                                          func PointerDown(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                            PointerDown is an event fired when the pointer enters the active buttons state.

                                                                                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/pointerdown

                                                                                                                                                                                                            func PointerEnter

                                                                                                                                                                                                            func PointerEnter(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                              PointerEnter is an event fired when pointing device is moved inside the hit-testing boundary.

                                                                                                                                                                                                              https://developer.mozilla.org/docs/Web/Events/pointerenter

                                                                                                                                                                                                              func PointerLeave

                                                                                                                                                                                                              func PointerLeave(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                PointerLeave is an event fired when pointing device is moved out of the hit-testing boundary.

                                                                                                                                                                                                                https://developer.mozilla.org/docs/Web/Events/pointerleave

                                                                                                                                                                                                                func PointerLockChange

                                                                                                                                                                                                                func PointerLockChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                  PointerLockChange is an event fired when the pointer was locked or released.

                                                                                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/pointerlockchange

                                                                                                                                                                                                                  func PointerLockError

                                                                                                                                                                                                                  func PointerLockError(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                    PointerLockError is an event fired when it was impossible to lock the pointer for technical reasons or because the permission was denied.

                                                                                                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/pointerlockerror

                                                                                                                                                                                                                    func PointerMove

                                                                                                                                                                                                                    func PointerMove(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                      PointerMove is an event fired when the pointer changed coordinates.

                                                                                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/pointermove

                                                                                                                                                                                                                      func PointerOut

                                                                                                                                                                                                                      func PointerOut(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                        PointerOut is an event fired when the pointing device moved out of hit-testing boundary or leaves detectable hover range.

                                                                                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/pointerout

                                                                                                                                                                                                                        func PointerOver

                                                                                                                                                                                                                        func PointerOver(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                          PointerOver is an event fired when the pointing device is moved into the hit-testing boundary.

                                                                                                                                                                                                                          https://developer.mozilla.org/docs/Web/Events/pointerover

                                                                                                                                                                                                                          func PointerUp

                                                                                                                                                                                                                          func PointerUp(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                            PointerUp is an event fired when the pointer leaves the active buttons state.

                                                                                                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/pointerup

                                                                                                                                                                                                                            func PopState

                                                                                                                                                                                                                            func PopState(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                              PopState is an event fired when a session history entry is being navigated to (in certain cases).

                                                                                                                                                                                                                              https://developer.mozilla.org/docs/Web/Events/popstate

                                                                                                                                                                                                                              func Progress

                                                                                                                                                                                                                              func Progress(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                Progress is an event fired when the user agent is downloading resources listed by the manifest.

                                                                                                                                                                                                                                https://developer.mozilla.org/docs/Web/Reference/Events/progress_(appcache_event)

                                                                                                                                                                                                                                func Push

                                                                                                                                                                                                                                func Push(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                  Push is an event fired when a Service Worker has received a push message.

                                                                                                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/push

                                                                                                                                                                                                                                  func PushSubscriptionChange

                                                                                                                                                                                                                                  func PushSubscriptionChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                    PushSubscriptionChange is an event fired when a PushSubscription has expired.

                                                                                                                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/pushsubscriptionchange

                                                                                                                                                                                                                                    func RateChange

                                                                                                                                                                                                                                    func RateChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                      RateChange is an event fired when the playback rate has changed.

                                                                                                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/ratechange

                                                                                                                                                                                                                                      func ReadyStateChange

                                                                                                                                                                                                                                      func ReadyStateChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                        ReadyStateChange is an event fired when the readyState attribute of a document has changed.

                                                                                                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/readystatechange

                                                                                                                                                                                                                                        func RepeatEvent

                                                                                                                                                                                                                                        func RepeatEvent(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                          RepeatEvent is an event fired when a SMIL animation element is repeated.

                                                                                                                                                                                                                                          https://developer.mozilla.org/docs/Web/Events/repeatEvent

                                                                                                                                                                                                                                          func Reset

                                                                                                                                                                                                                                          func Reset(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                            Reset is an event fired when a form is reset.

                                                                                                                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/reset

                                                                                                                                                                                                                                            func Resize

                                                                                                                                                                                                                                            func Resize(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                              Resize is an event fired when the document view has been resized.

                                                                                                                                                                                                                                              https://developer.mozilla.org/docs/Web/Events/resize

                                                                                                                                                                                                                                              func ResourceTimingBufferFull

                                                                                                                                                                                                                                              func ResourceTimingBufferFull(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                ResourceTimingBufferFull is an event fired when the browser's resource timing buffer is full.

                                                                                                                                                                                                                                                https://developer.mozilla.org/docs/Web/Events/resourcetimingbufferfull

                                                                                                                                                                                                                                                func Result

                                                                                                                                                                                                                                                func Result(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                  Result is an event fired when the speech recognition service returns a result — a word or phrase has been positively recognized and this has been communicated back to the app.

                                                                                                                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/result

                                                                                                                                                                                                                                                  func Resume

                                                                                                                                                                                                                                                  func Resume(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                    Resume is an event fired when a paused utterance is resumed.

                                                                                                                                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/resume

                                                                                                                                                                                                                                                    func SVGAbort

                                                                                                                                                                                                                                                    func SVGAbort(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                      SVGAbort is an event fired when page loading has been stopped before the SVG was loaded.

                                                                                                                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/SVGAbort

                                                                                                                                                                                                                                                      func SVGError

                                                                                                                                                                                                                                                      func SVGError(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                        SVGError is an event fired when an error has occurred before the SVG was loaded.

                                                                                                                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/SVGError

                                                                                                                                                                                                                                                        func SVGLoad

                                                                                                                                                                                                                                                        func SVGLoad(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                          SVGLoad is an event fired when an SVG document has been loaded and parsed.

                                                                                                                                                                                                                                                          https://developer.mozilla.org/docs/Web/Events/SVGLoad

                                                                                                                                                                                                                                                          func SVGResize

                                                                                                                                                                                                                                                          func SVGResize(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                            SVGResize is an event fired when an SVG document is being resized.

                                                                                                                                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/SVGResize

                                                                                                                                                                                                                                                            func SVGScroll

                                                                                                                                                                                                                                                            func SVGScroll(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                              SVGScroll is an event fired when an SVG document is being scrolled.

                                                                                                                                                                                                                                                              https://developer.mozilla.org/docs/Web/Events/SVGScroll

                                                                                                                                                                                                                                                              func SVGUnload

                                                                                                                                                                                                                                                              func SVGUnload(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                SVGUnload is an event fired when an SVG document has been removed from a window or frame.

                                                                                                                                                                                                                                                                https://developer.mozilla.org/docs/Web/Events/SVGUnload

                                                                                                                                                                                                                                                                func SVGZoom

                                                                                                                                                                                                                                                                func SVGZoom(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                  SVGZoom is an event fired when an SVG document is being zoomed.

                                                                                                                                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/SVGZoom

                                                                                                                                                                                                                                                                  func Scroll

                                                                                                                                                                                                                                                                  func Scroll(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                    Scroll is an event fired when the document view or an element has been scrolled.

                                                                                                                                                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/scroll

                                                                                                                                                                                                                                                                    func Seeked

                                                                                                                                                                                                                                                                    func Seeked(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                      Seeked is an event fired when a seek operation completed.

                                                                                                                                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/seeked

                                                                                                                                                                                                                                                                      func Seeking

                                                                                                                                                                                                                                                                      func Seeking(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                        Seeking is an event fired when a seek operation began.

                                                                                                                                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/seeking

                                                                                                                                                                                                                                                                        func Select

                                                                                                                                                                                                                                                                        func Select(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                          Select is an event fired when some text is being selected.

                                                                                                                                                                                                                                                                          https://developer.mozilla.org/docs/Web/Events/select

                                                                                                                                                                                                                                                                          func SelectStart

                                                                                                                                                                                                                                                                          func SelectStart(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                            SelectStart is an event fired when a selection just started.

                                                                                                                                                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/selectstart

                                                                                                                                                                                                                                                                            func SelectionChange

                                                                                                                                                                                                                                                                            func SelectionChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                              SelectionChange is an event fired when the selection in the document has been changed.

                                                                                                                                                                                                                                                                              https://developer.mozilla.org/docs/Web/Events/selectionchange

                                                                                                                                                                                                                                                                              func Show

                                                                                                                                                                                                                                                                              func Show(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                Show is an event fired when a contextmenu event was fired on/bubbled to an element that has a contextmenu attribute

                                                                                                                                                                                                                                                                                https://developer.mozilla.org/docs/Web/Events/show

                                                                                                                                                                                                                                                                                func SlotChange

                                                                                                                                                                                                                                                                                func SlotChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                  SlotChange is an event fired when the node contents of a HTMLSlotElement (<slot>) have changed.

                                                                                                                                                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/slotchange

                                                                                                                                                                                                                                                                                  func SoundEnd

                                                                                                                                                                                                                                                                                  func SoundEnd(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                    SoundEnd is an event fired when any sound — recognisable speech or not — has stopped being detected.

                                                                                                                                                                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/soundend

                                                                                                                                                                                                                                                                                    func SoundStart

                                                                                                                                                                                                                                                                                    func SoundStart(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                      SoundStart is an event fired when any sound — recognisable speech or not — has been detected.

                                                                                                                                                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/soundstart

                                                                                                                                                                                                                                                                                      func SpeechEnd

                                                                                                                                                                                                                                                                                      func SpeechEnd(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                        SpeechEnd is an event fired when speech recognised by the speech recognition service has stopped being detected.

                                                                                                                                                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/speechend

                                                                                                                                                                                                                                                                                        func SpeechStart

                                                                                                                                                                                                                                                                                        func SpeechStart(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                          SpeechStart is an event fired when sound that is recognised by the speech recognition service as speech has been detected.

                                                                                                                                                                                                                                                                                          https://developer.mozilla.org/docs/Web/Events/speechstart

                                                                                                                                                                                                                                                                                          func Stalled

                                                                                                                                                                                                                                                                                          func Stalled(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                            Stalled is an event fired when the user agent is trying to fetch media data, but data is unexpectedly not forthcoming.

                                                                                                                                                                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/stalled

                                                                                                                                                                                                                                                                                            func Start

                                                                                                                                                                                                                                                                                            func Start(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                              Start is an event fired when the utterance has begun to be spoken.

                                                                                                                                                                                                                                                                                              https://developer.mozilla.org/docs/Web/Events/start_(SpeechSynthesis)

                                                                                                                                                                                                                                                                                              func Storage

                                                                                                                                                                                                                                                                                              func Storage(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                Storage is an event fired when a storage area (localStorage or sessionStorage) has changed.

                                                                                                                                                                                                                                                                                                https://developer.mozilla.org/docs/Web/Events/storage

                                                                                                                                                                                                                                                                                                func Submit

                                                                                                                                                                                                                                                                                                func Submit(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                  Submit is an event fired when a form is submitted.

                                                                                                                                                                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/submit

                                                                                                                                                                                                                                                                                                  func Success

                                                                                                                                                                                                                                                                                                  func Success(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                    Success is an event fired when a request successfully completed.

                                                                                                                                                                                                                                                                                                    https://developer.mozilla.org/docs/Web/Reference/Events/success_indexedDB

                                                                                                                                                                                                                                                                                                    func Suspend

                                                                                                                                                                                                                                                                                                    func Suspend(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                      Suspend is an event fired when media data loading has been suspended.

                                                                                                                                                                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/suspend

                                                                                                                                                                                                                                                                                                      func TimeUpdate

                                                                                                                                                                                                                                                                                                      func TimeUpdate(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                        TimeUpdate is an event fired when the time indicated by the currentTime attribute has been updated.

                                                                                                                                                                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/timeupdate

                                                                                                                                                                                                                                                                                                        func Timeout

                                                                                                                                                                                                                                                                                                        func Timeout(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                          Timeout event is fired when Progression is terminated due to preset time expiring.

                                                                                                                                                                                                                                                                                                          https://developer.mozilla.org/docs/Web/Events/timeout

                                                                                                                                                                                                                                                                                                          func TouchCancel

                                                                                                                                                                                                                                                                                                          func TouchCancel(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                            TouchCancel is an event fired when a touch point has been disrupted in an implementation-specific manners (too many touch points for example).

                                                                                                                                                                                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/touchcancel

                                                                                                                                                                                                                                                                                                            func TouchEnd

                                                                                                                                                                                                                                                                                                            func TouchEnd(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                              TouchEnd is an event fired when a touch point is removed from the touch surface.

                                                                                                                                                                                                                                                                                                              https://developer.mozilla.org/docs/Web/Events/touchend

                                                                                                                                                                                                                                                                                                              func TouchMove

                                                                                                                                                                                                                                                                                                              func TouchMove(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                TouchMove is an event fired when a touch point is moved along the touch surface.

                                                                                                                                                                                                                                                                                                                https://developer.mozilla.org/docs/Web/Events/touchmove

                                                                                                                                                                                                                                                                                                                func TouchStart

                                                                                                                                                                                                                                                                                                                func TouchStart(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                  TouchStart is an event fired when a touch point is placed on the touch surface.

                                                                                                                                                                                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/touchstart

                                                                                                                                                                                                                                                                                                                  func TransitionEnd

                                                                                                                                                                                                                                                                                                                  func TransitionEnd(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                    TransitionEnd is an event fired when a CSS transition has completed.

                                                                                                                                                                                                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/transitionend

                                                                                                                                                                                                                                                                                                                    func Unload

                                                                                                                                                                                                                                                                                                                    func Unload(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                      Unload is an event fired when the document or a dependent resource is being unloaded.

                                                                                                                                                                                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/unload

                                                                                                                                                                                                                                                                                                                      func UpdateReady

                                                                                                                                                                                                                                                                                                                      func UpdateReady(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                        UpdateReady is an event fired when the resources listed in the manifest have been newly redownloaded, and the script can use swapCache() to switch to the new cache.

                                                                                                                                                                                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/updateready

                                                                                                                                                                                                                                                                                                                        func UpgradeNeeded

                                                                                                                                                                                                                                                                                                                        func UpgradeNeeded(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                          UpgradeNeeded is an event fired when an attempt was made to open a database with a version number higher than its current version. A versionchange transaction has been created.

                                                                                                                                                                                                                                                                                                                          https://developer.mozilla.org/docs/Web/Reference/Events/upgradeneeded_indexedDB

                                                                                                                                                                                                                                                                                                                          func UserProximity

                                                                                                                                                                                                                                                                                                                          func UserProximity(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                            UserProximity is an event fired when fresh data is available from a proximity sensor (indicates whether the nearby object is near the device or not).

                                                                                                                                                                                                                                                                                                                            https://developer.mozilla.org/docs/Web/Events/userproximity

                                                                                                                                                                                                                                                                                                                            func VersionChange

                                                                                                                                                                                                                                                                                                                            func VersionChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                              VersionChange is an event fired when a versionchange transaction completed.

                                                                                                                                                                                                                                                                                                                              https://developer.mozilla.org/docs/Web/Reference/Events/versionchange_indexedDB

                                                                                                                                                                                                                                                                                                                              func VisibilityChange

                                                                                                                                                                                                                                                                                                                              func VisibilityChange(listener func(*vecty.Event)) *vecty.EventListener

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

                                                                                                                                                                                                                                                                                                                                https://developer.mozilla.org/docs/Web/Events/visibilitychange

                                                                                                                                                                                                                                                                                                                                func VoicesChanged

                                                                                                                                                                                                                                                                                                                                func VoicesChanged(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                                  VoicesChanged is an event fired when the list of SpeechSynthesisVoice objects that would be returned by the SpeechSynthesis.getVoices() method has changed (when the voiceschanged event fires.)

                                                                                                                                                                                                                                                                                                                                  https://developer.mozilla.org/docs/Web/Events/voiceschanged

                                                                                                                                                                                                                                                                                                                                  func VolumeChange

                                                                                                                                                                                                                                                                                                                                  func VolumeChange(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                                    VolumeChange is an event fired when the volume has changed.

                                                                                                                                                                                                                                                                                                                                    https://developer.mozilla.org/docs/Web/Events/volumechange

                                                                                                                                                                                                                                                                                                                                    func Waiting

                                                                                                                                                                                                                                                                                                                                    func Waiting(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                                      Waiting is an event fired when playback has stopped because of a temporary lack of data.

                                                                                                                                                                                                                                                                                                                                      https://developer.mozilla.org/docs/Web/Events/waiting

                                                                                                                                                                                                                                                                                                                                      func Wheel

                                                                                                                                                                                                                                                                                                                                      func Wheel(listener func(*vecty.Event)) *vecty.EventListener

                                                                                                                                                                                                                                                                                                                                        Wheel is an event fired when a wheel button of a pointing device is rotated in any direction.

                                                                                                                                                                                                                                                                                                                                        https://developer.mozilla.org/docs/Web/Events/wheel

                                                                                                                                                                                                                                                                                                                                        Types

                                                                                                                                                                                                                                                                                                                                        This section is empty.

                                                                                                                                                                                                                                                                                                                                        Source Files