Show the popup list. If the list is already showing, this method
will recalculate the popup's size and position.
543112
public void show() {
        int height = buildDropDown();

        int widthSpec = 0;
        int heightSpec = 0;

        boolean noInputMethod = isInputMethodNotNeeded();

        if (mPopup.isShowing()) {
            if (mDropDownWidth == ViewGroup.LayoutParams.MATCH_PARENT) {
                // The call to PopupWindow's update method below can accept -1 for any
                // value you do not want to update.
                widthSpec = -1;
            } else if (mDropDownWidth == ViewGroup.LayoutParams.WRAP_CONTENT) {
                widthSpec = getAnchorView().getWidth();
            } else {
                widthSpec = mDropDownWidth;
            }

            if (mDropDownHeight == ViewGroup.LayoutParams.MATCH_PARENT) {
                // The call to PopupWindow's update method below can accept -1 for any
                // value you do not want to update.
                heightSpec = noInputMethod ? height : ViewGroup.LayoutParams.MATCH_PARENT;
                if (noInputMethod) {
                    mPopup.setWindowLayoutMode(
                            mDropDownWidth == ViewGroup.LayoutParams.MATCH_PARENT ?
                                    ViewGroup.LayoutParams.MATCH_PARENT : 0, 0);
                } else {
                    mPopup.setWindowLayoutMode(
                            mDropDownWidth == ViewGroup.LayoutParams.MATCH_PARENT ?
                                    ViewGroup.LayoutParams.MATCH_PARENT : 0,
                            ViewGroup.LayoutParams.MATCH_PARENT);
                }
            } else if (mDropDownHeight == ViewGroup.LayoutParams.WRAP_CONTENT) {
                heightSpec = height;
            } else {
                heightSpec = mDropDownHeight;
            }

            mPopup.setOutsideTouchable(!mForceIgnoreOutsideTouch && !mDropDownAlwaysVisible);

            mPopup.update(getAnchorView(), mDropDownHorizontalOffset,
                    mDropDownVerticalOffset, widthSpec, heightSpec);
        } else {
            if (mDropDownWidth == ViewGroup.LayoutParams.MATCH_PARENT) {
                widthSpec = ViewGroup.LayoutParams.MATCH_PARENT;
            } else {
                if (mDropDownWidth == ViewGroup.LayoutParams.WRAP_CONTENT) {
                    mPopup.setWidth(getAnchorView().getWidth());
                } else {
                    mPopup.setWidth(mDropDownWidth);
                }
            }

            if (mDropDownHeight == ViewGroup.LayoutParams.MATCH_PARENT) {
                heightSpec = ViewGroup.LayoutParams.MATCH_PARENT;
            } else {
                if (mDropDownHeight == ViewGroup.LayoutParams.WRAP_CONTENT) {
                    mPopup.setHeight(height);
                } else {
                    mPopup.setHeight(mDropDownHeight);
                }
            }

            mPopup.setWindowLayoutMode(widthSpec, heightSpec);
            setPopupClipToScreenEnabled(true);

            // use outside touchable to dismiss drop down when touching outside of it, so
            // only set this if the dropdown is not always visible
            mPopup.setOutsideTouchable(!mForceIgnoreOutsideTouch && !mDropDownAlwaysVisible);
            mPopup.setTouchInterceptor(mTouchInterceptor);
            PopupWindowCompat.showAsDropDown(mPopup, getAnchorView(), mDropDownHorizontalOffset,
                    mDropDownVerticalOffset, mDropDownGravity);
            mDropDownList.setSelection(ListView.INVALID_POSITION);

            if (!mModal || mDropDownList.isInTouchMode()) {
                clearListSelection();
            }
            if (!mModal) {
                mHandler.post(mHideSelector);
            }

            // show item animation
            if(mItemAnimationId != 0)
	            mPopup.getContentView().getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {

					@Override
					public boolean onPreDraw() {
						mPopup.getContentView().getViewTreeObserver().removeOnPreDrawListener(this);
						for(int i = 0, count = mDropDownList.getChildCount(); i < count; i ++){
							View v = mDropDownList.getChildAt(i);

							Animation anim = AnimationUtils.loadAnimation(mContext, mItemAnimationId);
							anim.setStartOffset(mItemAnimationOffset * i);
							v.startAnimation(anim);
						}
						return false;
					}

				});
        }
    }
484278
def show_popup(self, selected, pos):
        ''''''
        state = self.state
        if selected.popup_menu is not None:
            import copy
            popup_menu = selected.popup_menu
            if state.default_popup is not None and state.default_popup.combine:
                popup_menu = copy.deepcopy(popup_menu)
                popup_menu.add(MPMenuSeparator())
                popup_menu.combine(state.default_popup.popup)
            wx_menu = popup_menu.wx_menu()
            state.frame.PopupMenu(wx_menu, pos)
1101764
def show(self, ):
        
        self.update_all_buttons()
        pos = self.get_position()
        self.move(pos)
        super(WidgetToolTip, self).show()
290643
def showPopup(self):
        
        as_dialog = QApplication.keyboardModifiers()
        
        anchor = self.defaultAnchor()
        if anchor:
            self.popupWidget().setAnchor(anchor)
        else:
            anchor = self.popupWidget().anchor()
        
        if ( anchor & (XPopupWidget.Anchor.BottomLeft |
                       XPopupWidget.Anchor.BottomCenter |
                       XPopupWidget.Anchor.BottomRight) ):
            pos = QPoint(self.width() / 2, 0)
        else:
            pos = QPoint(self.width() / 2, self.height())
        
        pos = self.mapToGlobal(pos)
        
        if not self.signalsBlocked():
            self.popupAboutToShow.emit()
        self._popupWidget.popup(pos)
        
        if as_dialog:
            self._popupWidget.setCurrentMode(XPopupWidget.Mode.Dialog)
466429
protected void refreshListUI() {
		final Display display = Display.getDefault();
		if (display.getThread().equals(Thread.currentThread())) {
			if (!this.list.isBusy()) {
				this.list.refresh();
			}
		} else {
			display.syncExec(new Runnable() {
				@SuppressWarnings("synthetic-access")
				@Override
				public void run() {
					if (!AbstractConversionTable.this.list.isBusy()) {
						AbstractConversionTable.this.list.refresh();
					}
				}
			});
		}
	}
980250
def showPopup( self ):
        
        if not self.isCheckable():
            return super(XComboBox, self).showPopup()
        
        if not self.isVisible():
            return
        
        # update the checkable widget popup
        point = self.mapToGlobal(QPoint(0, self.height() - 1))
        popup = self.checkablePopup()
        popup.setModel(self.model())
        popup.move(point)
        popup.setFixedWidth(self.width())
        
        height = (self.count() * 19) + 2
        if height > 400:
            height = 400
            popup.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
        else:
            popup.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        
        popup.setFixedHeight(height)
        popup.show()
        popup.raise_()
768700
public void show() {
        if (mAnchorViewRef.get() != null) {
            mPopupContent = new PopupContentView(mContext);
            TextView body = (TextView) mPopupContent.findViewById(
                    R.id.com_facebook_tooltip_bubble_view_text_body);
            body.setText(mText);
            if (mStyle == Style.BLUE) {
                mPopupContent.bodyFrame.setBackgroundResource(
                        R.drawable.com_facebook_tooltip_blue_background);
                mPopupContent.bottomArrow.setImageResource(
                        R.drawable.com_facebook_tooltip_blue_bottomnub);
                mPopupContent.topArrow.setImageResource(
                        R.drawable.com_facebook_tooltip_blue_topnub);
                mPopupContent.xOut.setImageResource(R.drawable.com_facebook_tooltip_blue_xout);
            } else {
                mPopupContent.bodyFrame.setBackgroundResource(
                        R.drawable.com_facebook_tooltip_black_background);
                mPopupContent.bottomArrow.setImageResource(
                        R.drawable.com_facebook_tooltip_black_bottomnub);
                mPopupContent.topArrow.setImageResource(
                        R.drawable.com_facebook_tooltip_black_topnub);
                mPopupContent.xOut.setImageResource(R.drawable.com_facebook_tooltip_black_xout);
            }
            
            final Window window = ((Activity) mContext).getWindow();
            final View decorView = window.getDecorView();
            final int decorWidth = decorView.getWidth();
            final int decorHeight = decorView.getHeight();
            registerObserver();
            mPopupContent.onMeasure(
                    View.MeasureSpec.makeMeasureSpec(decorWidth, View.MeasureSpec.AT_MOST), 
                    View.MeasureSpec.makeMeasureSpec(decorHeight, View.MeasureSpec.AT_MOST));
            mPopupWindow = new PopupWindow(
                    mPopupContent, 
                    mPopupContent.getMeasuredWidth(),
                    mPopupContent.getMeasuredHeight());
            mPopupWindow.showAsDropDown(mAnchorViewRef.get());
            updateArrows();
            if (mNuxDisplayTime > 0) {
                mPopupContent.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        dismiss();
                    }
                }, mNuxDisplayTime);
            }
            mPopupWindow.setTouchable(true);
            mPopupContent.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    dismiss();
                }
            });
        }
    }
516930
function(e) {
        Dom.setStyle(this.id, "visibility", "");
        
        // Fire the reordered event if position in list has changed
        var clickEl = this.getEl();
        var newIndex = inputEx.indexOf(clickEl ,clickEl.parentNode.childNodes);
        if(this._originalIndex != newIndex) {
           this._list.onReordered(this._originalIndex, newIndex);
        }
    }
1050721
def showPopup(self):
        
        if not self.showTreePopup():
            return super(XOrbRecordBox, self).showPopup()
        
        tree = self.treePopupWidget()
        
        if tree and not tree.isVisible():
            tree.move(self.mapToGlobal(QPoint(0, self.height())))
            tree.resize(self.width(), 250)
            tree.resizeToContents()
            tree.filterItems('')
            tree.setFilteredColumns(range(tree.columnCount()))
            tree.show()
1111465
function () {
		//if we can't fit the popup above or below the activator then forget vertical positioning
		if (!this.initVerticalPositioning()) {
			return false;
		}

		var clientRect = this.getBoundingRect(this.node);
		var innerWidth = this.getViewWidth();

		if (this.floating){
			//Get the left edge delta to horizontally center the popup
			var centeredLeft = this.activatorOffset.left + this.activatorOffset.width/2 - clientRect.width/2;
			if (centeredLeft + clientRect.width > innerWidth) {//popup goes off right edge of the screen if centered
				this.applyPosition({left: this.activatorOffset.left + this.activatorOffset.width - clientRect.width});
				this.addClass('left');
			} else if (centeredLeft < 0) {//popup goes off left edge of the screen if centered
				this.applyPosition({left:this.activatorOffset.left});
				this.addClass('right');
			} else {//center the popup
				this.applyPosition({left: centeredLeft});
			}

		} else {
			//Get the left edge delta to horizontally center the popup
			var centeredLeftDelta = this.activatorOffset.left + this.activatorOffset.width/2 - clientRect.left - clientRect.width/2;
			if (clientRect.right + centeredLeftDelta > innerWidth) {//popup goes off right edge of the screen if centered
				this.applyPosition({left: this.activatorOffset.left + this.activatorOffset.width - clientRect.right});
				this.addRemoveClass('left', true);
			} else if (clientRect.left + centeredLeftDelta < 0) {//popup goes off left edge of the screen if centered
				this.addRemoveClass('right', true);
			} else {//center the popup
				this.applyPosition({left: centeredLeftDelta});
			}
		}

		return true;
	}
152688
public void show(Node node, PopupVPosition vAlign, PopupHPosition hAlign, double initOffsetX, double initOffsetY) {
        if (!isShowing()) {
            if (node.getScene() == null || node.getScene().getWindow() == null) {
                throw new IllegalStateException("Can not show popup. The node must be attached to a scene/window.");
            }
            Window parent = node.getScene().getWindow();
            final Point2D origin = node.localToScene(0, 0);
            final double anchorX = parent.getX() + origin.getX()
                + node.getScene().getX() + (hAlign == PopupHPosition.RIGHT ? ((Region) node).getWidth() : 0);
            final double anchorY = parent.getY() + origin.getY()
                + node.getScene()
                      .getY() + (vAlign == PopupVPosition.BOTTOM ? ((Region) node).getHeight() : 0);
            this.show(parent, anchorX, anchorY);
            ((JFXPopupSkin) getSkin()).reset(vAlign, hAlign, initOffsetX, initOffsetY);
            Platform.runLater(() -> ((JFXPopupSkin) getSkin()).animate());
        }
    }
1187439
private void initializeListView() {
    placesListView.setAdapter(placesAdapter);
    placesListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
      @Override
      public void onItemClick(AdapterView<?> adapterView, View view, int position, long id) {
        lastLoadedPlacePosition = position;
        showPlace(position);
      }
    });
  }
979323
public void showInstructionList() {
    onInstructionListVisibilityChanged(true);
    instructionLayout.requestFocus();
    beginDelayedListTransition();
    if (isLandscape()) {
      updateLandscapeConstraintsTo(R.layout.instruction_layout_alt);
    }
    instructionListLayout.setVisibility(VISIBLE);
  }
420123
function show() {

              popupTimeout = null;

              // If there is a pending remove transition, we must cancel it, lest the
              // tooltip be mysteriously removed.
              if ( transitionTimeout ) {
                $timeout.cancel( transitionTimeout );
                transitionTimeout = null;
              }

              // Don't show empty tooltips.
              if ( ! scope.tt_content ) {
                return angular.noop;
              }

              createTooltip();

              // Set the initial positioning.
              tooltip.css({ top: 0, left: 0, display: 'block' });

              // Now we add it to the DOM because need some info about it. But it's not 
              // visible yet anyway.
              if ( appendToBody ) {
                  $document.find( 'body' ).append( tooltip );
              } else {
                element.after( tooltip );
              }

              positionTooltip();

              // And show the tooltip.
              scope.tt_isOpen = true;
              scope.$digest(); // digest required as $apply is not called

              // Return positioning function as promise callback for correct
              // positioning after draw.
              return positionTooltip;
            }
27953
function() { 

        // As the images load, this function will call updateSize() to 
        // resize the popup to fit the content div (which presumably is now
        // bigger than when the image was not loaded).
        // 
        // If the 'panMapIfOutOfView' property is set, we will pan the newly
        // resized popup back into view.
        // 
        // Note that this function, when called, will have 'popup' and 
        // 'img' properties in the context.
        //
        var onImgLoad = function() {
            if (this.popup.id === null) { // this.popup has been destroyed!
                return;
            }
            this.popup.updateSize();
     
            if ( this.popup.visible() && this.popup.panMapIfOutOfView ) {
                this.popup.panIntoView();
            }

            OpenLayers.Event.stopObserving(
                this.img, "load", this.img._onImgLoad
            );
    
        };

        //cycle through the images and if their size is 0x0, that means that 
        // they haven't been loaded yet, so we attach the listener, which 
        // will fire when the images finish loading and will resize the 
        // popup accordingly to its new size.
        var images = this.contentDiv.getElementsByTagName("img");
        for (var i = 0, len = images.length; i < len; i++) {
            var img = images[i];
            if (img.width == 0 || img.height == 0) {

                var context = {
                    'popup': this,
                    'img': img
                };

                //expando this function to the image itself before registering
                // it. This way we can easily and properly unregister it.
                img._onImgLoad = OpenLayers.Function.bind(onImgLoad, context);

                OpenLayers.Event.observe(img, 'load', img._onImgLoad);
            }    
        } 
    }
652953
public static <T extends PopupPanel> T show (T popup, Position pos, Widget target)
    {
        popup.setVisible(false);
        popup.show();

        int left, top;
        switch (pos) {
        case RIGHT:
            left = target.getAbsoluteLeft() + target.getOffsetWidth() + NEAR_GAP;
            break;
        default:
            left = target.getAbsoluteLeft();
            break;
        }
        if (left + popup.getOffsetWidth() > Window.getClientWidth()) {
            left = Math.max(0, Window.getClientWidth() - popup.getOffsetWidth());
        }

        switch (pos) {
        case ABOVE:
            top = target.getAbsoluteTop() - popup.getOffsetHeight() - NEAR_GAP;
            break;
        case OVER:
            top = target.getAbsoluteTop();
            break;
        case RIGHT:
            top = target.getAbsoluteTop() + (target.getOffsetHeight() - popup.getOffsetHeight())/2;
            break;
        default:
        case BELOW:
            top = target.getAbsoluteTop() + target.getOffsetHeight() + NEAR_GAP;
            break;
        }

        popup.setPopupPosition(left, top);
        popup.setVisible(true);
        return popup;
    }
8661
def _show(self):
        """"""
        if not self._icon:
            self._icon = self._create_statusicon()
        widget = self._icon
        widget.set_visible(True)
        self._conn_left = widget.connect("activate", self._activate)
        self._conn_right = widget.connect("popup-menu", self._popup_menu)