Is called right after the popup is displayed.
437560
function () {
            var cfg = this._cfg;
            var getDomElementChild = ariaUtilsDom.getDomElementChild;
            this._domElt = this._popup.domElement;
            var titleBarDomElt = this._titleBarDomElt = getDomElementChild(this._domElt, 0, titleLast);
            this._titleDomElt = getDomElementChild(titleBarDomElt, cfg.icon ? 1 : 0);
            this._onDimensionsChanged();

            this._calculatePosition();

            if (cfg.autoFocus) {
                ariaTemplatesNavigationManager.focusFirst(this._domElt);
            } else if (cfg.modal) {
                var document = Aria.$window.document;
                var activeElement = document.activeElement;
                if (activeElement && activeElement !== document.body) {
                    activeElement.blur();
                }
            }

            ariaCoreTimer.addCallback({
                fn : function () {
                    // check that the dialog was not disposed
                    if (this._cfg) {
                        this.waiReadText(cfg.waiOpenMsg);
                        this.evalCallback(cfg.onOpen);
                    }
                },
                scope : this,
                delay : 4
            });

            if (cfg.maximized) {
                return; // don't create movable nor resizable
            }

            if (cfg.movable) {
                this._loadAndCreateDraggable();
            }

            if (cfg.resizable) {
                this._loadAndCreateResizable();
            }
        }
824574
function () {
            var domReference = this.reference;
            if (domReference && this.isOpen) {

                var position = this.popupContainer.calculatePosition(domReference);
                var size = {
                    width: domReference.offsetWidth,
                    height: domReference.offsetHeight
                };
                var referenceIsInContainer = this.popupContainer.isInside(position, size, this.domElement);

                if (referenceIsInContainer) {
                    this.referencePosition = position;
                    this.referenceSize = size;
                    this.refresh();
                    if (this.domElement && this.domElement.style.visibility === "hidden") {
                        this.domElement.style.visibility = "visible";
                    }
                } else {
                    this.domElement.style.visibility = "hidden";
                }
            }
        }
1272883
function()
	{
		var dialog = this.getDialog(),
			popupFeatures = dialog.getContentElement( 'target', 'popupFeatures' ),
			targetName = dialog.getContentElement( 'target', 'linkTargetName' ),
			value = this.getValue();

		if ( !popupFeatures || !targetName )
			return;

		popupFeatures = popupFeatures.getElement();
		popupFeatures.hide();
		targetName.setValue( '' );

		switch ( value )
 		{
			case 'frame' :
				targetName.setLabel( editor.lang.link.targetFrameName );
				targetName.getElement().show();
				break;
			case 'popup' :
				popupFeatures.show();
				targetName.setLabel( editor.lang.link.targetPopupName );
				targetName.getElement().show();
				break;
			default :
				targetName.setValue( value );
				targetName.getElement().hide();
				break;
 		}

	}
1354567
private void checkPopup(MouseEvent e) {
        if (e.isPopupTrigger()) {
            popup.show(this, e.getX(), e.getY());
        }
    }
1371027
function () {
            // --------------------------------------------------- destructuring

            var cfg = this._cfg;

            var modal = cfg.modal;
            var waiAria = cfg.waiAria;

            // ------------------------------------------------------ processing

            // refreshParams ---------------------------------------------------

            var refreshParams = {
                section : "__dialog_" + this._domId,
                writerCallback : {
                    fn : this._writerCallback,
                    scope : this
                }
            };

            // popupContainer --------------------------------------------------

            var popupContainer = PopupContainerManager.createPopupContainer(cfg.container);
            this._popupContainer = popupContainer;

            // previouslyFocusedElement ----------------------------------------

            if (modal) {
                this._previouslyFocusedElement = Aria.$window.document.activeElement;
            }

            // optionsBeforeMaximize -------------------------------------------
            // store current options to reapply them when unmaximized

            this._optionsBeforeMaximize = this._createOptionsBeforeMaximize(cfg);

            // section ---------------------------------------------------------

            var section = this._context.getRefreshedSection(refreshParams);

            // popup -----------------------------------------------------------

            var popup = new ariaPopupsPopup();

            this._popup = popup;

            popup.$on({
                "onAfterOpen" : this._onAfterPopupOpen,
                "onEscape" : this._onEscape,
                "onAfterClose" : this._onAfterPopupClose,
                scope : this
            });

            if (cfg.closeOnMouseClick) {
                popup.$on({
                    "onMouseClickClose" : this._onMouseClickClose,
                    scope : this
                });
            }

            popup.open({
                section : section,
                keepSection : true,
                absolutePosition : {
                    left : cfg.xpos,
                    top : cfg.ypos
                },
                center : cfg.center,
                maximized : cfg.maximized,
                offset : cfg.maximized ? this._shadows : this._shadowsZero,
                modal : modal,
                maskCssClass : "xDialogMask",
                popupContainer : popupContainer,
                closeOnMouseClick : cfg.closeOnMouseClick,
                closeOnMouseScroll : false,
                parentDialog : this,
                zIndexKeepOpenOrder : false, // allows to re-order dialogs (dynamic z-index)
                role: modal ? "dialog" : null,
                labelId: modal ? this.__getLabelId() : null,
                waiAria: waiAria
            });

            // hiddenElements --------------------------------------------------

            if (modal && waiAria) {
                var container = popupContainer.getContainerElt();
                this._showBack = DomNavigationManager.hidingManager.hideOthers(popup.domElement, function (element) {
                     return element != null && element !== container;
                });
            }

            // -----------------------------------------------------------------

            // must be registered before we check for _cfg.maximized, to fire the event correctly after overflow change
            ariaTemplatesLayout.$on({
                "viewportResized" : this._onViewportResized,
                scope : this
            });

            // -----------------------------------------------------------------

            // in case when bound "maximized" was toggled while Dialog was not visible
            if (cfg.maximized) {
                this._setContainerOverflow("hidden");
                this._setMaximizedHeightAndWidth();
            }

            this._firstEscapeTime = null;
        }
1357936
function(contentHTML) {

        if (contentHTML != null) {
            this.contentHTML = contentHTML;
        }
       
        if ((this.contentDiv != null) && 
            (this.contentHTML != null) &&
            (this.contentHTML != this.contentDiv.innerHTML)) {
       
            this.contentDiv.innerHTML = this.contentHTML;
       
            if (this.autoSize) {
                
                //if popup has images, listen for when they finish
                // loading and resize accordingly
                this.registerImageListeners();

                //auto size the popup to its current contents
                this.updateSize();
            }
        }    

    }
139306
public void show (PopupPanel popup, Widget onCenter)
    {
        // determine the ypos of our onCenter target in case it's in the currently popped up popup,
        // because after we hide that popup we won't be able to compute it
        int ypos = (onCenter == null) ? 0 :
            (onCenter.getAbsoluteTop() + onCenter.getOffsetHeight()/2);

        PopupPanel showing = _showingPopup.get();
        if (showing != null) {
            // null _showingPopup before hiding to avoid triggering the close handler logic
            _popups.add(showing);
            _showingPopup.update(null);
            showing.hide(true);
        }

        if (onCenter == null) {
            popup.center(); // this will show the popup
        } else {
            Popups.centerOn(popup, ypos).show();
        }

        // now that we've centered and shown our popup (which may have involved showing, hiding and
        // showing it again), we can add a close handler and listen for it to actually close
        popup.addCloseHandler(new CloseHandler<PopupPanel>() {
            public void onClose (CloseEvent<PopupPanel> event) {
                if (_showingPopup.get() == event.getTarget()) {
                    if (_popups.size() > 0) {
                        _showingPopup.update(_popups.remove(_popups.size()-1));
                        _showingPopup.get().show();
                    } else {
                        _showingPopup.update(null);
                    }
                }
            }
        });
        _showingPopup.update(popup);
    }
791624
public void disposeTooltip() {
    if (popup != null) {
      timer.stop();
      popup.setVisible(false);
      popup = null;
    }
  }
73802
function() {
          module.debug('Toggling pop-up');
          if( module.is.hidden() ) {
            module.debug('Popup is hidden, showing pop-up');
            module.unbind.close();
            module.show();
          }
          else {
            module.debug('Popup is visible, hiding pop-up');
            module.hide();
          }
        }
295532
public function init() {
		
		parent::init();

        $booster = Booster::getBooster();
		$popover = $booster->popoverSelector;
		$tooltip = $booster->tooltipSelector;

		$afterAjaxUpdate = "js:function() {
			jQuery('.popover').remove();
			jQuery('{$popover}').popover();
			jQuery('.tooltip').remove();
			jQuery('{$tooltip}').tooltip();
		}";

		if (!isset($this->afterAjaxUpdate)) {
			$this->afterAjaxUpdate = $afterAjaxUpdate;
		}
	}
80156
public static void showPopup() {

        final CmsPopup popup = new CmsPopup(CmsAliasMessages.messageTitleImport());
        popup.setModal(true);
        popup.setGlassEnabled(true);
        CmsImportView importView = new CmsImportView();
        popup.setMainContent(importView);
        popup.setWidth(800);
        popup.addDialogClose(null);
        popup.centerHorizontally(100);
    }
815018
def display_popup(self, title, content):
        
        assert isinstance(title, six.text_type)
        assert isinstance(content, six.text_type)

        self.popup_dialog.title = title
        self._popup_textarea.text = content
        self.client_state.display_popup = True
        get_app().layout.focus(self._popup_textarea)
132322
function () {
                for (var i = this.openedPopups.length - 1; i >= 0; i--) {
                    var popup = this.openedPopups[i];
                    popup.updatePosition();
                }
            }
682400
public void show (Popups.Position pos, Widget target)
    {
        Popups.show(this, pos, target);
    }
739457
def _on_click(self, *args):
        
        if callable(self._callback):
            self._callback(self.selection)
595650
def _runPopUp(workbench, popUp):
    
    workbench.display(popUp)

    d = popUp.notifyCompleted()
    d.addCallback(_popUpCompleted, workbench)
    return d
1330928
void updateCornerLeft() {

        if (m_corner != null) {
            int popupLeft = popup.getPopupLeft();
            int dif = (getAbsoluteLeft() - popupLeft) + OFFSET;
            m_corner.getStyle().setLeft(dif, Unit.PX);
        }
    }