docs: function (evtDesc) {
                  if (this._listeners == null) {
                      return;
                  }
                  var nm = '', hasArgs = false;
                  if (typeof(evtDesc) == 'string') {
                      nm = evtDesc;
                  } else {
                      nm = evtDesc.name;
                      hasArgs = true;
                  }
                  // The comparison with null below is important, as an empty string is a valid event description.
                  if (nm == null || this.$events[nm] == null) {
                      this.$logError(this.UNDECLARED_EVENT, [nm, this.$classpath]);
                  } else {
                      // loop on evtName + '*'
                      var evtNames = [nm, '*'], evt = null;
                      var listeners = this._listeners;
                      for (var idx = 0; idx < 2; idx++) {
                          // warning this can be disposed during this call as some events (like 'complete') may be caught
                          // for this purpose also make a copy because a callback could modify this list
                          var lsnList = listeners[evtNames[idx]];
                          if (lsnList) {
                              if (!evt) {
                                  // create the event object if we have an event description object, we use it directly to
                                  // be able to pass back parameters to the function which called $raiseEvent
                                  evt = (hasArgs ? evtDesc : {});
                                  evt.name = nm;
                                  // the src property of the event is now set differently for each listener, because when
                                  // interfaces have events, we do not want the event object to be used to access the
                                  // whole object instead of only the interface
                              }
                              // also make a copy because a callback could modify this list
                              lsnList = lsnList.slice(0);
  
                              var sz = lsnList.length, lsn, src;
                              for (var i = 0; sz > i; i++) {
                                  // call listener
                                  lsn = lsnList[i];
                                  src = lsn.src;
                                  // Check lsn.removed because it is possible that the listener is removed while
                                  // $raiseEvent is running.
                                  // In this case, lsnList still contains the listener, but __removeListeners sets lsn.src
                                  // to null
                                  // Also check that the event is in src.$events in case idx == 1 because when registering
                                  // a listener on '*' from an interface wrapper, the listener must only be called for
                                  // events of the interface (not for all the events of the object).
                                  // The comparison with null below is important, as an empty string is a valid event
                                  // description.
                                  if (!lsn.removed && (idx === 0 || src.$events[nm] != null)) {
                                      // update the source of the event (useful if registering an event from an interface)
                                      evt.src = src;
  
                                      if (lsn.once) {
                                          delete lsn.once;
                                          var rmvCfg = {};
                                          rmvCfg[evt.name] = lsn;
  
                                          // we must remove the listener before calling it (otherwise there can be
                                          // infinite loops in the framework...)
                                          this.$removeListeners(rmvCfg);
                                      }
                                      this.$callback(lsn, evt);
                                  }
                              }
                              // set src to null so that storing the evt object does not grant access to the whole object
                              evt.src = null;
                          }
                      }
                      listeners = lsnList = sz = null;
                  }
              }