If not done already, remove the resize listener from Aria.$window and notifies AriaWindow that we are no longer
using Aria.$window.
430349
function () {
        if (__cancelID) {
            timer.cancelCallback(__cancelID);
            __cancelID = null;
        }
        if (__autoresizes != null) {
            eventUtils.removeListener(Aria.$window, "resize", {
                fn : __onResize
            });
            ariaUtilsAriaWindow.detachWindow();
            __autoresizes = null;
        }
    }
1338680
function() {
        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
    }
1068231
function resizeListener(e) {
    var win = e.target || e.srcElement;
    // Get resize funciton to be triggered and suscribe itto cancel function
    if (win.__resizeRAF) cancelFrame(win.__resizeRAF);
    // Declare resize function and suscribe it to request animation frame functionality
    win.__resizeRAF = requestFrame(function() {
      var trigger = win.__resizeTrigger;
      // Call every monitored element resize callbacks
      if (trigger) {
        // Call every monitored element resize callbacks
        for (var key in trigger.__resizeListeners) {
          trigger.__resizeListeners[key].call(trigger, e);
        }
      }
    });
  }
280750
protected function removeLastEventIfOutsideWindowAndNonRecurring()
    {
        $events = $this->cal['VEVENT'];

        if (!empty($events)) {
            $lastIndex = sizeof($events) - 1;
            $lastEvent = $events[$lastIndex];

            if (!isset($lastEvent['RRULE']) || $lastEvent['RRULE'] === '' && $this->doesEventStartOutsideWindow($lastEvent)) {
                $this->eventCount--;

                unset($events[$lastIndex]);
            }

            $this->cal['VEVENT'] = $events;
        }
    }
709324
def remove_service_listener(self, listener):
        """"""
        for browser in self.browsers:
            if browser.listener == listener:
                browser.cancel()
                del(browser)
652477
function onResizeEnd() {
            utils.dragInfo.inDragging = false;
            utils.dragInfo.justResized = true; // if winJustDragged, should force children re-render
            setTimeout(function () {
              utils.dragInfo.justResized = false;
            }, 1200);

            refreshFrame();
          }
175196
function() {
		var checkReadyInterval,
			url = this._createUrl(),

			/**
			 * Bogus title to prevent re-usage of existing window with the
			 * same title. The actual title will be set by the new window's
			 * GoldenLayout instance if it detects that it is in subWindowMode
			 */
			title = Math.floor( Math.random() * 1000000 ).toString( 36 ),

			/**
			 * The options as used in the window.open string
			 */
			options = this._serializeWindowOptions( {
				width: this._dimensions.width,
				height: this._dimensions.height,
				innerWidth: this._dimensions.width,
				innerHeight: this._dimensions.height,
				menubar: 'no',
				toolbar: 'no',
				location: 'no',
				personalbar: 'no',
				resizable: 'yes',
				scrollbars: 'no',
				status: 'no'
			} );

		this._popoutWindow = window.open( url, title, options );

		if( !this._popoutWindow ) {
			if( this._layoutManager.config.settings.blockedPopoutsThrowError === true ) {
				var error = new Error( 'Popout blocked' );
				error.type = 'popoutBlocked';
				throw error;
			} else {
				return;
			}
		}

		$( this._popoutWindow )
			.on( 'load', lm.utils.fnBind( this._positionWindow, this ) )
			.on( 'unload beforeunload', lm.utils.fnBind( this._onClose, this ) );

		/**
		 * Polling the childwindow to find out if GoldenLayout has been initialised
		 * doesn't seem optimal, but the alternatives - adding a callback to the parent
		 * window or raising an event on the window object - both would introduce knowledge
		 * about the parent to the child window which we'd rather avoid
		 */
		checkReadyInterval = setInterval( lm.utils.fnBind( function() {
			if( this._popoutWindow.__glInstance && this._popoutWindow.__glInstance.isInitialised ) {
				this._onInitialised();
				clearInterval( checkReadyInterval );
			}
		}, this ), 10 );
	}
577412
protected void removeDecorationWidget(Widget widget, int width) {

        if ((widget != null) && m_decorationWidgets.remove(widget)) {
            m_decorationWidth -= width;
            initContent();
        }
    }
404439
function () {
        var scope = aria.ext.StressCss;
        aria.templates.CSSMgr.__load = scope.original__load;
        aria.templates.CSSMgr.__unload = scope.original__unload;
        refreshCSS();
    }
238605
function () {
        if (__autoresizes == null && layout._listeners && layout._listeners['viewportResized']) {
            __init();
        } else if (__autoresizes != null && __autoresizes.length === 0
                && (layout._listeners == null || layout._listeners['viewportResized'] == null)) {
            __reset();
        }
    }
403952
function (e) {
                // call unload listeners
                // Keep a local copy of the reference to unloadListeners because it is possible that a listener calls
                // aria.utils.Event.reset (that's what AriaWindow is doing).
                var list = unloadListeners.slice();
                for (var i = 0, len = list.length; i < len; ++i) {
                    var l = list[i];
                    if (l) {
                        l[CB].call(this.getEvent(e));
                        list[i] = null;
                        l = null;
                    }
                }
                list = null;
            }
1223196
public void retireWindow(W window) throws Exception {
		this.mapping.remove(window);
		boolean removed = this.sortedWindows.remove(window);
		if (!removed) {
			throw new IllegalStateException("Window " + window + " is not in in-flight window set.");
		}
	}
866524
function removeResizeListener(resizeListener) {
        removeIdFromList(rootListener, resizeListener.id);
        if (a4p.isDefined(listenersIndex[resizeListener.id])) {
            delete listenersIndex[resizeListener.id];
        }
        if (a4p.isDefined(listenersIndex[resizeListener.name]) && (listenersIndex[resizeListener.name].id == resizeListener.id)) {
            delete listenersIndex[resizeListener.name];
        }
    }
378375
function () {
            this._displayDiv.innerHTML = '';
            if (this._displayDiv != null) {
                aria.utils.Dom.removeElement(this._displayDiv);
            }
            this._displayDiv = null;
        }
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();
                }
            }
        }
820374
function () {
            var cfg = this._cfg;
            var modal = cfg.modal;

            if (this._showBack != null) {
                this._showBack();
                this._showBack = null;
            }

            if (this._popup) {
                this.waiReadText(cfg.waiCloseMsg);

                this._destroyDraggable();
                this._destroyResizable();

                if (cfg.maximized) {
                    this._setContainerOverflow(this._optionsBeforeMaximize.containerOverflow);
                }

                this._domElt = null;
                this._titleBarDomElt = null;
                this._titleDomElt = null;
                if (this._closeDelegateId) {
                    ariaUtilsDelegate.remove(this._closeDelegateId);
                }
                if (this._maximizeDelegateId) {
                    ariaUtilsDelegate.remove(this._maximizeDelegateId);
                }

                this._popup.close();
                this._popup.$unregisterListeners(this);
                this._popup.$dispose();
                this._popup = null;
                PopupContainerManager.releasePopupContainer(this._popupContainer);
                this._popupContainer = null;

                ariaTemplatesLayout.$removeListeners({
                    "viewportResized" : this._onViewportResized,
                    scope : this
                });

                if (modal) {
                    var previouslyFocusedElement = this._previouslyFocusedElement;
                    if (cfg.restoreFocusOnClose && ariaUtilsDom.isInDom(previouslyFocusedElement) && !/^body$/i.test(previouslyFocusedElement.tagName)) {
                        setTimeout(function () {
                            try {
                                // On IE 7 and 8, focusing an element which is no longer in the DOM
                                // throws the "Unexpected call to method or property access." exception
                                previouslyFocusedElement.focus();
                            } catch (e) {}
                        }, 0);
                        this._previouslyFocusedElement = null;
                    }
                }
            }
        }
1082840
function (window) {
            window = window || Aria.$window;
            var href = window.location.href;
            var sharpIndex = href.indexOf("#");
            if (sharpIndex != -1) {
                return href.substring(sharpIndex + 1);
            }
            return "";
        }