Fires an {@link JQMTabsEvent} on all registered handlers in the handler source.

@param <S> The handler source type
@param source - the source of the handlers
332637
public static <S extends HasAttachHandlers> void fire(S source, TabsState tabsState,
            Widget newTabHeader, Widget oldTabHeader, Widget newTabContent, Widget oldTabContent) {
        if (TYPE != null) {
            JQMTabsEvent event = new JQMTabsEvent(tabsState, newTabHeader, oldTabHeader,
                                                  newTabContent, oldTabContent);
            source.fireEvent(event);
        }
    }
1286327
public static <S extends HasAttachHandlers> void fire(S source, DisplayChangeData data) {
        if (TYPE != null) {
            JQMCalBoxEvent event = new JQMCalBoxEvent(data);
            source.fireEvent(event);
        }
    }
833624
public static <T> void fire(final HasItemAddedOnInitHandlers<T> source, T item) {
        if (TYPE != null) {
            ItemAddedOnInitEvent<T> event = new ItemAddedOnInitEvent<T>(item);
            source.fireEvent(event);
        }
    }
130029
public static void fire(final HasSummernoteChangeHandlers source) {
        if (TYPE != null) {
            SummernoteChangeEvent event = new SummernoteChangeEvent();
            source.fireEvent(event);
        }
    }
520650
public static void fire(final HasRefreshedHandlers source) {
        if (TYPE != null) {
            RefreshedEvent event = new RefreshedEvent();
            source.fireEvent(event);
        }
    }
930101
public void handleDebugEvents(DebugEvent[] events)
	{
		if (view == null)
		{
			return;
		}

		for (int i = 0; i < events.length; ++i)
		{
			DebugEvent event = events[i];

			append(new VdmDebugLogItem(Messages.ItemType_Event, getDebugEventKind(event)
					+ " from " + event.getSource().getClass().getName()));//$NON-NLS-1$

			if (event.getKind() == DebugEvent.CREATE)
			{
				handleCreateEvent(event);
			} else if (event.getKind() == DebugEvent.MODEL_SPECIFIC
					&& event.getDetail() == ExtendedDebugEventDetails.DGBP_NEW_CONNECTION)
			{
				if (event.getSource() instanceof IDbgpDebugingEngine)
				{
					((IDbgpDebugingEngine) event.getSource()).addRawListener(this);
				}
			} else if (event.getKind() == DebugEvent.TERMINATE)
			{
				handleTerminateEvent(event);
			}
		}
	}
946349
public static <S extends HasAttachHandlers> void fire(S source, CollapsibleState collapsibleState,
                                                          Element eventTarget) {
        if (TYPE != null) {
            JQMCollapsibleEvent event = new JQMCollapsibleEvent(collapsibleState, eventTarget);
            source.fireEvent(event);
        }
    }
1017260
@Override
    public <T> void fire(T event, NonManagedObserver<T> nonManagedObserver) {
        Validate.notNull(event, "Event must be specified");

        runtimeLogger.debug(event, true);
        // we start fresh pr new event
        handledThrowables.get().clear();

        List<ObserverMethod> observers = resolveObservers(event.getClass());
        List<ObserverMethod> interceptorObservers = resolveInterceptorObservers(event.getClass());

        ApplicationContext context = (ApplicationContext) getScopedContext(ApplicationScoped.class);
        // We need to know if we were to the one to Activate it to avoid:
        // * nested ApplicationContexts
        // * ending the scope to soon (to low in the stack)
        boolean activatedApplicationContext = false;
        try {
            if (!context.isActive()) {
                context.activate();
                activatedApplicationContext = true;
            }
            new EventContextImpl<T>(this, interceptorObservers, observers, nonManagedObserver, event,
                runtimeLogger).proceed();
        } catch (Exception e) {
            Throwable fireException = e;
            if (fireException instanceof InvocationException) {
                fireException = fireException.getCause();
            }
            if (handledThrowables.get().contains(fireException.getClass())) {
                UncheckedThrow.throwUnchecked(fireException);
            } else {
                fireException(fireException);
            }
        } finally {
            runtimeLogger.debug(event, false);
            if (activatedApplicationContext && context.isActive()) {
                context.deactivate();
            }
        }
    }
678134
public static void fire(final HasSummernoteBlurHandlers source) {
        if (TYPE != null) {
            SummernoteBlurEvent event = new SummernoteBlurEvent();
            source.fireEvent(event);
        }
    }
1031884
public static void fire(final HasSummernoteEnterHandlers source) {
        if (TYPE != null) {
            SummernoteEnterEvent event = new SummernoteEnterEvent();
            source.fireEvent(event);
        }
    }
583334
public static void fire(final HasSlideDisabledHandlers source) {
        if (TYPE != null) {
            SlideDisabledEvent event = new SlideDisabledEvent();
            source.fireEvent(event);
        }
    }
734903
@Override
    public final void onEvent(final StoreEvent<T> event, final long sequence, final boolean endOfBatch)
            throws Exception {
        try {
            handle(event, sequence, endOfBatch);
        } finally {
            event.reset();
        }
    }
1029427
public void fireEvent(final Event<?> event)
    {
        Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand() {
            @Override
            public void execute() {
                bus.fireEventFromSource(event, dialog.getInterfaceModel().getId());
            }
        });

    }
886226
public static void fire(final HasSlideEnabledHandlers source) {
        if (TYPE != null) {
            SlideEnabledEvent event = new SlideEnabledEvent();
            source.fireEvent(event);
        }
    }
529029
@Async
    public void fireEventAsync(Object publisher, FireAfterTransactionAsynchronous events) throws Exception {
        for (int i = 0; i < events.events().length; i++) {
            Class<? extends EventObject> event = events.events()[i];
            if (RootApplicationEvent.class.isAssignableFrom(event)) {
                LOGGER.debug("Sending event: [{}]", event);
                ctx.publishEvent((RootApplicationEvent) event.getConstructor(Object.class).newInstance(publisher));
            }
        }
    }
227115
@Override
    public void onEvent(Object event, long sequence, boolean endOfBatch) throws Exception {
        if (event == null) {
            return;
        }
        handleEvent(event, endOfBatch);
    }
914824
public void fireEventListeners(EntityMetadata metadata, Object entity, Class<?> event)
    {

        // handle external listeners first
        List<? extends CallbackMethod> callBackMethods = metadata.getCallbackMethods(event);

        if (null != callBackMethods && !callBackMethods.isEmpty() && null != entity)
        {
            log.debug("Callback >> " + event.getSimpleName() + " on " + metadata.getEntityClazz().getName());
            for (CallbackMethod callback : callBackMethods)
            {
                log.debug("Firing >> " + callback);

                callback.invoke(entity);

            }
        }
    }