/** * Checks if there is at least one listener registered for the given event * type for this component. * * @param eventType * the component event type * @return <code>true</code> if at least one listener is registered, * <code>false</code> otherwise */ @SuppressWarnings("rawtypes") protected boolean hasListener(Class<? extends ComponentEvent> eventType) { return eventBus != null && eventBus.hasListener(eventType); }
/** * Gets the event bus for this component. * <p> * This method will create the event bus if it has not yet been created. * * @return the event bus for this component */ protected ComponentEventBus getEventBus() { if (eventBus == null) { eventBus = new ComponentEventBus(this); } return eventBus; }
/** * Adds a listener for the given event type. * * @param <T> * the event type * @param eventType * the event type for which to call the listener * @param listener * the listener to call when the event occurs * @return an object which can be used to remove the event listener */ public <T extends ComponentEvent<?>> Registration addListener( Class<T> eventType, ComponentEventListener<T> listener) { return addListenerInternal(eventType, listener, null); }
/** * Handles a DOM event of the given type by firing a corresponding component * event. * * @param eventType * the component event type which should be fired * @param domEvent * the DOM event * @param wrapper * the component event listener to call when the DOM event is * fired */ private <T extends ComponentEvent<?>> void handleDomEvent( Class<T> eventType, DomEvent domEvent, ListenerWrapper<T> wrapper) { T event = createEventForDomEvent(eventType, domEvent, component); fireEventForListener(event, wrapper); }
/** * Dispatches the event to all listeners registered for the event type. * * @param event * the event to fire */ @SuppressWarnings({ "unchecked", "rawtypes" }) public void fireEvent(ComponentEvent event) { Class<? extends ComponentEvent> eventType = event.getClass(); if (!hasListener(eventType)) { return; } // Copy the list to avoid ConcurrentModificationException for (ListenerWrapper wrapper : new ArrayList<>( componentEventData.get(event.getClass()))) { fireEventForListener(event, wrapper); } }
private <T extends ComponentEvent<?>> Registration addListenerInternal( Class<T> eventType, ComponentEventListener<T> listener, Consumer<DomListenerRegistration> domListenerConsumer) { ListenerWrapper<T> wrapper = new ListenerWrapper<>(listener); boolean isDomEvent = addDomTriggerIfNeeded(eventType, wrapper); if (domListenerConsumer != null) { if (!isDomEvent) { throw new IllegalArgumentException(String.format( "DomListenerConsumer can be used only for DOM events. The given event type %s is not annotated with %s.", eventType.getSimpleName(), DomEvent.class.getSimpleName())); } domListenerConsumer.accept(wrapper.domRegistration); } componentEventData.computeIfAbsent(eventType, t -> new ArrayList<>(1)) .add(wrapper); return () -> removeListener(eventType, wrapper); }
/** * Adds a listener for an event of the given type. * * @param <T> * the component event type * @param eventType * the component event type, not <code>null</code> * @param listener * the listener to add, not <code>null</code> * @return a handle that can be used for removing the listener */ protected <T extends ComponentEvent<?>> Registration addListener( Class<T> eventType, ComponentEventListener<T> listener) { return getEventBus().addListener(eventType, listener); }
/** * Adds a DOM listener for the given component event if it is mapped to a * DOM event. * * @param eventType * the type of event * @param wrapper * the listener that is being registered * @return {@code true} if a DOM-trigger was added (the event is annotated * with {@link DomEvent}), {@code false} otherwise. */ private <T extends ComponentEvent<?>> boolean addDomTriggerIfNeeded( Class<T> eventType, ListenerWrapper<T> wrapper) { return AnnotationReader .getAnnotationFor(eventType, com.vaadin.flow.component.DomEvent.class) .map(annotation -> { addDomTrigger(eventType, annotation, wrapper); return true; }).orElse(false); }
/** * Dispatches the event to all listeners registered for the event type. * * @see ComponentUtil#fireEvent(Component, ComponentEvent) * * @param componentEvent * the event to fire */ protected void fireEvent(ComponentEvent<?> componentEvent) { if (hasListener(componentEvent.getClass())) { getEventBus().fireEvent(componentEvent); } }
List<Object> eventData = createEventDataObjects(domEvent, eventType); Object[] params = new Object[eventData.size() + 2];
ComponentEventListener<T> listener, Consumer<DomListenerRegistration> domListenerConsumer) { return component.getEventBus().addListener(eventType, listener, domListenerConsumer);
@Override public boolean listenProgress() { return upload.getEventBus().hasListener(ProgressUpdateEvent.class); }
Objects.requireNonNull(domListenerConsumer, "DOM listener consumer cannot be null"); return addListenerInternal(eventType, listener, domListenerConsumer);