com.google.gwt.event.shared.GwtEvent Java Examples

protected void checkSelectionHandler(MaterialPopupMenu popupMenu) {
    final boolean[] isSelectionFired = {false};
    popupMenu.setEnabled(true);
    popupMenu.addSelectionHandler(selectionEvent -> isSelectionFired[0] = true);
    popupMenu.fireEvent(new GwtEvent<SelectionHandler<?>>() {
        @Override
        public Type<SelectionHandler<?>> getAssociatedType() {
            return SelectionEvent.getType();
        }

        @Override
        protected void dispatch(SelectionHandler<?> eventHandler) {
            eventHandler.onSelection(null);
        }
    });
    assertTrue(isSelectionFired[0]);
}
 

public void testSelectionEvent() {
    MaterialNavSection widget = new MaterialNavSection();

    final boolean[] isSelectionEventFired = {false};
    widget.addSelectionHandler(selectionEvent -> isSelectionEventFired[0] = true);
    widget.fireEvent(new GwtEvent<SelectionHandler<?>>() {
        @Override
        public Type<SelectionHandler<?>> getAssociatedType() {
            return SelectionEvent.getType();
        }

        @Override
        protected void dispatch(SelectionHandler eventHandler) {
            eventHandler.onSelection(null);
        }
    });

    assertTrue(isSelectionEventFired[0]);
}
 

@Override
public void onKeyDown(final KeyDownEvent event) {

	if (event.getNativeKeyCode() == keyCode) {				
		actionButton.fireEvent( new GwtEvent<ClickHandler>() {
	        @Override
	        public com.google.gwt.event.shared.GwtEvent.Type<ClickHandler> getAssociatedType() {
	        	return ClickEvent.getType();
	        }
	        @Override
	        protected void dispatch(final ClickHandler handler) {
	            handler.onClick(null);
	        }
	   });
	}
}
 

public void fireDropActiveEvent() {
    target.fireEvent(new GwtEvent<DropActivateEvent.DropActivateHandler>() {
        @Override
        public Type<DropActivateEvent.DropActivateHandler> getAssociatedType() {
            return DropActivateEvent.TYPE;
        }

        @Override
        protected void dispatch(DropActivateEvent.DropActivateHandler handler) {
            handler.onDropActivate(new DropActivateEvent());
        }
    });
}
 

@Override
public void fireEvent(GwtEvent<?> event) {
    try {
        if (!GWT.isProdMode()) {
            GWT.log("Firing " + event.toDebugString()); 
        }
        super.fireEvent(event);
    } catch (Exception e) {
        ExceptionHandler.handleUnexpectedException(e);
    }
}
 

public void testDynamicTab() {
    // given
    MaterialTab tab = getWidget();

    // when / then
    // This will dynamically add new Tab Item
    MaterialTabItem item = newTabItem(tab, row, 1);

    boolean[] selectionEventFired = new boolean[]{false};
    tab.addSelectionHandler(selectionEvent -> selectionEventFired[0] = true);

    // This will trigger the selection event of the tab once tab item fired MouseDownEvent
    item.fireEvent(new GwtEvent<MouseDownHandler>() {
        @Override
        public Type<MouseDownHandler> getAssociatedType() {
            return MouseDownEvent.getType();
        }

        @Override
        protected void dispatch(MouseDownHandler eventHandler) {
            eventHandler.onMouseDown(null);
        }
    });

    // Expected : true
    assertTrue(selectionEventFired[0]);
}
 

@Override
public void fireEvent(GwtEvent<?> event) {
    if (event == null) {
        fireEvent();
        return ;
    }
    handlerManager.fireEvent(event);
}
 

public void fireEvent(GwtEvent<?> event, EventCallback callback) {
    try {
        if (!GWT.isProdMode()) {
            GWT.log("Firing " + event.toDebugString()); 
        }
        super.fireEvent(event);
        
        if (!GWT.isProdMode()) {
            GWT.log("    Event fired, calling callback"); 
        }
        callback.onEventFired();
    } catch (Exception e) {
        ExceptionHandler.handleUnexpectedException(e);
    }
}
 

public void fireDropEvent(JQueryElement relatedTarget) {
    target.fireEvent(new GwtEvent<DropEvent.DropHandler>() {
        @Override
        public Type<DropEvent.DropHandler> getAssociatedType() {
            return DropEvent.TYPE;
        }

        @Override
        protected void dispatch(DropEvent.DropHandler handler) {
            handler.onDrop(new DropEvent(relatedTarget));
        }
    });
}
 

public void fireDropDeactivateEvent() {
    target.fireEvent(new GwtEvent<DropDeactivateEvent.DropDeactivateHandler>() {
        @Override
        public Type<DropDeactivateEvent.DropDeactivateHandler> getAssociatedType() {
            return DropDeactivateEvent.TYPE;
        }

        @Override
        protected void dispatch(DropDeactivateEvent.DropDeactivateHandler handler) {
            handler.onDropDeactivate(new DropDeactivateEvent());
        }
    });
}
 

public void fireDragStartEvent() {
    target.fireEvent(new GwtEvent<DragStartEvent.DragStartHandler>() {
        @Override
        public Type<DragStartEvent.DragStartHandler> getAssociatedType() {
            return DragStartEvent.TYPE;
        }

        @Override
        public void dispatch(DragStartEvent.DragStartHandler handler) {
            handler.onDragStart(new DragStartEvent());
        }
    });
}
 

public void fireDragMoveEvent() {
    target.fireEvent(new GwtEvent<DragMoveEvent.DragMoveHandler>() {
        @Override
        public Type<DragMoveEvent.DragMoveHandler> getAssociatedType() {
            return DragMoveEvent.TYPE;
        }

        @Override
        public void dispatch(DragMoveEvent.DragMoveHandler handler) {
            handler.onDragMove(new DragMoveEvent());
        }
    });
}
 

public void fireDragEndEvent() {
    target.fireEvent(new GwtEvent<DragEndEvent.DragEndHandler>() {
        @Override
        public Type<DragEndEvent.DragEndHandler> getAssociatedType() {
            return DragEndEvent.TYPE;
        }

        @Override
        public void dispatch(DragEndEvent.DragEndHandler handler) {
            handler.onDragEnd(new DragEndEvent());
        }
    });
}
 

public void fireDragEnterEvent(JQueryElement relatedTarget) {
    target.fireEvent(new GwtEvent<DragEnterEvent.DragEnterHandler>() {
        @Override
        public Type<DragEnterEvent.DragEnterHandler> getAssociatedType() {
            return DragEnterEvent.TYPE;
        }

        @Override
        protected void dispatch(DragEnterEvent.DragEnterHandler handler) {
            handler.onDragEnter(new DragEnterEvent(relatedTarget));
        }
    });
}
 

public void fireDragLeaveEvent(JQueryElement relatedTarget) {
    target.fireEvent(new GwtEvent<DragLeaveEvent.DragLeaveHandler>() {
        @Override
        public Type<DragLeaveEvent.DragLeaveHandler> getAssociatedType() {
            return DragLeaveEvent.TYPE;
        }

        @Override
        protected void dispatch(DragLeaveEvent.DragLeaveHandler handler) {
            handler.onDragLeave(new DragLeaveEvent(relatedTarget));
        }
    });
}
 

public void fireEvent(GwtEvent<?> event) {
  handlerManager.fireEvent(event);
}
 

@Override
public com.google.gwt.event.shared.GwtEvent.Type<WaveCreationEventHandler> getAssociatedType() {
  return TYPE;
}
 

@Override
public void fireEvent(GwtEvent<?> event) {
	EventBus.get().fireEvent(event);
}
 

@Override
public void fireEvent(GwtEvent<?> event) {
	if (this.handlerManager != null) {
		this.handlerManager.fireEvent(event);
	}
}
 

@Override
public GwtEvent.Type<Handler> getAssociatedType() {
	return LiveValueChangeEvent.TYPE;
}
 

@Override
public GwtEvent.Type<Handler> getAssociatedType() {
	return CollapseEvent.TYPE;
}
 

@Override
public void fireEvent(GwtEvent<?> event) {
  handlerManger.fireEvent(event);
}
 

public static GwtEvent.Type<Handler> getType()
{
  return TYPE;
}
 

@Override
public GwtEvent.Type<Handler> getAssociatedType()
{
  return CachedEvent.getType();
}
 

public static GwtEvent.Type<Handler> getType()
{
  return TYPE;
}
 

@Override
public GwtEvent.Type<Handler> getAssociatedType()
{
  return ProgressEvent.getType();
}
 

public static GwtEvent.Type<Handler> getType()
{
  return TYPE;
}
 

public static GwtEvent.Type<Handler> getType()
{
  return TYPE;
}
 

@Override
public GwtEvent.Type<Handler> getAssociatedType()
{
  return ObsoleteEvent.getType();
}
 

@Override
public com.google.gwt.event.shared.GwtEvent.Type<DebugMessageEventHandler> getAssociatedType() {
  return TYPE;
}