com.vaadin.shared.Registration Java Examples

private void configureSessionStore() {
    final Registration sessionInitListenerReg = this.service.addSessionInitListener(event -> {
        MessageConsumer<String> consumer = sessionExpiredHandler(vertx, msg ->
            Optional.of(event.getSession().getSession())
                .filter(session -> msg.body().equals(session.getId()))
                .ifPresent(WrappedSession::invalidate));
        AtomicReference<Registration> sessionDestroyListenerUnregister = new AtomicReference<>();
        sessionDestroyListenerUnregister.set(
            event.getService().addSessionDestroyListener(ev2 -> {
                consumer.unregister();
                sessionDestroyListenerUnregister.get().remove();
            })
        );

    });
    this.service.addServiceDestroyListener(event -> sessionInitListenerReg.remove());
}
 

public Registration addFieldListener(FieldValueChangeListener<T> listener) {
    if (fieldValueChangeListener == null) {
        fieldValueChangeListener = ((CubaTextField) field).addValueChangeListener(event -> {
            String text = event.getValue();

            if (!suppressTextChangeListener &&
                    !Objects.equals(getStringRepresentation(), text)) {
                suppressTextChangeListener = true;

                FieldValueChangeEvent<T> e = new FieldValueChangeEvent<>(CubaPickerField.this, text, getValue());
                fireEvent(e);

                suppressTextChangeListener = false;

                // update text representation manually
                if (field instanceof TextField) {
                    updateTextRepresentation();
                }
            }
        });
    }

    addListener(FieldValueChangeEvent.class, listener, FIELD_VALUE_CHANGE_METHOD);

    return fieldValueChangeListener;
}
 

private void setResolution(org.tltv.gantt.client.shared.Resolution resolution) {
    resolutionValueChangeRegistration.ifPresent(Registration::remove);
    try {
        reso.setValue(resolution);
    } finally {
        resolutionValueChangeRegistration = Optional.of(reso.addValueChangeListener(resolutionValueChangeListener));
    }
}
 

@Override
public Registration addShortcutListener(ShortcutListener shortcut) {
    if (shortcutActionManager == null) {
        shortcutActionManager = new ShortcutActionManager(this);
    }

    shortcutActionManager.addAction(shortcut);
    return () -> getActionManager().removeAction(shortcut);
}
 

@Override
public Registration addShortcutListener(ShortcutListener shortcut) {
    if (shortcutActionManager == null) {
        shortcutActionManager = new ShortcutActionManager(this);
    }

    shortcutActionManager.addAction(shortcut);
    return () -> getActionManager().removeAction(shortcut);
}
 

@Override
public Registration addFocusListener(FocusListener listener) {
       Registration registration = addListener(FocusEvent.EVENT_ID, FocusEvent.class, listener,
               FocusListener.focusMethod);
       getState().listenToFocusChanges = true;
       return registration;
   }
 

@Override
public Registration addBlurListener(BlurListener listener) {
       Registration registration = addListener(BlurEvent.EVENT_ID, BlurEvent.class, listener,
               BlurListener.blurMethod);
       getState().listenToFocusChanges = true;
       return registration;
   }
 

@Override
public Registration setHandler(CalendarComponentEvents.ForwardHandler listener) {
    return setHandler(CalendarComponentEvents.ForwardEvent.EVENT_ID, CalendarComponentEvents.ForwardEvent.class, listener,
            CalendarComponentEvents.ForwardHandler.forwardMethod);
}
 

private void syncLocale() {
    startDateValueChangeRegistration.ifPresent(Registration::remove);
    endDateValueChangeRegistration.ifPresent(Registration::remove);
    try {
        start.setLocale(gantt.getLocale());
        start.setValue(gantt.getStartLocalDateTime());
        end.setLocale(gantt.getLocale());
        end.setValue(gantt.getEndLocalDateTime());
    } finally {
        startDateValueChangeRegistration = Optional.of(start.addValueChangeListener(startDateValueChangeListener));
        endDateValueChangeRegistration = Optional.of(end.addValueChangeListener(endDateValueChangeListener));
    }
    dateFormat = new SimpleDateFormat("MMM dd HH:mm:ss zzz yyyy", gantt.getLocale());
}
 

@Override
public Registration addComponentAttachListener(ComponentAttachListener listener) {
    return addListener(ComponentAttachEvent.class, listener,
            ComponentAttachListener.attachMethod);
}
 

@Override
public Registration addValueChangeListener(ValueChangeListener<T> listener) {
    return getFieldInternal().addValueChangeListener(listener);
}
 

public Registration addBeforeSaveListener(CubaEditorBeforeSaveListener<T> listener) {
    return eventRouter.addListener(CubaEditorBeforeSaveEvent.class, listener,
            ReflectTools.getMethod(CubaEditorBeforeSaveListener.class));
}
 

@Override
public Registration addShortcutListener(ShortcutListener listener) {
    getActionManager().addAction(listener);
    return () -> getActionManager().removeAction(listener);
}
 

@Override
public Registration addFocusListener(FocusListener listener) {
    return tf.addFocusListener(listener);
}
 

@Override
public Registration addShortcutListener(ShortcutListener listener) {
    getActionManager().addAction(listener);
    return () -> getActionManager().removeAction(listener);
}
 

@Override
public Registration addValueChangeListener(ValueChangeListener<T> listener) {
    return getFieldInternal().addValueChangeListener(listener);
}
 

public Registration addFocusListener(FocusListener listener) {
    return textfield.addFocusListener(listener);
}
 

@Override
public Registration addComponentDetachListener(ComponentDetachListener listener) {
    return addListener(ComponentDetachEvent.class, listener,
            ComponentDetachListener.detachMethod);
}
 

@Override
public Registration addBlurListener(BlurListener listener) {
    return tf.addBlurListener(listener);
}
 

public Registration addBlurListener(BlurListener listener) {
    return textfield.addBlurListener(listener);
}
 

@Override
public Registration addShortcutListener(ShortcutListener listener) {
    getActionManager().addAction(listener);
    return () -> getActionManager().removeAction(listener);
}
 

@Override
public Registration addBlurListener(final BlurListener listener) {
    return addListener(BlurEvent.EVENT_ID, BlurEvent.class, listener, BlurListener.blurMethod);
}
 

@Override
public Registration addFocusListener(final FocusListener listener) {
    return addListener(FocusEvent.EVENT_ID, FocusEvent.class, listener, FocusListener.focusMethod);
}
 

@Override
public Registration addValueChangeListener(final HasValue.ValueChangeListener<Set<T>> listener) {
    return addSelectionListener(event -> listener
                                .valueChange(new ValueChangeEvent<>(event.getComponent(), this, event.getOldValue(), event.isUserOriginated())));
}
 

public Registration addToggleListener(SliderPanelToggleListener listener) {
    return this.addListener(SliderPanelToggleEvent.class, listener, SliderPanelToggleListener.ELEMENT_TOGGLED_METHOD);
}
 

@Override
public Registration addShortcutListener(ShortcutListener listener) {
    getActionManager().addAction(listener);
    return () -> getActionManager().removeAction(listener);
}
 

/**
 * Set the handler for the given type information. Mirrors
 * {@link #addListener(String, Class, Object, Method) addListener} from
 * AbstractComponent
 *
 * @param eventId
 *            A unique id for the event. Usually one of
 *            {@link CalendarEventId}
 * @param eventType
 *            The class of the event, most likely a subclass of
 *            {@link CalendarComponentEvent}
 * @param listener
 *            A listener that listens to the given event
 * @param listenerMethod
 *            The method on the lister to call when the event is triggered
 * @return handler registration
 */
protected Registration setHandler(String eventId, Class<?> eventType, EventListener listener, Method listenerMethod) {

    if (handlers.get(eventId) != null) {
        handlers.get(eventId).remove();
        handlers.remove(eventId);
    }

    if (listener != null) {
        Registration registration = addListener(eventId, eventType, listener, listenerMethod);
        handlers.put(eventId, registration);
        return registration;
    }

    return null;
}
 

@Override
public Registration setHandler(CalendarComponentEvents.BackwardHandler listener) {
    return setHandler(CalendarComponentEvents.BackwardEvent.EVENT_ID,
            CalendarComponentEvents.BackwardEvent.class, listener,
            CalendarComponentEvents.BackwardHandler.backwardMethod);
}
 

@Override
public Registration setHandler(CalendarComponentEvents.DateClickHandler listener) {
    return setHandler(CalendarComponentEvents.DateClickEvent.EVENT_ID,
            CalendarComponentEvents.DateClickEvent.class, listener,
            CalendarComponentEvents.DateClickHandler.dateClickMethod);
}
 

@Override
public Registration setHandler(CalendarComponentEvents.ItemClickHandler listener) {
    return setHandler(CalendarComponentEvents.ItemClickEvent.EVENT_ID,
            CalendarComponentEvents.ItemClickEvent.class, listener,
            CalendarComponentEvents.ItemClickHandler.itemClickMethod);
}