goog.ui.PopupBase

Mouse events that occur within an autoHide partner will not hide a popup set to autoHide.

Adds an event listener to the event target. The same handler can only be added once per the type. Even if you add the same handler multiple times using the same type then it will only be called once when the event is dispatched.

Invokes a callback function when this object is disposed. Callbacks are invoked in the order in which they were added. If a callback is added to an already disposed Disposable, it will be called immediately.

Dispatches an event (or event like object) and calls all listeners listening for events of this type. The type of the event is decided by the type property on the event object.

If any of the listeners returns false OR calls preventDefault then this function will return false. If one of the capture listeners calls stopPropagation, then the bubble listeners won't fire.

Disposes of the object and its resources.

Removes listeners from this object. Classes that extend EventTarget may need to override this method in order to remove references to DOM Elements and additional listeners.

Fires all registered listeners in this listenable for the given type and capture mode, passing them the given eventObject. This does not perform actual capture/bubble. Only implementors of the interface should be using this.

Returns whether the Popup dismisses itself when the user clicks outside of it.

Returns the region inside which the Popup dismisses itself when the user clicks, or null if it's the entire document.

Returns the dom element that should be used for the popup.

Returns the event handler for the popup. All event listeners belonging to this handler are removed when the tooltip is hidden. Therefore, the recommended usage of this handler is to listen on events in #onShow.

Returns the time when the popup was last hidden.

Returns the time when the popup was last shown.

Gets the goog.events.ListenableKey for the event or null if no such listener is in use.

Gets all listeners in this listenable for the given type and capture mode.

Returns the parent of this event target to use for capture/bubble mechanism.

NOTE(chrishenry): The name reflects the original implementation of custom event target (goog.events.EventTarget). We decided that changing the name is not worth it.

Whether there is any active listeners matching the specified signature. If either the type or capture parameters are unspecified, the function will match on the remaining criteria.

Hides the popup element.

Returns whether the popup is currently visible or was visible within about 150 ms ago. This is used by clients to handle a very specific, but common, popup scenario. The button that launches the popup should close the popup on mouse down if the popup is already open. The problem is that the popup closes itself during the capture phase of the mouse down and thus the button thinks it's hidden and this should show it again. This method provides a good heuristic for clients. Typically in their event handler they will have code that is:

if (menu.isOrWasRecentlyVisible()) { menu.setVisible(false); } else { ... // code to position menu and initialize other state menu.setVisible(true); }

Returns whether the popup is currently visible.

Adds an event listener. A listener can only be added once to an object and if it is added again the key for the listener is returned. Note that if the existing listener is a one-off listener (registered via listenOnce), it will no longer be a one-off listener after a call to listen().

Adds an event listener that is removed automatically after the listener fired once.

If an existing listener already exists, listenOnce will do nothing. In particular, if the listener was previously registered via listen(), listenOnce() will not turn the listener into a one-off listener. Similarly, if there is already an existing one-off listener, listenOnce does not modify the listeners (it is still a once listener).

Called before the popup is hidden. Derived classes can override to hook this event but should make sure to call the parent class method.

Called before the popup is shown. Derived classes can override to hook this event but should make sure to call the parent class method.

Called after the popup is hidden. Derived classes can override to hook this event but should make sure to call the parent class method.

Called after the popup is shown. Derived classes can override to hook this event but should make sure to call the parent class method.

Associates a disposable object with this object so that they will be disposed together.

Removes all listeners from this listenable. If type is specified, it will only remove listeners of the particular type. otherwise all registered listeners will be removed.

Removes a previously registered auto hide partner.

Removes an event listener from the event target. The handler must be the same object as the one added. If the handler has not been added then nothing is done.

Repositions the popup according to the current state. Should be overriden by subclases.

Sets whether the Popup dismisses itself when the user clicks outside of it.

Sets the region inside which the Popup dismisses itself when the user clicks.

Specifies the dom element that should be used for the popup.

Sets whether clicks in other iframes should dismiss this popup. In some cases it should be disabled, because it can cause spurious

Sets whether the Popup dismisses itself on the escape key.

Sets the parent of this event target to use for capture/bubble mechanism.

Sets whether the popup should hide itself asynchronously using a timeout instead of synchronously.

Sets the target to be used for event.target when firing event. Mainly used for testing. For example, see goog.testing.events.mixinListenable.

Sets transition animation on showing and hiding the popup.

Specifies the type of popup to use.

Sets whether the popup should be visible. After this method returns, isVisible() will always return the new state, even if there is a transition.

Returns whether the popup should hide itself asynchronously using a timeout instead of synchronously.

Shows the popup element.

Removes an event listener which was added with listen() or listenOnce().

Removes an event listener which was added with listen() by the key returned by listen().

If monitoring the goog.Disposable instances is enabled, stores the creation stack trace of the Disposable instance.

A time in ms used to debounce events that happen right after each other.

A note about why this is necessary. There are two cases to consider. First case, a popup will usually see a focus event right after it's launched because it's typical for it to be launched in a mouse-down event which will then move focus to the launching button. We don't want to think this is a separate user action moving focus. Second case, a user clicks on the launcher button to close the menu. In that case, we'll close the menu in the focus event and then show it again because of the mouse down event, even though the intention is to just close the menu. This workaround appears to be the least intrusive fix.