GlobalEventHandlers abstract#

abstract class GlobalEventHandlers implements EventTarget

Implemented types

EventTarget

Implementers

Properties#

hashCode no setter inherited#

int get hashCode

The hash code for this object.

A hash code is a single integer which represents the state of the object that affects operator == comparisons.

All objects have hash codes. The default hash code implemented by Object represents only the identity of the object, the same way as the default operator == implementation only considers objects equal if they are identical (see identityHashCode).

If operator == is overridden to use the object state instead, the hash code must also be changed to represent that state, otherwise the object cannot be used in hash based data structures like the default Set and Map implementations.

Hash codes must be the same for objects that are equal to each other according to operator ==. The hash code of an object should only change if the object changes in a way that affects equality. There are no further requirements for the hash codes. They need not be consistent between executions of the same program and there are no distribution guarantees.

Objects that are not equal are allowed to have the same hash code. It is even technically allowed that all instances have the same hash code, but if clashes happen too often, it may reduce the efficiency of hash-based data structures like HashSet or HashMap.

If a subclass overrides hashCode, it should override the operator == operator as well to maintain consistency.

Inherited from Object.

Implementation

external int get hashCode;

on no setter override#

Events get on

This is an ease-of-use accessor for event streams which should only be used when an explicit accessor is not available.

Implementation

Events get on;

onAbort no setter#

Stream<Event> get onAbort

Implementation

Stream<Event> get onAbort => abortEvent.forTarget(this);

onBlur no setter#

Stream<Event> get onBlur

Implementation

Stream<Event> get onBlur => blurEvent.forTarget(this);

onCanPlay no setter#

Stream<Event> get onCanPlay

Implementation

Stream<Event> get onCanPlay => canPlayEvent.forTarget(this);

onCanPlayThrough no setter#

Stream<Event> get onCanPlayThrough

Implementation

Stream<Event> get onCanPlayThrough => canPlayThroughEvent.forTarget(this);

onChange no setter#

Stream<Event> get onChange

Implementation

Stream<Event> get onChange => changeEvent.forTarget(this);

onClick no setter#

Stream<MouseEvent> get onClick

Implementation

Stream<MouseEvent> get onClick => clickEvent.forTarget(this);

onContextMenu no setter#

Stream<MouseEvent> get onContextMenu

Implementation

Stream<MouseEvent> get onContextMenu => contextMenuEvent.forTarget(this);

onDoubleClick no setter#

Stream<Event> get onDoubleClick

Implementation

@DomName('GlobalEventHandlers.ondblclick')
Stream<Event> get onDoubleClick => doubleClickEvent.forTarget(this);

onDrag no setter#

Stream<MouseEvent> get onDrag

Implementation

Stream<MouseEvent> get onDrag => dragEvent.forTarget(this);

onDragEnd no setter#

Stream<MouseEvent> get onDragEnd

Implementation

Stream<MouseEvent> get onDragEnd => dragEndEvent.forTarget(this);

onDragEnter no setter#

Stream<MouseEvent> get onDragEnter

Implementation

Stream<MouseEvent> get onDragEnter => dragEnterEvent.forTarget(this);

onDragLeave no setter#

Stream<MouseEvent> get onDragLeave

Implementation

Stream<MouseEvent> get onDragLeave => dragLeaveEvent.forTarget(this);

onDragOver no setter#

Stream<MouseEvent> get onDragOver

Implementation

Stream<MouseEvent> get onDragOver => dragOverEvent.forTarget(this);

onDragStart no setter#

Stream<MouseEvent> get onDragStart

Implementation

Stream<MouseEvent> get onDragStart => dragStartEvent.forTarget(this);

onDrop no setter#

Stream<MouseEvent> get onDrop

Implementation

Stream<MouseEvent> get onDrop => dropEvent.forTarget(this);

onDurationChange no setter#

Stream<Event> get onDurationChange

Implementation

Stream<Event> get onDurationChange => durationChangeEvent.forTarget(this);

onEmptied no setter#

Stream<Event> get onEmptied

Implementation

Stream<Event> get onEmptied => emptiedEvent.forTarget(this);

onEnded no setter#

Stream<Event> get onEnded

Implementation

Stream<Event> get onEnded => endedEvent.forTarget(this);

onError no setter#

Stream<Event> get onError

Implementation

Stream<Event> get onError => errorEvent.forTarget(this);

onFocus no setter#

Stream<Event> get onFocus

Implementation

Stream<Event> get onFocus => focusEvent.forTarget(this);

onInput no setter#

Stream<Event> get onInput

Implementation

Stream<Event> get onInput => inputEvent.forTarget(this);

onInvalid no setter#

Stream<Event> get onInvalid

Implementation

Stream<Event> get onInvalid => invalidEvent.forTarget(this);

onKeyDown no setter#

Stream<KeyboardEvent> get onKeyDown

Implementation

Stream<KeyboardEvent> get onKeyDown => keyDownEvent.forTarget(this);

onKeyPress no setter#

Stream<KeyboardEvent> get onKeyPress

Implementation

Stream<KeyboardEvent> get onKeyPress => keyPressEvent.forTarget(this);

onKeyUp no setter#

Stream<KeyboardEvent> get onKeyUp

Implementation

Stream<KeyboardEvent> get onKeyUp => keyUpEvent.forTarget(this);

onLoad no setter#

Stream<Event> get onLoad

Implementation

Stream<Event> get onLoad => loadEvent.forTarget(this);

onLoadedData no setter#

Stream<Event> get onLoadedData

Implementation

Stream<Event> get onLoadedData => loadedDataEvent.forTarget(this);

onLoadedMetadata no setter#

Stream<Event> get onLoadedMetadata

Implementation

Stream<Event> get onLoadedMetadata => loadedMetadataEvent.forTarget(this);

onMouseDown no setter#

Stream<MouseEvent> get onMouseDown

Implementation

Stream<MouseEvent> get onMouseDown => mouseDownEvent.forTarget(this);

onMouseEnter no setter#

Stream<MouseEvent> get onMouseEnter

Implementation

Stream<MouseEvent> get onMouseEnter => mouseEnterEvent.forTarget(this);

onMouseLeave no setter#

Stream<MouseEvent> get onMouseLeave

Implementation

Stream<MouseEvent> get onMouseLeave => mouseLeaveEvent.forTarget(this);

onMouseMove no setter#

Stream<MouseEvent> get onMouseMove

Implementation

Stream<MouseEvent> get onMouseMove => mouseMoveEvent.forTarget(this);

onMouseOut no setter#

Stream<MouseEvent> get onMouseOut

Implementation

Stream<MouseEvent> get onMouseOut => mouseOutEvent.forTarget(this);

onMouseOver no setter#

Stream<MouseEvent> get onMouseOver

Implementation

Stream<MouseEvent> get onMouseOver => mouseOverEvent.forTarget(this);

onMouseUp no setter#

Stream<MouseEvent> get onMouseUp

Implementation

Stream<MouseEvent> get onMouseUp => mouseUpEvent.forTarget(this);

onMouseWheel no setter#

Stream<WheelEvent> get onMouseWheel

Implementation

Stream<WheelEvent> get onMouseWheel => mouseWheelEvent.forTarget(this);

onPause no setter#

Stream<Event> get onPause

Implementation

Stream<Event> get onPause => pauseEvent.forTarget(this);

onPlay no setter#

Stream<Event> get onPlay

Implementation

Stream<Event> get onPlay => playEvent.forTarget(this);

onPlaying no setter#

Stream<Event> get onPlaying

Implementation

Stream<Event> get onPlaying => playingEvent.forTarget(this);

onRateChange no setter#

Stream<Event> get onRateChange

Implementation

Stream<Event> get onRateChange => rateChangeEvent.forTarget(this);

onReset no setter#

Stream<Event> get onReset

Implementation

Stream<Event> get onReset => resetEvent.forTarget(this);

onResize no setter#

Stream<Event> get onResize

Implementation

Stream<Event> get onResize => resizeEvent.forTarget(this);

onScroll no setter#

Stream<Event> get onScroll

Implementation

Stream<Event> get onScroll => scrollEvent.forTarget(this);

onSeeked no setter#

Stream<Event> get onSeeked

Implementation

Stream<Event> get onSeeked => seekedEvent.forTarget(this);

onSeeking no setter#

Stream<Event> get onSeeking

Implementation

Stream<Event> get onSeeking => seekingEvent.forTarget(this);

onSelect no setter#

Stream<Event> get onSelect

Implementation

Stream<Event> get onSelect => selectEvent.forTarget(this);

onStalled no setter#

Stream<Event> get onStalled

Implementation

Stream<Event> get onStalled => stalledEvent.forTarget(this);

onSubmit no setter#

Stream<Event> get onSubmit

Implementation

Stream<Event> get onSubmit => submitEvent.forTarget(this);

onSuspend no setter#

Stream<Event> get onSuspend

Implementation

Stream<Event> get onSuspend => suspendEvent.forTarget(this);

onTimeUpdate no setter#

Stream<Event> get onTimeUpdate

Implementation

Stream<Event> get onTimeUpdate => timeUpdateEvent.forTarget(this);

onTouchCancel no setter#

Stream<TouchEvent> get onTouchCancel

Implementation

Stream<TouchEvent> get onTouchCancel => touchCancelEvent.forTarget(this);

onTouchEnd no setter#

Stream<TouchEvent> get onTouchEnd

Implementation

Stream<TouchEvent> get onTouchEnd => touchEndEvent.forTarget(this);

onTouchMove no setter#

Stream<TouchEvent> get onTouchMove

Implementation

Stream<TouchEvent> get onTouchMove => touchMoveEvent.forTarget(this);

onTouchStart no setter#

Stream<TouchEvent> get onTouchStart

Implementation

Stream<TouchEvent> get onTouchStart => touchStartEvent.forTarget(this);

onVolumeChange no setter#

Stream<Event> get onVolumeChange

Implementation

Stream<Event> get onVolumeChange => volumeChangeEvent.forTarget(this);

onWaiting no setter#

Stream<Event> get onWaiting

Implementation

Stream<Event> get onWaiting => waitingEvent.forTarget(this);

onWheel no setter#

Stream<WheelEvent> get onWheel

Implementation

Stream<WheelEvent> get onWheel => wheelEvent.forTarget(this);

runtimeType no setter inherited#

Type get runtimeType

A representation of the runtime type of the object.

Inherited from Object.

Implementation

external Type get runtimeType;

Methods#

addEventListener() override#

void addEventListener( String type, dynamic Function(Event event)? listener, [ bool? useCapture, ]);

Implementation

void addEventListener(
  String type,
  dynamic listener(Event event)?, [
  bool? useCapture,
]);

dispatchEvent() override#

bool dispatchEvent(Event event)

Implementation

bool dispatchEvent(Event event);

noSuchMethod() inherited#

dynamic noSuchMethod(Invocation invocation)

Invoked when a nonexistent method or property is accessed.

A dynamic member invocation can attempt to call a member which doesn't exist on the receiving object. Example:

dynamic object = 1;
object.add(42); // Statically allowed, run-time error

This invalid code will invoke the noSuchMethod method of the integer 1 with an Invocation representing the .add(42) call and arguments (which then throws).

Classes can override noSuchMethod to provide custom behavior for such invalid dynamic invocations.

A class with a non-default noSuchMethod invocation can also omit implementations for members of its interface. Example:

class MockList<T> implements List<T> {
  noSuchMethod(Invocation invocation) {
    log(invocation);
    super.noSuchMethod(invocation); // Will throw.
  }
}
void main() {
  MockList().add(42);
}

This code has no compile-time warnings or errors even though the MockList class has no concrete implementation of any of the List interface methods. Calls to List methods are forwarded to noSuchMethod, so this code will log an invocation similar to Invocation.method(#add, [42]) and then throw.

If a value is returned from noSuchMethod, it becomes the result of the original invocation. If the value is not of a type that can be returned by the original invocation, a type error occurs at the invocation.

The default behavior is to throw a NoSuchMethodError.

Inherited from Object.

Implementation

@pragma("vm:entry-point")
@pragma("wasm:entry-point")
external dynamic noSuchMethod(Invocation invocation);

removeEventListener() override#

void removeEventListener( String type, dynamic Function(Event event)? listener, [ bool? useCapture, ]);

Implementation

void removeEventListener(
  String type,
  dynamic listener(Event event)?, [
  bool? useCapture,
]);

toString() inherited#

String toString()

A string representation of this object.

Some classes have a default textual representation, often paired with a static parse function (like int.parse). These classes will provide the textual representation as their string representation.

Other classes have no meaningful textual representation that a program will care about. Such classes will typically override toString to provide useful information when inspecting the object, mainly for debugging or logging.

Inherited from Object.

Implementation

external String toString();

Operators#

operator ==() inherited#

bool operator ==(Object other)

The equality operator.

The default behavior for all Objects is to return true if and only if this object and other are the same object.

Override this method to specify a different equality relation on a class. The overriding method must still be an equivalence relation. That is, it must be:

Total: It must return a boolean for all arguments. It should never throw.
Reflexive: For all objects o, o == o must be true.
Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must either both be true, or both be false.
Transitive: For all objects o1, o2, and o3, if o1 == o2 and o2 == o3 are true, then o1 == o3 must be true.

The method should also be consistent over time, so whether two objects are equal should only change if at least one of the objects was modified.

If a subclass overrides the equality operator, it should override the hashCode method as well to maintain consistency.

Inherited from Object.

Implementation

external bool operator ==(Object other);

Constants#

abortEvent#

const EventStreamProvider<Event> abortEvent

Implementation

static const EventStreamProvider<Event> abortEvent =
    const EventStreamProvider<Event>('abort');

blurEvent#

const EventStreamProvider<Event> blurEvent

Implementation

static const EventStreamProvider<Event> blurEvent =
    const EventStreamProvider<Event>('blur');

canPlayEvent#

const EventStreamProvider<Event> canPlayEvent

Implementation

static const EventStreamProvider<Event> canPlayEvent =
    const EventStreamProvider<Event>('canplay');

canPlayThroughEvent#

const EventStreamProvider<Event> canPlayThroughEvent

Implementation

static const EventStreamProvider<Event> canPlayThroughEvent =
    const EventStreamProvider<Event>('canplaythrough');

changeEvent#

const EventStreamProvider<Event> changeEvent

Implementation

static const EventStreamProvider<Event> changeEvent =
    const EventStreamProvider<Event>('change');

clickEvent#

const EventStreamProvider<MouseEvent> clickEvent

Implementation

static const EventStreamProvider<MouseEvent> clickEvent =
    const EventStreamProvider<MouseEvent>('click');

contextMenuEvent#

const EventStreamProvider<MouseEvent> contextMenuEvent

Implementation

static const EventStreamProvider<MouseEvent> contextMenuEvent =
    const EventStreamProvider<MouseEvent>('contextmenu');

doubleClickEvent#

const EventStreamProvider<Event> doubleClickEvent

Implementation

@DomName('GlobalEventHandlers.dblclickEvent')
static const EventStreamProvider<Event> doubleClickEvent =
    const EventStreamProvider<Event>('dblclick');

dragEndEvent#

const EventStreamProvider<MouseEvent> dragEndEvent

Implementation

static const EventStreamProvider<MouseEvent> dragEndEvent =
    const EventStreamProvider<MouseEvent>('dragend');

dragEnterEvent#

const EventStreamProvider<MouseEvent> dragEnterEvent

Implementation

static const EventStreamProvider<MouseEvent> dragEnterEvent =
    const EventStreamProvider<MouseEvent>('dragenter');

dragEvent#

const EventStreamProvider<MouseEvent> dragEvent

Implementation

static const EventStreamProvider<MouseEvent> dragEvent =
    const EventStreamProvider<MouseEvent>('drag');

dragLeaveEvent#

const EventStreamProvider<MouseEvent> dragLeaveEvent

Implementation

static const EventStreamProvider<MouseEvent> dragLeaveEvent =
    const EventStreamProvider<MouseEvent>('dragleave');

dragOverEvent#

const EventStreamProvider<MouseEvent> dragOverEvent

Implementation

static const EventStreamProvider<MouseEvent> dragOverEvent =
    const EventStreamProvider<MouseEvent>('dragover');

dragStartEvent#

const EventStreamProvider<MouseEvent> dragStartEvent

Implementation

static const EventStreamProvider<MouseEvent> dragStartEvent =
    const EventStreamProvider<MouseEvent>('dragstart');

dropEvent#

const EventStreamProvider<MouseEvent> dropEvent

Implementation

static const EventStreamProvider<MouseEvent> dropEvent =
    const EventStreamProvider<MouseEvent>('drop');

durationChangeEvent#

const EventStreamProvider<Event> durationChangeEvent

Implementation

static const EventStreamProvider<Event> durationChangeEvent =
    const EventStreamProvider<Event>('durationchange');

emptiedEvent#

const EventStreamProvider<Event> emptiedEvent

Implementation

static const EventStreamProvider<Event> emptiedEvent =
    const EventStreamProvider<Event>('emptied');

endedEvent#

const EventStreamProvider<Event> endedEvent

Implementation

static const EventStreamProvider<Event> endedEvent =
    const EventStreamProvider<Event>('ended');

errorEvent#

const EventStreamProvider<Event> errorEvent

Implementation

static const EventStreamProvider<Event> errorEvent =
    const EventStreamProvider<Event>('error');

focusEvent#

const EventStreamProvider<Event> focusEvent

Implementation

static const EventStreamProvider<Event> focusEvent =
    const EventStreamProvider<Event>('focus');

inputEvent#

const EventStreamProvider<Event> inputEvent

Implementation

static const EventStreamProvider<Event> inputEvent =
    const EventStreamProvider<Event>('input');

invalidEvent#

const EventStreamProvider<Event> invalidEvent

Implementation

static const EventStreamProvider<Event> invalidEvent =
    const EventStreamProvider<Event>('invalid');

keyDownEvent#

const EventStreamProvider<KeyboardEvent> keyDownEvent

Implementation

static const EventStreamProvider<KeyboardEvent> keyDownEvent =
    const EventStreamProvider<KeyboardEvent>('keydown');

keyPressEvent#

const EventStreamProvider<KeyboardEvent> keyPressEvent

Implementation

static const EventStreamProvider<KeyboardEvent> keyPressEvent =
    const EventStreamProvider<KeyboardEvent>('keypress');

keyUpEvent#

const EventStreamProvider<KeyboardEvent> keyUpEvent

Implementation

static const EventStreamProvider<KeyboardEvent> keyUpEvent =
    const EventStreamProvider<KeyboardEvent>('keyup');

loadedDataEvent#

const EventStreamProvider<Event> loadedDataEvent

Implementation

static const EventStreamProvider<Event> loadedDataEvent =
    const EventStreamProvider<Event>('loadeddata');

loadedMetadataEvent#

const EventStreamProvider<Event> loadedMetadataEvent

Implementation

static const EventStreamProvider<Event> loadedMetadataEvent =
    const EventStreamProvider<Event>('loadedmetadata');

loadEvent#

const EventStreamProvider<Event> loadEvent

Implementation

static const EventStreamProvider<Event> loadEvent =
    const EventStreamProvider<Event>('load');

mouseDownEvent#

const EventStreamProvider<MouseEvent> mouseDownEvent

Implementation

static const EventStreamProvider<MouseEvent> mouseDownEvent =
    const EventStreamProvider<MouseEvent>('mousedown');

mouseEnterEvent#

const EventStreamProvider<MouseEvent> mouseEnterEvent

Implementation

static const EventStreamProvider<MouseEvent> mouseEnterEvent =
    const EventStreamProvider<MouseEvent>('mouseenter');

mouseLeaveEvent#

const EventStreamProvider<MouseEvent> mouseLeaveEvent

Implementation

static const EventStreamProvider<MouseEvent> mouseLeaveEvent =
    const EventStreamProvider<MouseEvent>('mouseleave');

mouseMoveEvent#

const EventStreamProvider<MouseEvent> mouseMoveEvent

Implementation

static const EventStreamProvider<MouseEvent> mouseMoveEvent =
    const EventStreamProvider<MouseEvent>('mousemove');

mouseOutEvent#

const EventStreamProvider<MouseEvent> mouseOutEvent

Implementation

static const EventStreamProvider<MouseEvent> mouseOutEvent =
    const EventStreamProvider<MouseEvent>('mouseout');

mouseOverEvent#

const EventStreamProvider<MouseEvent> mouseOverEvent

Implementation

static const EventStreamProvider<MouseEvent> mouseOverEvent =
    const EventStreamProvider<MouseEvent>('mouseover');

mouseUpEvent#

const EventStreamProvider<MouseEvent> mouseUpEvent

Implementation

static const EventStreamProvider<MouseEvent> mouseUpEvent =
    const EventStreamProvider<MouseEvent>('mouseup');

mouseWheelEvent#

const EventStreamProvider<WheelEvent> mouseWheelEvent

Implementation

static const EventStreamProvider<WheelEvent> mouseWheelEvent =
    const EventStreamProvider<WheelEvent>('mousewheel');

pauseEvent#

const EventStreamProvider<Event> pauseEvent

Implementation

static const EventStreamProvider<Event> pauseEvent =
    const EventStreamProvider<Event>('pause');

playEvent#

const EventStreamProvider<Event> playEvent

Implementation

static const EventStreamProvider<Event> playEvent =
    const EventStreamProvider<Event>('play');

playingEvent#

const EventStreamProvider<Event> playingEvent

Implementation

static const EventStreamProvider<Event> playingEvent =
    const EventStreamProvider<Event>('playing');

rateChangeEvent#

const EventStreamProvider<Event> rateChangeEvent

Implementation

static const EventStreamProvider<Event> rateChangeEvent =
    const EventStreamProvider<Event>('ratechange');

resetEvent#

const EventStreamProvider<Event> resetEvent

Implementation

static const EventStreamProvider<Event> resetEvent =
    const EventStreamProvider<Event>('reset');

resizeEvent#

const EventStreamProvider<Event> resizeEvent

Implementation

static const EventStreamProvider<Event> resizeEvent =
    const EventStreamProvider<Event>('resize');

scrollEvent#

const EventStreamProvider<Event> scrollEvent

Implementation

static const EventStreamProvider<Event> scrollEvent =
    const EventStreamProvider<Event>('scroll');

seekedEvent#

const EventStreamProvider<Event> seekedEvent

Implementation

static const EventStreamProvider<Event> seekedEvent =
    const EventStreamProvider<Event>('seeked');

seekingEvent#

const EventStreamProvider<Event> seekingEvent

Implementation

static const EventStreamProvider<Event> seekingEvent =
    const EventStreamProvider<Event>('seeking');

selectEvent#

const EventStreamProvider<Event> selectEvent

Implementation

static const EventStreamProvider<Event> selectEvent =
    const EventStreamProvider<Event>('select');

stalledEvent#

const EventStreamProvider<Event> stalledEvent

Implementation

static const EventStreamProvider<Event> stalledEvent =
    const EventStreamProvider<Event>('stalled');

submitEvent#

const EventStreamProvider<Event> submitEvent

Implementation

static const EventStreamProvider<Event> submitEvent =
    const EventStreamProvider<Event>('submit');

suspendEvent#

const EventStreamProvider<Event> suspendEvent

Implementation

static const EventStreamProvider<Event> suspendEvent =
    const EventStreamProvider<Event>('suspend');

timeUpdateEvent#

const EventStreamProvider<Event> timeUpdateEvent

Implementation

static const EventStreamProvider<Event> timeUpdateEvent =
    const EventStreamProvider<Event>('timeupdate');

touchCancelEvent#

const EventStreamProvider<TouchEvent> touchCancelEvent

Implementation

static const EventStreamProvider<TouchEvent> touchCancelEvent =
    const EventStreamProvider<TouchEvent>('touchcancel');

touchEndEvent#

const EventStreamProvider<TouchEvent> touchEndEvent

Implementation

static const EventStreamProvider<TouchEvent> touchEndEvent =
    const EventStreamProvider<TouchEvent>('touchend');

touchMoveEvent#

const EventStreamProvider<TouchEvent> touchMoveEvent

Implementation

static const EventStreamProvider<TouchEvent> touchMoveEvent =
    const EventStreamProvider<TouchEvent>('touchmove');

touchStartEvent#

const EventStreamProvider<TouchEvent> touchStartEvent

Implementation

static const EventStreamProvider<TouchEvent> touchStartEvent =
    const EventStreamProvider<TouchEvent>('touchstart');

volumeChangeEvent#

const EventStreamProvider<Event> volumeChangeEvent

Implementation

static const EventStreamProvider<Event> volumeChangeEvent =
    const EventStreamProvider<Event>('volumechange');

waitingEvent#

const EventStreamProvider<Event> waitingEvent

Implementation

static const EventStreamProvider<Event> waitingEvent =
    const EventStreamProvider<Event>('waiting');

wheelEvent#

const EventStreamProvider<WheelEvent> wheelEvent

Implementation

static const EventStreamProvider<WheelEvent> wheelEvent =
    const EventStreamProvider<WheelEvent>('wheel');