com.intendia.rxgwt2.user.RxEvents Maven / Gradle / Ivy

Go to download
package com.intendia.rxgwt2.user;

import static com.intendia.rxgwt2.user.RxUser.register;

import com.google.gwt.core.shared.GwtIncompatible;
import com.google.gwt.event.dom.client.BlurEvent;
import com.google.gwt.event.dom.client.CanPlayThroughEvent;
import com.google.gwt.event.dom.client.ChangeEvent;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ContextMenuEvent;
import com.google.gwt.event.dom.client.DoubleClickEvent;
import com.google.gwt.event.dom.client.DragEndEvent;
import com.google.gwt.event.dom.client.DragEnterEvent;
import com.google.gwt.event.dom.client.DragEvent;
import com.google.gwt.event.dom.client.DragLeaveEvent;
import com.google.gwt.event.dom.client.DragOverEvent;
import com.google.gwt.event.dom.client.DragStartEvent;
import com.google.gwt.event.dom.client.DropEvent;
import com.google.gwt.event.dom.client.EndedEvent;
import com.google.gwt.event.dom.client.ErrorEvent;
import com.google.gwt.event.dom.client.FocusEvent;
import com.google.gwt.event.dom.client.GestureChangeEvent;
import com.google.gwt.event.dom.client.GestureEndEvent;
import com.google.gwt.event.dom.client.GestureStartEvent;
import com.google.gwt.event.dom.client.KeyDownEvent;
import com.google.gwt.event.dom.client.KeyPressEvent;
import com.google.gwt.event.dom.client.KeyUpEvent;
import com.google.gwt.event.dom.client.LoadEvent;
import com.google.gwt.event.dom.client.LoadedMetadataEvent;
import com.google.gwt.event.dom.client.LoseCaptureEvent;
import com.google.gwt.event.dom.client.MouseDownEvent;
import com.google.gwt.event.dom.client.MouseMoveEvent;
import com.google.gwt.event.dom.client.MouseOutEvent;
import com.google.gwt.event.dom.client.MouseOverEvent;
import com.google.gwt.event.dom.client.MouseUpEvent;
import com.google.gwt.event.dom.client.MouseWheelEvent;
import com.google.gwt.event.dom.client.ProgressEvent;
import com.google.gwt.event.dom.client.ScrollEvent;
import com.google.gwt.event.dom.client.TouchCancelEvent;
import com.google.gwt.event.dom.client.TouchEndEvent;
import com.google.gwt.event.dom.client.TouchMoveEvent;
import com.google.gwt.event.dom.client.TouchStartEvent;
import com.google.gwt.event.logical.shared.AttachEvent;
import com.google.gwt.event.logical.shared.BeforeSelectionEvent;
import com.google.gwt.event.logical.shared.BeforeSelectionHandler;
import com.google.gwt.event.logical.shared.CloseEvent;
import com.google.gwt.event.logical.shared.CloseHandler;
import com.google.gwt.event.logical.shared.HighlightEvent;
import com.google.gwt.event.logical.shared.HighlightHandler;
import com.google.gwt.event.logical.shared.InitializeEvent;
import com.google.gwt.event.logical.shared.OpenEvent;
import com.google.gwt.event.logical.shared.OpenHandler;
import com.google.gwt.event.logical.shared.ResizeEvent;
import com.google.gwt.event.logical.shared.SelectionEvent;
import com.google.gwt.event.logical.shared.SelectionHandler;
import com.google.gwt.event.logical.shared.ShowRangeEvent;
import com.google.gwt.event.logical.shared.ShowRangeHandler;
import com.google.gwt.event.logical.shared.ValueChangeEvent;
import com.google.gwt.event.logical.shared.ValueChangeHandler;
import com.google.gwt.user.cellview.client.ColumnSortEvent;
import com.google.gwt.user.cellview.client.RowHoverEvent;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.ui.FormPanel;
import com.google.gwt.user.client.ui.Widget;
import com.google.gwt.view.client.CellPreviewEvent;
import com.google.gwt.view.client.RangeChangeEvent;
import com.google.gwt.view.client.RowCountChangeEvent;
import com.google.gwt.view.client.SelectionChangeEvent;
import io.reactivex.Observable;
import java.lang.SuppressWarnings;

@SuppressWarnings("unused")
public class RxEvents {
    public static Observable attach(Widget source) {
        return Observable.create(s -> register(s, source.addHandler(s::onNext, AttachEvent.getType())));
    }

    public static  Observable> beforeSelection(Widget source) {
        return Observable.create(s -> register(s, source.addHandler((BeforeSelectionHandler) s::onNext, BeforeSelectionEvent.getType())));
    }

    public static Observable blur(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, BlurEvent.getType())));
    }

    public static Observable canPlayThrough(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, CanPlayThroughEvent.getType())));
    }

    public static  Observable> cellPreview(Widget source) {
        return Observable.create(s -> register(s, source.addHandler((CellPreviewEvent.Handler) s::onNext, CellPreviewEvent.getType())));
    }

    public static Observable change(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, ChangeEvent.getType())));
    }

    public static Observable click(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, ClickEvent.getType())));
    }

    public static  Observable> close(Widget source) {
        return Observable.create(s -> register(s, source.addHandler((CloseHandler) s::onNext, CloseEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.user.client.Window$ClosingEvent do not have a public getType!")
    private void closing() {
    }

    public static Observable columnSort(Widget source) {
        return Observable.create(s -> register(s, source.addHandler(s::onNext, ColumnSortEvent.getType())));
    }

    public static Observable contextMenu(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, ContextMenuEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.user.datepicker.client.DateChangeEvent do not have a public getType!")
    private void dateChange() {
    }

    @GwtIncompatible("class com.google.gwt.user.datepicker.client.DatePicker$DateHighlightEvent do not have a public getType!")
    private void dateHighlight() {
    }

    @GwtIncompatible("class com.google.gwt.event.dom.client.DomEvent do not have a public getType!")
    private void dom() {
    }

    public static Observable doubleClick(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, DoubleClickEvent.getType())));
    }

    public static Observable drag(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, DragEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.event.dom.client.DragDropEventBase do not have a public getType!")
    private void dragDropEven() {
    }

    public static Observable dragEnd(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, DragEndEvent.getType())));
    }

    public static Observable dragEnter(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, DragEnterEvent.getType())));
    }

    public static Observable dragLeave(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, DragLeaveEvent.getType())));
    }

    public static Observable dragOver(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, DragOverEvent.getType())));
    }

    public static Observable dragStart(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, DragStartEvent.getType())));
    }

    public static Observable drop(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, DropEvent.getType())));
    }

    public static Observable ended(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, EndedEvent.getType())));
    }

    public static Observable error(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, ErrorEvent.getType())));
    }

    public static Observable focus(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, FocusEvent.getType())));
    }

    public static Observable gestureChange(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, GestureChangeEvent.getType())));
    }

    public static Observable gestureEnd(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, GestureEndEvent.getType())));
    }

    public static Observable gestureStart(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, GestureStartEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.event.shared.GwtEvent do not have a public getType!")
    private void gwt() {
    }

    public static  Observable> highlight(Widget source) {
        return Observable.create(s -> register(s, source.addHandler((HighlightHandler) s::onNext, HighlightEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.event.dom.client.HumanInputEvent do not have a public getType!")
    private void humanInput() {
    }

    public static Observable initialize(Widget source) {
        return Observable.create(s -> register(s, source.addHandler(s::onNext, InitializeEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.event.dom.client.KeyEvent do not have a public getType!")
    private void key() {
    }

    @GwtIncompatible("class com.google.gwt.event.dom.client.KeyCodeEvent do not have a public getType!")
    private void keyCode() {
    }

    public static Observable keyDown(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, KeyDownEvent.getType())));
    }

    public static Observable keyPress(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, KeyPressEvent.getType())));
    }

    public static Observable keyUp(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, KeyUpEvent.getType())));
    }

    public static Observable load(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, LoadEvent.getType())));
    }

    public static Observable loadedMetadata(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, LoadedMetadataEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.user.cellview.client.LoadingStateChangeEvent do not have a public getType!")
    private void loadingStateChange() {
    }

    public static Observable loseCapture(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, LoseCaptureEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.event.dom.client.MouseEvent do not have a public getType!")
    private void mouse() {
    }

    public static Observable mouseDown(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, MouseDownEvent.getType())));
    }

    public static Observable mouseMove(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, MouseMoveEvent.getType())));
    }

    public static Observable mouseOut(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, MouseOutEvent.getType())));
    }

    public static Observable mouseOver(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, MouseOverEvent.getType())));
    }

    public static Observable mouseUp(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, MouseUpEvent.getType())));
    }

    public static Observable mouseWheel(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, MouseWheelEvent.getType())));
    }

    public static Observable nativePreview(Widget source) {
        return Observable.create(s -> register(s, source.addHandler(s::onNext, Event.NativePreviewEvent.getType())));
    }

    public static  Observable> open(Widget source) {
        return Observable.create(s -> register(s, source.addHandler((OpenHandler) s::onNext, OpenEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.place.shared.PlaceChangeEvent do not have a public getType!")
    private void placeChange() {
    }

    @GwtIncompatible("class com.google.gwt.place.shared.PlaceChangeRequestEvent do not have a public getType!")
    private void placeChangeRequest() {
    }

    public static Observable progress(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, ProgressEvent.getType())));
    }

    public static Observable rangeChange(Widget source) {
        return Observable.create(s -> register(s, source.addHandler(s::onNext, RangeChangeEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.user.cellview.client.AbstractHasData$RedrawEvent do not have a public getType!")
    private void redraw() {
    }

    public static Observable resize(Widget source) {
        return Observable.create(s -> register(s, source.addHandler(s::onNext, ResizeEvent.getType())));
    }

    public static Observable rowCountChange(Widget source) {
        return Observable.create(s -> register(s, source.addHandler(s::onNext, RowCountChangeEvent.getType())));
    }

    public static Observable rowHover(Widget source) {
        return Observable.create(s -> register(s, source.addHandler(s::onNext, RowHoverEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.user.client.Window$ScrollEvent do not have a public getType!")
    private void scroll() {
    }

    public static Observable scroll(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, ScrollEvent.getType())));
    }

    public static  Observable> selection(Widget source) {
        return Observable.create(s -> register(s, source.addHandler((SelectionHandler) s::onNext, SelectionEvent.getType())));
    }

    public static Observable selectionChange(Widget source) {
        return Observable.create(s -> register(s, source.addHandler(s::onNext, SelectionChangeEvent.getType())));
    }

    public static  Observable> showRange(Widget source) {
        return Observable.create(s -> register(s, source.addHandler((ShowRangeHandler) s::onNext, ShowRangeEvent.getType())));
    }

    public static Observable submit(Widget source) {
        return Observable.create(s -> register(s, source.addHandler(s::onNext, FormPanel.SubmitEvent.getType())));
    }

    public static Observable submitComplete(Widget source) {
        return Observable.create(s -> register(s, source.addHandler(s::onNext, FormPanel.SubmitCompleteEvent.getType())));
    }

    @GwtIncompatible("class com.google.gwt.event.dom.client.TouchEvent do not have a public getType!")
    private void touch() {
    }

    public static Observable touchCancel(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, TouchCancelEvent.getType())));
    }

    public static Observable touchEnd(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, TouchEndEvent.getType())));
    }

    public static Observable touchMove(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, TouchMoveEvent.getType())));
    }

    public static Observable touchStart(Widget source) {
        return Observable.create(s -> register(s, source.addDomHandler(s::onNext, TouchStartEvent.getType())));
    }

    public static  Observable> valueChange(Widget source) {
        return Observable.create(s -> register(s, source.addHandler((ValueChangeHandler) s::onNext, ValueChangeEvent.getType())));
    }
}