Invokes callbacks on all subscribers of this and parent events.

@param eventName Name of the event.
@param eventData The associated event data.
324131
public void invokeCallbacks(String eventName, T eventData) {
        String name = eventName;
        
        while (!StringUtils.isEmpty(name)) {
            Iterable<IGenericEvent<T>> subscribers = getSubscribers(name);
            
            if (subscribers != null) {
                for (IGenericEvent<T> subscriber : subscribers) {
                    try {
                        if (log.isDebugEnabled()) {
                            log.debug(String.format("Firing local Event[name=%s,data=%s]", eventName, eventData));
                        }
                        subscriber.eventCallback(eventName, eventData);
                    } catch (Throwable e) {
                        log.error("Error during local event callback.", e);
                    }
                }
            }
            
            name = stripLevel(name);
        }
    }
103362
public void handleData(String data) {
		if (data == null) return;
		text = data;
		sendEvent(new TextInputEvent(this.user, getPayload(), data));
		if (handler != null)
			handler.onType(data);
	}
490491
public void subscribeToEvent(EventListener eventListener, Class<? extends AbstractTaskEvent> eventType) {
		this.outputGate.subscribeToEvent(eventListener, eventType);
	}
520157
function(eventStr, callback) {
    if (!this.events[eventStr]) {
      this.events[eventStr] = [];
    }

    this.events[eventStr].push(callback);
  }
1076279
private void doSubscribe(boolean subscribe) {
        for (String eventName : eventNames) {
            if (subscribe) {
                eventManager.subscribe(eventName, this);
            } else {
                eventManager.unsubscribe(eventName, this);
            }
        }
    }
1157215
public void handleData(String data) {
		value = Double.valueOf(data);
		sendEvent(new SlideEvent(this.user, getPayload(), value));
		if (handler != null)
			handler.slide(value);
	}
464400
protected final void firePropertyDataChanged(Collection<? extends D> oldData, Collection<? extends D> newData) {
		firePropertyDataChanged(new TreeDataEvent(this, oldData, newData, this.data));
	}
867039
function (eventName, callback) {

                // do nothing if no section is defined (partial refresh usecase)
                if (!this._currentSection) {
                    return;
                }

                var delegate = ariaUtilsDelegate;

                // Fallback mechanism for event that can not be delegated
                if (!delegate.isDelegated(eventName)) {
                    var delegateId = delegate.add(callback);
                    this._currentSection.delegateIds.push(delegateId);
                    this.write(delegate.getFallbackMarkup(eventName, delegateId, true));
                    return;
                }

                // transform callback description into a new callback that will be use by the function doing dispatch
                callback = new aria.utils.Callback(callback);
                this._currentSection.delegateCallbacks.push(callback);

                if (!this._delegateMap) {
                    this._delegateMap = {};
                }

                this._delegateMap[eventName] = callback;

            }
1078611
@Override
  public void addUpdateListener( AsyncCallback<T> callback )
  {
    DataSubscription subscription = new DataSubscription( RTDataEvents.updated, tableName, createCallback( callback ) );
    addEventListener( subscription );
  }
1321757
@Override
    public void subscribeRemoteEvent(String eventName, boolean subscribe) {
        String channelName = EventUtil.getChannelName(eventName);
        
        if (subscribe) {
            consumer.subscribe(channelName, this);
        } else {
            consumer.unsubscribe(channelName, this);
        }
    }
979305
function(eventName, selector, callback) {
        if (!isString(selector)) {
            callback = selector;
            selector = '';
        }

        if (callback) {
            var events = this.events[eventName];
            if (events) {
                events = events[selector];
                if (events) {
                    for (var i = 0; i < events.length; i++) {
                        if (events[i] === callback) {
                            events.splice(i, 1);
                            i--;
                        }
                    }
                }
            }
        } else {
            this.events[eventName][selector] = [];
        }
    }
320209
public void dispatch_event(final EventData eventData) {
        final TangoDataReady tangoDataReady = this;
        if (EventUtil.graphicAvailable()) {
                //   Causes doRun.run() to be executed asynchronously
                //      on the AWT event dispatching thread.
            Runnable do_work_later = new Runnable() {
                public void run() {
                    fireTangoDataReadyEvent(tangoDataReady, eventData);
                }
            };
            SwingUtilities.invokeLater(do_work_later);
        }
        else
            fireTangoDataReadyEvent(tangoDataReady, eventData);
    }
1297859
@SuppressWarnings({"unused", "WeakerAccess"})
    public void pushEvent(String eventName) {
        if (eventName == null || eventName.trim().equals(""))
            return;

        pushEvent(eventName, null);
    }
611203
public void addEvent(String eventType, Serializable eventData) {
        @SuppressWarnings("unchecked")
        Queue<ScoreEvent> eventsQueue = getFromMap(SCORE_EVENTS_QUEUE);
        if (eventsQueue == null) {
            eventsQueue = new ArrayDeque<>();
            contextMap.put(SCORE_EVENTS_QUEUE, (ArrayDeque) eventsQueue);
        }
        eventsQueue.add(new ScoreEvent(eventType, getLanguageName(), eventData, getMetaData()));
    }
1041630
private void fireEvent(EventName eventName) {
        this.returnCode = eventName.getEventIdentifier().getParms();
        switch (eventName.getEventIdentifier().intValue()) {
            case MgcpEvent.REPORT_ON_COMPLETION :
                try {
                    fsm.signal(SIGNAL_PLAY_COMPLETED);
                } catch (UnknownTransitionException e) {
                    e.printStackTrace();
                }
                break;
            case MgcpEvent.REPORT_FAILURE :
                try {
                    fsm.signal("FAILURE");
                } catch (UnknownTransitionException e) {
                    e.printStackTrace();
                }
                break;            
        }
        
    }
866449
public void handleData(String data) {
		try {
			sendEvent(new ClickEvent(this.user, getPayload()));
			if (clickHandler != null)
				clickHandler.clicked();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
1286998
@Override
    public void fireRemoteEvent(String eventName, Serializable eventData, Recipient... recipients) {
        Message message = new EventMessage(eventName, eventData);
        producer.publish(EventUtil.getChannelName(eventName), message, recipients);
    }