Proxy datastore event to child listeners.
487422
@Override
  public void contentChanged(DataStoreEvent e) {
    for(int i = 0; i < listenerList.size(); i++) {
      listenerList.get(i).contentChanged(e);
    }
  }
832406
function onEventHandledEEArr(event){
  var pd = this[proxied],
      p = this;
  
  function onEvent(){
    p.fire(event,arguments);
  }
  
  p[proxiedHandlers][event] = onEvent;
  pd.on(event,onEvent);
}
718682
public void dispatchEvent(Event event, String eventName) {
    int typeInt = Event.getTypeInt(eventName);
    Object[] handlerData = $(element).data(EVENT_DATA);
    for (int i = 0, l = elementEvents.length(); i < l; i++) {
      BindFunction listener = elementEvents.get(i);
      String namespace = JsUtils.prop(event, "namespace");
      boolean matchEV = listener != null && (listener.hasEventType(typeInt) || listener.isTypeOf(eventName));
      boolean matchNS = matchEV && (isNullOrEmpty(namespace) || listener.nameSpace.equals(namespace));
      if (matchEV && matchNS) {
        if (!listener.fire(event, typeInt, eventName, handlerData)) {
          event.stopPropagation();
          event.preventDefault();
        }
      }
    }
  }
265919
private static void callback(long handle) {
        final C4DatabaseObserver obs = REVERSE_LOOKUP_TABLE.get(handle);
        if (obs != null && obs.listener != null) { obs.listener.callback(obs, obs.context); }
    }
220956
function (preEventExtender) {
    if (!preEventExtender || !_.isObject(preEventExtender)) {
      var err = new Error('Please inject a valid event extender object!');
      debug(err);
      throw err;
    }
    if (this.preEventExtenders.indexOf(preEventExtender) < 0) {
      preEventExtender.useCollection(this);
      this.preEventExtenders.push(preEventExtender);
    }
  }
78962
public void trigger(String dataId, InputStream is) {
        List<LoaderListener> listeners = getListeners("");
        //noinspection SynchronizationOnLocalVariableOrMethodParameter
        synchronized (listeners) {
            for (LoaderListener ll : listeners) {
                try {
                    ll.newDataLoaded(dataId, is);
                } catch (Exception e) {
                    LOG.log(Level.SEVERE, "Error calling LoadListener: " + ll, e);
                }
            }
        }
        if (!(dataId==null || dataId.isEmpty())) {
            listeners = getListeners(dataId);
            //noinspection SynchronizationOnLocalVariableOrMethodParameter
            synchronized (listeners) {
                for (LoaderListener ll : listeners) {
                    try {
                        ll.newDataLoaded(dataId, is);
                    } catch (Exception e) {
                        throw new IllegalArgumentException("Failed to load new data: " + ll, e);
                    }
                }
            }
        }
    }
279596
protected final void fireChildrenAdded(BeanContextMembershipEvent event)
	{
		Object listeners[];
		synchronized (bcmListeners)
		{
			listeners = bcmListeners.toArray();
		}
		for (int i = 0; i < listeners.length; i++)
		{
			BeanContextMembershipListener l = (BeanContextMembershipListener) listeners[i];
			l.childrenAdded(event);
		}
	}
124650
public void notifyChildren(String eventName, Object eventData, boolean recurse) {
        notifyChildren(this, eventName, eventData, recurse);
    }
580910
@SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
    public void trigger(String dataId, DataStreamFactory dataStreamFactory) {
        List<LoaderListener> listeners = getListeners("");
        synchronized (listeners) {
            for (LoaderListener ll : listeners) {
                try {
                    ll.newDataLoaded(dataId, dataStreamFactory.getDataStream());
                } catch (Exception e) {
                    LOG.log(Level.SEVERE, "Error calling LoadListener: " + ll, e);
                }
            }
        }
        if (!(Objects.isNull(dataId) || dataId.isEmpty())) {
            listeners = getListeners(dataId);
            synchronized (listeners) {
                for (LoaderListener ll : listeners) {
                    try {
                        ll.newDataLoaded(dataId, dataStreamFactory.getDataStream());
                    } catch (Exception e) {
                        throw new IllegalArgumentException("Failed to load new data: " + ll, e);
                    }
                }
            }
        }
    }
653188
function createListener(db, e, object) {
  function listener(err) {
    if (object.listeners(e).length > 0) {
      object.emit(e, err, db);

      // Emit on all associated db's if available
      for (let i = 0; i < db.s.children.length; i++) {
        db.s.children[i].emit(e, err, db.s.children[i]);
      }
    }
  }
  return listener;
}
657543
function globalEventHandler(event) {
    if (listeners[event.type]) {
      listeners[event.type].forEach(function(currentHandler) {
        currentHandler.call(this, event);
      }, this);
    }
  }
1223182
function listen(query,key,func)
    {
      /* standard message listener */
      if(arguments.length === 2)
      {
        func = key.bind(this);
        key = query;
        if(!_messages[key]) _messages[key] = [];
        _messages[key].push(func);
      }
      else
      {
        func = func.bind(this);
        if(!_scopemessages[query]) _scopemessages[query] = {};
        if(!_scopemessages[query][key]) _scopemessages[query][key] = [];
        _scopemessages[query][key].push(func);
        
        /* if this happens to be a parent component we immediately retrieve the value, if not then callAllSubscribers will fire initial */
        if(document.querySelector('.'+query))
        {
          var scopeMessages = _scopemessages[query][key],
              data = document.querySelector('.'+query).kb_mapper.kb_viewmodel,
              local = data.getLayer(key),
              localKey = key.split('.').pop(),
              val = local[localKey];
          scopeMessages[(scopeMessages.length-1)]({
            key:localKey,
            value:val,
            oldValue:val,
            local:local,
            kbref:data,
            onChange:false,
            initial:true
          });
        }
      }
      return this;
    }
1086051
function (event) {
        var trigger = event.target;
        var probe = function (type) {
            if ((type !== event.type) || (1 !== trigger.nodeType)) {
                return false;
            }

            var attribute = ['data', this.id, type].join('-');
            var key = trigger.getAttribute(attribute);

            if (key && this.registry.hasOwnProperty(key)) {
                this.registry[key](event, trigger);
                return true;
            }

            if (-1 !== this.bubble.indexOf(type)) {
                while (this.documentElement !== trigger) {
                    trigger = trigger.parentNode;

                    if (probe(type)) {
                        break;
                    }
                }
            }

            return false;
        }.bind(this);

        this.events.forEach(probe);
    }
45262
def _register_event_listeners(self, cls):
        
        event.listen(cls, 'after_insert', self._new_listener)
        event.listen(cls, 'after_update', self._update_listener)
        event.listen(cls, 'after_delete', self._delete_listener)
1226437
private void dispatchLegacyEventIfNeeded(ManagerEvent event)
    {
        if (event instanceof DialBeginEvent)
        {
            DialEvent legacyEvent = new DialEvent((DialBeginEvent) event);
            dispatchEvent(legacyEvent);
        }
    }
917403
function(events){
    this._delegateDOMEvents(events);
    Marionette.bindEntityEvents(this, this.model, Marionette.getOption(this, "modelEvents"));
    Marionette.bindEntityEvents(this, this.collection, Marionette.getOption(this, "collectionEvents"));
  }
611923
function(callback, opt_this) {
      function visit(ec) {
        callback.call(opt_this, ec);
        ec.iterateAllChildEventContainers(visit);
      }
      visit(this);
    }