docs: function (evt) {
              if (!this.__delegateMapping) {
                  // there is no event listener
                  if (evt.$DomEvent) {
                      evt.$dispose();
                  }
                  return;
              }
  
              if (!this.__stackCache) {
                  this.__stackCache = {};
              }
  
              var depth = this.depth, stack = [], cacheStack, expandoValue, target;
              var stopper = Aria.$window.document.body;
  
              evt = this.__wrapEvent(evt);
  
              // Retrieve DOM corresponding to a widget
              target = evt.target;
  
              // flag to distinguish elements defined through aria templates
              var ATflag = false; // stays false if the target has not been generated with AT
  
              // retrieve dom that might contain delegation
              while (depth && target && target != stopper) {
                  if (target.attributes) {
                      expandoValue = target.attributes[this.delegateExpando];
                      if (expandoValue) {
                          ATflag = true;
                          expandoValue = expandoValue.value;
                          cacheStack = this.__stackCache[expandoValue];
  
                          // search the cache for existing hierachy
                          if (cacheStack) {
                              // find value -> merge with existing hierarchy
                              stack = stack.concat(cacheStack);
                              break;
                          } else {
                              stack.push({
                                  expandoValue : expandoValue,
                                  target : target
                              });
                          }
                      }
                  }
                  target = target.parentNode;
                  depth--;
              }
  
              var callback, delegateConfig;
  
              // will be used to track changes
              var nested = false;
              if (this._changed) {
                  nested = true;
              } else {
                  this._changed = {};
              }
  
              for (var i = 0, l = stack.length; i < l; i++) {
                  delegateConfig = stack[i];
                  expandoValue = delegateConfig.expandoValue;
                  target = delegateConfig.target;
  
                  // store hierarchy in cache : index 0 is the start point
                  if (i === 0) {
                      this.__stackCache[expandoValue] = stack;
                  }
  
                  // if this id has been removed, don't proceed this callback
                  if (this._changed[expandoValue]) {
                      continue;
                  }
  
                  // retrieve callback (cost nearly nothing, even in big objects)
                  callback = this.__delegateMapping[expandoValue];
  
                  evt.delegateTarget = target;
  
                  // only stop bubbling if callback returned false -> strict equal
                  // Callback might be null has a sub delegation might have destroyed it
                  var result;
                  if (callback) {
                      try {
                          result = callback.call(evt);
                      } catch (e) {
                          this.$logError(this.DELEGATE_UTIL_CALLBACK_FAIL, [evt.type], e);
                      }
                  }
  
                  // return false or hasStopPropagation stop bubbling
                  if (result === false || evt.hasStopPropagation) {
                      break;
                  }
  
                  target = null;
              }
  
              if (!nested) {
                  this._changed = null;
              }
  
              if (result !== false && !evt.hasStopPropagation && aria.templates) {
                  // handle global navigation
                  var navManager = aria.templates.NavigationManager;
                  if (navManager) {
                      navManager.handleGlobalNavigation(evt);
                  }
              }
  
              // focus tracking
              if (evt.type == "focus") {
                  this._focusedElementRemoved = false;
                  this._focusTracking = evt.target;
                  if (this._focusTracking && ATflag) {
  
                      this.$raiseEvent({
                          name : "elementFocused",
                          focusedElement : this._focusTracking
                      });
                  }
              } else if (evt.type == "blur") {
  
                  if (ATflag) {
                      this.$raiseEvent({
                          name : "elementBlurred",
                          blurredElement : this._focusTracking
                      });
                  }
                  this._focusTracking = null;
              }
  
              // dispose event
              evt.$dispose();
  
          }