Called when the module controller is about to be disposed.
@param {Object} event Module controller event.
@protected
337593
function (evt) {
            var reloading = evt.reloadingObject;
            var tmpCfg = this._getReloadCfg();
            var isUsingModuleData = reloading && (this.moduleCtrl.getData() == tmpCfg.data);
            Aria.disposeTemplate(tmpCfg.div); // dispose the old template
            if (reloading) {
                var oSelf = this;
                reloading.$on({
                    scope : {},
                    "objectLoaded" : function (evt) {
                        tmpCfg.moduleCtrl = evt.object;
                        if (isUsingModuleData) {
                            tmpCfg.data = evt.object.getData();
                        }
                        oSelf._callLoadTemplate(tmpCfg);
                    }
                });
            }
        }
793234
function (event) {
            this.$Widget._dom_onmouseleave.call(this, event);
            if (this._ellipsis && this._ellipsis.ellipsesNeeded) {
                if (this._hasFocus === false && this._hasMouseOver === true) {
                    this._hasMouseOver = false;
                    this._ellipsis._hideFullText(event.relatedTarget);
                }
            }
        }
64533
function(event) {
  if (event) {
    var executeDispatch = EventPluginUtils.executeDispatch;
    // Plugins can provide custom behavior when dispatching events.
    var PluginModule = EventPluginRegistry.getPluginModuleForEvent(event);
    if (PluginModule && PluginModule.executeDispatch) {
      executeDispatch = PluginModule.executeDispatch;
    }
    EventPluginUtils.executeDispatchesInOrder(event, executeDispatch);

    if (!event.isPersistent()) {
      event.constructor.release(event);
    }
  }
}
1275132
function(event) {
      var d = event.target.ownerDocument || event.target;
      stopMutation(d);
      expireCache(d);
    }
135506
protected synchronized void fireMPDChangeEvent(MPDChangeEvent.Event event) {
        MPDChangeEvent mce = new MPDChangeEvent(this, event);

        for (MPDChangeListener mcl : listeners) {
            mcl.mpdChanged(mce);
        }
    }
84490
function (evt, args) {
            var smList = this._smList;
            if (smList) {
                // smList can be null if the module is in the process of being disposed
                for (var i = 0, l = smList.length; i < l; i++) {
                    if (smList[i] == evt.src) {
                        ariaUtilsArray.removeAt(smList, i);
                        if (evt.reloadingObject) {
                            evt.reloadingObject.$onOnce({
                                "objectLoaded" : {
                                    scope : this,
                                    fn : this.__onSubModuleReloaded
                                }
                            });
                        }
                        break;
                    }
                }
            }
        }
579846
function onMouseMove(event)  {
  project.deselectAll();

  if (event.item) {
    event.item.selected = true;
  }
}
915315
function () {
        if(this.events) {
            if(this.eventListeners) {
                this.events.un(this.eventListeners);
            }
            this.events.destroy();
            this.events = null;
        }
        this.eventListeners = null;

        // eliminate circular references
        if (this.handler) {
            this.handler.destroy();
            this.handler = null;
        }
        if(this.handlers) {
            for(var key in this.handlers) {
                if(this.handlers.hasOwnProperty(key) &&
                   typeof this.handlers[key].destroy == "function") {
                    this.handlers[key].destroy();
                }
            }
            this.handlers = null;
        }
        if (this.map) {
            this.map.removeControl(this);
            this.map = null;
        }
        this.div = null;
    }
1282237
def __cleanup_module(self, event):
        
        pid     = event.get_pid()
        process = event.get_process()
        module  = event.get_module()

        # Cleanup thread breakpoints on this module
        for tid in process.iter_thread_ids():
            thread = process.get_thread(tid)

            # Running breakpoints
            if tid in self.__runningBP:
                bplist = list(self.__runningBP[tid])
                for bp in bplist:
                    bp_address = bp.get_address()
                    if process.get_module_at_address(bp_address) == module:
                        self.__cleanup_breakpoint(event, bp)
                        self.__runningBP[tid].remove(bp)

            # Hardware breakpoints
            if tid in self.__hardwareBP:
                bplist = list(self.__hardwareBP[tid])
                for bp in bplist:
                    bp_address = bp.get_address()
                    if process.get_module_at_address(bp_address) == module:
                        self.__cleanup_breakpoint(event, bp)
                        self.__hardwareBP[tid].remove(bp)

        # Cleanup code breakpoints on this module
        for (bp_pid, bp_address) in compat.keys(self.__codeBP):
            if bp_pid == pid:
                if process.get_module_at_address(bp_address) == module:
                    bp = self.__codeBP[ (bp_pid, bp_address) ]
                    self.__cleanup_breakpoint(event, bp)
                    del self.__codeBP[ (bp_pid, bp_address) ]

        # Cleanup page breakpoints on this module
        for (bp_pid, bp_address) in compat.keys(self.__pageBP):
            if bp_pid == pid:
                if process.get_module_at_address(bp_address) == module:
                    bp = self.__pageBP[ (bp_pid, bp_address) ]
                    self.__cleanup_breakpoint(event, bp)
                    del self.__pageBP[ (bp_pid, bp_address) ]
807255
function(event)
	{
		var i;
		
		var define = (function(n)
		{
			Object.defineProperty(this, n, 
			{
				get: function() { return this.getItemAt(n); },
				set: function(value) { this.setItemAt(n, value); },
				configurable: true,
				enumerable: true
			});
		}).bind(this);
		
		for (i=0; i<this.length; i++)
		{
			define(i);
		}
		
		while (i in this)
		{
			delete this[i++];
		}
	}
1022180
private boolean checkEventsControllers(EventModel event) {
        List<CompletableFuture<Boolean>> collect = eventsControllers.stream()
                .map(controller -> submit(() -> controller.controlEventDispatcher(event)).thenApply(result -> {
                    if (!result)
                        debug("Event: " + event + " is canceled by " + controller.getID());
                    return result;
                }))
                .collect(Collectors.toList());
        try {
            collect = timeOut(collect, 1000);
        } catch (InterruptedException e) {
            debug("interrupted");
        }
        return collect.stream()
                .map(future -> {
                    try {
                        return future.get();
                    } catch (InterruptedException | ExecutionException e) {
                        return null;
                    }
                })
                .filter(Objects::nonNull)
                .noneMatch(bool -> !bool);
    }
1234784
function (event) {
            var pageId = event.pageId;
            if (this.currentPageId == pageId) {
                this._rootModule.unloadPageModules(pageId);
                this.navigate({
                    pageId : pageId,
                    url : this._navigationManager ? this._navigationManager.getUrl() : null,
                    forceReload : true
                });
            }
        }
741907
function(_event){
                if (_event.button === 0) {
                    _v._$addEvent(this,'mousemove',_onMouseMove);
                    setTimeout(_dispatchIfChanged.bind(null, this), 0);
                }
            }
520545
function completed( event ) {
	        // readyState === "complete" is good enough for us to call the dom ready in oldIE
	        if ( w3c || event.type === LOAD || doc[READYSTATE] === COMPLETE ) {
	            detach();
	            ready();
	        }
	    }
47789
function (event) {
            var
                eventsHandler;
            if (event
                && event.type() === _gpfI.IWritableStream.EVENT_ERROR) {
                gpfFireEvent.call(this, event, this._eventsHandler);
            } else if (0 === this._buffer.length) {
                eventsHandler = this._eventsHandler;
                this._eventsHandler = null;
                gpfFireEvent.call(this, _gpfI.IWritableStream.EVENT_READY, eventsHandler);
            } else {
                this._stream.write(this._buffer.shift(), this._flushed.bind(this));
            }
        }
876594
function (domEvent) {
            if (!!this._cfg.onclick) {
                var domEvtWrapper;
                if (domEvent) {
                    domEvtWrapper = new ariaTemplatesDomEventWrapper(domEvent);
                }
                this.evalCallback(this._cfg.onclick, domEvtWrapper);
                if (domEvtWrapper) {
                    domEvtWrapper.$dispose();
                }
            }
        }
712973
function windowLoaded(event) {
    document.removeEventListener('DOMContentLoaded', windowLoaded);

    // JSDom > 7.1 does not allow re-dispatching the same event, so
    // a copy of the event needs to be created for the new dispatch
    const windowContentLoaded = document.createEvent('HTMLEvents');
    windowContentLoaded.initEvent('DOMContentLoaded', false, false);
    window.dispatchEvent(windowContentLoaded);
  }