/**@class android.widget.PopupWindow
@extends java.lang.Object

 <p>
 This class represents a popup window that can be used to display an
 arbitrary view. The popup window is a floating container that appears on top
 of the current activity.
 </p>
 <a name="Animation"></a>
 <h3>Animation</h3>
 <p>
 On all versions of Android, popup window enter and exit animations may be
 specified by calling {@link #setAnimationStyle}(int) and passing the
 resource ID for an animation style that defines {@code windowEnterAnimation}
 and {@code windowExitAnimation}. For example, passing
 {@link android.R.style#Animation_Dialog} will give a scale and alpha
 animation.
 </br>
 A window animation style may also be specified in the popup window's style
 XML via the {@link android.R.styleable#PopupWindow_popupAnimationStyle popupAnimationStyle}
 attribute.
 </p>
 <p>
 Starting with API 23, more complex popup window enter and exit transitions
 may be specified by calling either {@link #setEnterTransition}(Transition)
 or {@link #setExitTransition}(Transition) and passing a  {@link Transition}.
 </br>
 Popup enter and exit transitions may also be specified in the popup window's
 style XML via the {@link android.R.styleable#PopupWindow_popupEnterTransition popupEnterTransition}
 and {@link android.R.styleable#PopupWindow_popupExitTransition popupExitTransition}
 attributes, respectively.
 </p>

 @attr ref android.R.styleable#PopupWindow_overlapAnchor
 @attr ref android.R.styleable#PopupWindow_popupAnimationStyle
 @attr ref android.R.styleable#PopupWindow_popupBackground
 @attr ref android.R.styleable#PopupWindow_popupElevation
 @attr ref android.R.styleable#PopupWindow_popupEnterTransition
 @attr ref android.R.styleable#PopupWindow_popupExitTransition

 @see android.widget.AutoCompleteTextView
 @see android.widget.Spinner
*/
var PopupWindow = {

/** Mode for {@link #setInputMethodMode}(int): the requirements for the
 input method should be based on the focusability of the popup.  That is
 if it is focusable than it needs to work with the input method, else
 it doesn't.
*/
INPUT_METHOD_FROM_FOCUSABLE : "0",
/** Mode for {@link #setInputMethodMode}(int): this popup always needs to
 work with an input method, regardless of whether it is focusable.  This
 means that it will always be displayed so that the user can also operate
 the input method while it is shown.
*/
INPUT_METHOD_NEEDED : "1",
/** Mode for {@link #setInputMethodMode}(int): this popup never needs to
 work with an input method, regardless of whether it is focusable.  This
 means that it will always be displayed to use as much space on the
 screen as needed, regardless of whether this covers the input method.
*/
INPUT_METHOD_NOT_NEEDED : "2",
/**Sets the enter transition to be used when the popup window is shown.
@param {Object {Transition}} enterTransition the enter transition, or {@code null} to clear
@see #getEnterTransition()
@attr ref android.R.styleable#PopupWindow_popupEnterTransition
*/
setEnterTransition : function(  ) {},

/**Returns the enter transition to be used when the popup window is shown.
@return {Object {android.transition.Transition}} the enter transition, or {@code null} if not set
@see #setEnterTransition(Transition)
@attr ref android.R.styleable#PopupWindow_popupEnterTransition
*/
getEnterTransition : function(  ) {},

/**Sets the exit transition to be used when the popup window is dismissed.
@param {Object {Transition}} exitTransition the exit transition, or {@code null} to clear
@see #getExitTransition()
@attr ref android.R.styleable#PopupWindow_popupExitTransition
*/
setExitTransition : function(  ) {},

/**Returns the exit transition to be used when the popup window is
 dismissed.
@return {Object {android.transition.Transition}} the exit transition, or {@code null} if not set
@see #setExitTransition(Transition)
@attr ref android.R.styleable#PopupWindow_popupExitTransition
*/
getExitTransition : function(  ) {},

/**<p>Returns bounds which are used as a center of the enter and exit transitions.<p/>

 <p>Transitions use Rect, referred to as the epicenter, to orient
 the direction of travel. For popup windows, the anchor view bounds are
 used as the default epicenter.</p>

 <p>See {@link Transition#setEpicenterCallback(EpicenterCallback)} for more
 information about how transition epicenters work.</p>
@return {Object {android.graphics.Rect}} bounds relative to anchor view, or {@code null} if not set
@see #setEpicenterBounds(Rect)
*/
getEpicenterBounds : function(  ) {},

/**<p>Sets the bounds used as the epicenter of the enter and exit transitions.</p>

 <p>Transitions use Rect, referred to as the epicenter, to orient
 the direction of travel. For popup windows, the anchor view bounds are
 used as the default epicenter.</p>

 <p>See {@link Transition#setEpicenterCallback(EpicenterCallback)} for more
 information about how transition epicenters work.</p>
@param {Object {Rect}} bounds the epicenter bounds relative to the anchor view, or
               {@code null} to use the default epicenter
@see #getEpicenterBounds()
*/
setEpicenterBounds : function(  ) {},

/**Return the drawable used as the popup window's background.
@return {Object {android.graphics.drawable.Drawable}} the background drawable or {@code null} if not set
@see #setBackgroundDrawable(Drawable)
@attr ref android.R.styleable#PopupWindow_popupBackground
*/
getBackground : function(  ) {},

/**Specifies the background drawable for this popup window. The background
 can be set to {@code null}.
@param {Object {Drawable}} background the popup's background
@see #getBackground()
@attr ref android.R.styleable#PopupWindow_popupBackground
*/
setBackgroundDrawable : function(  ) {},

/**
@return {Number} the elevation for this popup window in pixels
@see #setElevation(float)
@attr ref android.R.styleable#PopupWindow_popupElevation
*/
getElevation : function(  ) {},

/**Specifies the elevation for this popup window.
@param {Number} elevation the popup's elevation in pixels
@see #getElevation()
@attr ref android.R.styleable#PopupWindow_popupElevation
*/
setElevation : function(  ) {},

/**<p>Return the animation style to use the popup appears and disappears</p>
@return {Number} the animation style to use the popup appears and disappears
*/
getAnimationStyle : function(  ) {},

/**Set the flag on popup to ignore cheek press events; by default this flag
 is set to false
 which means the popup will not ignore cheek press dispatch events.

 <p>If the popup is showing, calling this method will take effect only
 the next time the popup is shown or through a manual call to one of
 the {@link #update}() methods.</p>
@see #update()
*/
setIgnoreCheekPress : function(  ) {},

/**<p>Change the animation style resource for this popup.</p>

 <p>If the popup is showing, calling this method will take effect only
 the next time the popup is shown or through a manual call to one of
 the {@link #update}() methods.</p>
@param {Number} animationStyle animation style to use when the popup appears
      and disappears.  Set to -1 for the default animation, 0 for no
      animation, or a resource identifier for an explicit animation.
@see #update()
*/
setAnimationStyle : function(  ) {},

/**<p>Return the view used as the content of the popup window.</p>
@return {Object {android.view.View}} a {@link android.view.View} representing the popup's content
@see #setContentView(android.view.View)
*/
getContentView : function(  ) {},

/**<p>Change the popup's content. The content is represented by an instance
 of {@link android.view.View}.</p>

 <p>This method has no effect if called when the popup is showing.</p>
@param {Object {View}} contentView the new content for the popup
@see #getContentView()
@see #isShowing()
*/
setContentView : function(  ) {},

/**Set a callback for all touch events being dispatched to the popup
 window.
*/
setTouchInterceptor : function(  ) {},

/**<p>Indicate whether the popup window can grab the focus.</p>
@return {Boolean} true if the popup is focusable, false otherwise
@see #setFocusable(boolean)
*/
isFocusable : function(  ) {},

/**<p>Changes the focusability of the popup window. When focusable, the
 window will grab the focus from the current focused widget if the popup
 contains a focusable {@link android.view.View}.  By default a popup
 window is not focusable.</p>

 <p>If the popup is showing, calling this method will take effect only
 the next time the popup is shown or through a manual call to one of
 the {@link #update}() methods.</p>
@param {Boolean} focusable true if the popup should grab focus, false otherwise.
@see #isFocusable()
@see #isShowing()
@see #update()
*/
setFocusable : function(  ) {},

/**Return the current value in {@link #setInputMethodMode}(int).
@see #setInputMethodMode(int)
*/
getInputMethodMode : function(  ) {},

/**Control how the popup operates with an input method: one of
 {@link #INPUT_METHOD_FROM_FOCUSABLE}, {@link #INPUT_METHOD_NEEDED},
 or {@link #INPUT_METHOD_NOT_NEEDED}.

 <p>If the popup is showing, calling this method will take effect only
 the next time the popup is shown or through a manual call to one of
 the {@link #update}() methods.</p>
@see #getInputMethodMode()
@see #update()
*/
setInputMethodMode : function(  ) {},

/**Sets the operating mode for the soft input area.
@param {Number} mode The desired mode, see
        {@link android.view.WindowManager.LayoutParams#softInputMode}
        for the full list
@see android.view.WindowManager.LayoutParams#softInputMode
@see #getSoftInputMode()
*/
setSoftInputMode : function(  ) {},

/**Returns the current value in {@link #setSoftInputMode}(int).
@see #setSoftInputMode(int)
@see android.view.WindowManager.LayoutParams#softInputMode
*/
getSoftInputMode : function(  ) {},

/**<p>Indicates whether the popup window receives touch events.</p>
@return {Boolean} true if the popup is touchable, false otherwise
@see #setTouchable(boolean)
*/
isTouchable : function(  ) {},

/**<p>Changes the touchability of the popup window. When touchable, the
 window will receive touch events, otherwise touch events will go to the
 window below it. By default the window is touchable.</p>

 <p>If the popup is showing, calling this method will take effect only
 the next time the popup is shown or through a manual call to one of
 the {@link #update}() methods.</p>
@param {Boolean} touchable true if the popup should receive touch events, false otherwise
@see #isTouchable()
@see #isShowing()
@see #update()
*/
setTouchable : function(  ) {},

/**<p>Indicates whether the popup window will be informed of touch events
 outside of its window.</p>
@return {Boolean} true if the popup is outside touchable, false otherwise
@see #setOutsideTouchable(boolean)
*/
isOutsideTouchable : function(  ) {},

/**<p>Controls whether the pop-up will be informed of touch events outside
 of its window.  This only makes sense for pop-ups that are touchable
 but not focusable, which means touches outside of the window will
 be delivered to the window behind.  The default is false.</p>

 <p>If the popup is showing, calling this method will take effect only
 the next time the popup is shown or through a manual call to one of
 the {@link #update}() methods.</p>
@param {Boolean} touchable true if the popup should receive outside
 touch events, false otherwise
@see #isOutsideTouchable()
@see #isShowing()
@see #update()
*/
setOutsideTouchable : function(  ) {},

/**<p>Indicates whether clipping of the popup window is enabled.</p>
@return {Boolean} true if the clipping is enabled, false otherwise
@see #setClippingEnabled(boolean)
*/
isClippingEnabled : function(  ) {},

/**<p>Allows the popup window to extend beyond the bounds of the screen. By default the
 window is clipped to the screen boundaries. Setting this to false will allow windows to be
 accurately positioned.</p>

 <p>If the popup is showing, calling this method will take effect only
 the next time the popup is shown or through a manual call to one of
 the {@link #update}() methods.</p>
@param {Boolean} enabled false if the window should be allowed to extend outside of the screen
@see #isShowing()
@see #isClippingEnabled()
@see #update()
*/
setClippingEnabled : function(  ) {},

/**<p>Indicates whether this popup will be clipped to the screen and not to the
 containing window<p/>
@return {Boolean} true if popup will be clipped to the screen instead of the window, false otherwise
@deprecated Use {@link #isClippedToScreen()} instead
@removed 
*/
isClipToScreenEnabled : function(  ) {},

/**<p>Clip this popup window to the screen, but not to the containing window.</p>

 <p>If the popup is showing, calling this method will take effect only
 the next time the popup is shown or through a manual call to one of
 the {@link #update}() methods.</p>
@deprecated Use {@link #setIsClippedToScreen(boolean)} instead
@removed 
*/
setClipToScreenEnabled : function(  ) {},

/**<p>Indicates whether this popup will be clipped to the screen and not to the
 containing window<p/>
@return {Boolean} true if popup will be clipped to the screen instead of the window, false otherwise
@see #setIsClippedToScreen(boolean)
*/
isClippedToScreen : function(  ) {},

/**<p>Clip this popup window to the screen, but not to the containing window.</p>

 <p>If the popup is showing, calling this method will take effect only
 the next time the popup is shown or through a manual call to one of
 the {@link #update}() methods.</p>
@param {Boolean} enabled true to clip to the screen.
@see #isClippedToScreen()
*/
setIsClippedToScreen : function(  ) {},

/**<p>Indicates whether the popup window supports splitting touches.</p>
@return {Boolean} true if the touch splitting is enabled, false otherwise
@see #setSplitTouchEnabled(boolean)
*/
isSplitTouchEnabled : function(  ) {},

/**<p>Allows the popup window to split touches across other windows that also
 support split touch.  When this flag is false, the first pointer
 that goes down determines the window to which all subsequent touches
 go until all pointers go up.  When this flag is true, each pointer
 (not necessarily the first) that goes down determines the window
 to which all subsequent touches of that pointer will go until that
 pointer goes up thereby enabling touches with multiple pointers
 to be split across multiple windows.</p>
@param {Boolean} enabled true if the split touches should be enabled, false otherwise
@see #isSplitTouchEnabled()
*/
setSplitTouchEnabled : function(  ) {},

/**<p>Indicates whether the popup window will be forced into using absolute screen coordinates
 for positioning.</p>
@return {Boolean} true if the window will always be positioned in screen coordinates.
@deprecated Use {@link #isLaidOutInScreen()} instead
@removed 
*/
isLayoutInScreenEnabled : function(  ) {},

/**<p>Allows the popup window to force the flag
 {@link WindowManager.LayoutParams#FLAG_LAYOUT_IN_SCREEN}, overriding default behavior.
 This will cause the popup to be positioned in absolute screen coordinates.</p>
@param {Boolean} enabled true if the popup should always be positioned in screen coordinates
@deprecated Use {@link #setIsLaidOutInScreen(boolean)} instead
@removed 
*/
setLayoutInScreenEnabled : function(  ) {},

/**<p>Indicates whether the popup window will be forced into using absolute screen coordinates
 for positioning.</p>
@return {Boolean} true if the window will always be positioned in screen coordinates.
@see #setIsLaidOutInScreen(boolean)
*/
isLaidOutInScreen : function(  ) {},

/**<p>Allows the popup window to force the flag
 {@link WindowManager.LayoutParams#FLAG_LAYOUT_IN_SCREEN}, overriding default behavior.
 This will cause the popup to be positioned in absolute screen coordinates.</p>
@param {Boolean} enabled true if the popup should always be positioned in screen coordinates
@see #isLaidOutInScreen()
*/
setIsLaidOutInScreen : function(  ) {},

/**<p>Indicates whether the popup window will be attached in the decor frame of its parent
 window.
@return {Boolean} true if the window will be attached to the decor frame of its parent window.
@see #setAttachedInDecor(boolean)
@see WindowManager.LayoutParams#FLAG_LAYOUT_ATTACHED_IN_DECOR
*/
isAttachedInDecor : function(  ) {},

/**<p>This will attach the popup window to the decor frame of the parent window to avoid
 overlaping with screen decorations like the navigation bar. Overrides the default behavior of
 the flag {@link WindowManager.LayoutParams#FLAG_LAYOUT_ATTACHED_IN_DECOR}.

 <p>By default the flag is set on SDK version {@link Build.VERSION_CODES#LOLLIPOP_MR1} or
 greater and cleared on lesser SDK versions.
@param {Boolean} enabled true if the popup should be attached to the decor frame of its parent window.
@see WindowManager.LayoutParams#FLAG_LAYOUT_ATTACHED_IN_DECOR
*/
setAttachedInDecor : function(  ) {},

/**Allows the popup window to force the flag
 {@link WindowManager.LayoutParams#FLAG_LAYOUT_INSET_DECOR}, overriding default behavior.
 This will cause the popup to inset its content to account for system windows overlaying
 the screen, such as the status bar.

 <p>This will often be combined with {@link #setIsLaidOutInScreen}(boolean).
@param {Boolean} enabled true if the popup's views should inset content to account for system windows,
                the way that decor views behave for full-screen windows.
@hide 
*/
setLayoutInsetDecor : function(  ) {},

/**Set the layout type for this window.
 <p>
 See {@link WindowManager.LayoutParams#type} for possible values.
@param {Number} layoutType Layout type for this window.
@see WindowManager.LayoutParams#type
*/
setWindowLayoutType : function(  ) {},

/**Returns the layout type for this window.
@see #setWindowLayoutType(int)
*/
getWindowLayoutType : function(  ) {},

/**<p>Indicates whether outside touches will be sent to this window
 or other windows behind it<p/>
@return {Boolean} true if touches will be sent to this window, false otherwise
@see #setTouchModal(boolean)
*/
isTouchModal : function(  ) {},

/**<p>Set whether this window is touch modal or if outside touches will be sent to
 other windows behind it.<p/>

 <p>If the popup is showing, calling this method will take effect only
 the next time the popup is shown or through a manual call to one of
 the {@link #update}() methods.</p>
@param {Boolean} touchModal true to sent all outside touches to this window,
 false to other windows behind it
@see #isTouchModal()
*/
setTouchModal : function(  ) {},

/**<p>Change the width and height measure specs that are given to the
 window manager by the popup.  By default these are 0, meaning that
 the current width or height is requested as an explicit size from
 the window manager.  You can supply
 {@link ViewGroup.LayoutParams#WRAP_CONTENT} or
 {@link ViewGroup.LayoutParams#MATCH_PARENT} to have that measure
 spec supplied instead, replacing the absolute width and height that
 has been set in the popup.</p>

 <p>If the popup is showing, calling this method will take effect only
 the next time the popup is shown.</p>
@param {Number} widthSpec an explicit width measure spec mode, either
 {@link ViewGroup.LayoutParams#WRAP_CONTENT},
 {@link ViewGroup.LayoutParams#MATCH_PARENT}, or 0 to use the absolute
 width.
@param {Number} heightSpec an explicit height measure spec mode, either
 {@link ViewGroup.LayoutParams#WRAP_CONTENT},
 {@link ViewGroup.LayoutParams#MATCH_PARENT}, or 0 to use the absolute
 height.
@deprecated Use {@link #setWidth(int)} and {@link #setHeight(int)}.
*/
setWindowLayoutMode : function(  ) {},

/**Returns the popup's requested height. May be a layout constant such as
 {@link android.widget.AbsListView.LayoutParams#WRAP_CONTENT} or {@link android.widget.AbsListView.LayoutParams#MATCH_PARENT}.
 <p>
 The actual size of the popup may depend on other factors such as
 clipping and window layout.
@return {Number} the popup height in pixels or a layout constant
@see #setHeight(int)
*/
getHeight : function(  ) {},

/**Sets the popup's requested height. May be a layout constant such as
 {@link android.widget.AbsListView.LayoutParams#WRAP_CONTENT} or {@link android.widget.AbsListView.LayoutParams#MATCH_PARENT}.
 <p>
 The actual size of the popup may depend on other factors such as
 clipping and window layout.
 <p>
 If the popup is showing, calling this method will take effect the next
 time the popup is shown.
@param {Number} height the popup height in pixels or a layout constant
@see #getHeight()
@see #isShowing()
*/
setHeight : function(  ) {},

/**Returns the popup's requested width. May be a layout constant such as
 {@link android.widget.AbsListView.LayoutParams#WRAP_CONTENT} or {@link android.widget.AbsListView.LayoutParams#MATCH_PARENT}.
 <p>
 The actual size of the popup may depend on other factors such as
 clipping and window layout.
@return {Number} the popup width in pixels or a layout constant
@see #setWidth(int)
*/
getWidth : function(  ) {},

/**Sets the popup's requested width. May be a layout constant such as
 {@link android.widget.AbsListView.LayoutParams#WRAP_CONTENT} or {@link android.widget.AbsListView.LayoutParams#MATCH_PARENT}.
 <p>
 The actual size of the popup may depend on other factors such as
 clipping and window layout.
 <p>
 If the popup is showing, calling this method will take effect the next
 time the popup is shown.
@param {Number} width the popup width in pixels or a layout constant
@see #getWidth()
@see #isShowing()
*/
setWidth : function(  ) {},

/**Sets whether the popup window should overlap its anchor view when
 displayed as a drop-down.
 <p>
 If the popup is showing, calling this method will take effect only
 the next time the popup is shown.
@param {Boolean} overlapAnchor Whether the popup should overlap its anchor.
@see #getOverlapAnchor()
@see #isShowing()
*/
setOverlapAnchor : function(  ) {},

/**Returns whether the popup window should overlap its anchor view when
 displayed as a drop-down.
@return {Boolean} Whether the popup should overlap its anchor.
@see #setOverlapAnchor(boolean)
*/
getOverlapAnchor : function(  ) {},

/**<p>Indicate whether this popup window is showing on screen.</p>
@return {Boolean} true if the popup is showing, false otherwise
*/
isShowing : function(  ) {},

/**<p>
 Display the content view in a popup window at the specified location. If the popup window
 cannot fit on screen, it will be clipped. See {@link android.view.WindowManager.LayoutParams}
 for more information on how gravity and the x and y parameters are related. Specifying
 a gravity of {@link android.view.Gravity#NO_GRAVITY} is similar to specifying
 <code>Gravity.LEFT | Gravity.TOP</code>.
 </p>
@param {Object {View}} parent a parent view to get the {@link android.view.View#getWindowToken()} token from
@param {Number} gravity the gravity which controls the placement of the popup window
@param {Number} x the popup's x location offset
@param {Number} y the popup's y location offset
*/
showAtLocation : function(  ) {},

/**Display the content view in a popup window at the specified location.
@param {Object {IBinder}} token Window token to use for creating the new window
@param {Number} gravity the gravity which controls the placement of the popup window
@param {Number} x the popup's x location offset
@param {Number} y the popup's y location offset
@hide Internal use only. Applications should use
       {@link #showAtLocation(View, int, int, int)} instead.
*/
showAtLocation : function(  ) {},

/**Display the content view in a popup window anchored to the bottom-left
 corner of the anchor view. If there is not enough room on screen to show
 the popup in its entirety, this method tries to find a parent scroll
 view to scroll. If no parent scroll view can be scrolled, the
 bottom-left corner of the popup is pinned at the top left corner of the
 anchor view.
@param {Object {View}} anchor the view on which to pin the popup window
@see #dismiss()
*/
showAsDropDown : function(  ) {},

/**Display the content view in a popup window anchored to the bottom-left
 corner of the anchor view offset by the specified x and y coordinates.
 If there is not enough room on screen to show the popup in its entirety,
 this method tries to find a parent scroll view to scroll. If no parent
 scroll view can be scrolled, the bottom-left corner of the popup is
 pinned at the top left corner of the anchor view.
 <p>
 If the view later scrolls to move <code>anchor</code> to a different
 location, the popup will be moved correspondingly.
@param {Object {View}} anchor the view on which to pin the popup window
@param {Number} xoff A horizontal offset from the anchor in pixels
@param {Number} yoff A vertical offset from the anchor in pixels
@see #dismiss()
*/
showAsDropDown : function(  ) {},

/**Displays the content view in a popup window anchored to the corner of
 another view. The window is positioned according to the specified
 gravity and offset by the specified x and y coordinates.
 <p>
 If there is not enough room on screen to show the popup in its entirety,
 this method tries to find a parent scroll view to scroll. If no parent
 view can be scrolled, the specified vertical gravity will be ignored and
 the popup will anchor itself such that it is visible.
 <p>
 If the view later scrolls to move <code>anchor</code> to a different
 location, the popup will be moved correspondingly.
@param {Object {View}} anchor the view on which to pin the popup window
@param {Number} xoff A horizontal offset from the anchor in pixels
@param {Number} yoff A vertical offset from the anchor in pixels
@param {Number} gravity Alignment of the popup relative to the anchor
@see #dismiss()
*/
showAsDropDown : function(  ) {},

/**Indicates whether the popup is showing above (the y coordinate of the popup's bottom
 is less than the y coordinate of the anchor) or below the anchor view (the y coordinate
 of the popup is greater than y coordinate of the anchor's bottom).

 The value returned
 by this method is meaningful only after {@link #showAsDropDown(android.view.View)}
 or {@link #showAsDropDown(android.view.View, int, int)} was invoked.
@return {Boolean} True if this popup is showing above the anchor view, false otherwise.
*/
isAboveAnchor : function(  ) {},

/**Returns the maximum height that is available for the popup to be
 completely shown. It is recommended that this height be the maximum for
 the popup's height, otherwise it is possible that the popup will be
 clipped.
@param {Object {View}} anchor The view on which the popup window must be anchored.
@return {Number} The maximum available height for the popup to be completely
         shown.
*/
getMaxAvailableHeight : function(  ) {},

/**Returns the maximum height that is available for the popup to be
 completely shown. It is recommended that this height be the maximum for
 the popup's height, otherwise it is possible that the popup will be
 clipped.
@param {Object {View}} anchor The view on which the popup window must be anchored.
@param {Number} yOffset y offset from the view's bottom edge
@return {Number} The maximum available height for the popup to be completely
         shown.
*/
getMaxAvailableHeight : function(  ) {},

/**Returns the maximum height that is available for the popup to be
 completely shown, optionally ignoring any bottom decorations such as
 the input method. It is recommended that this height be the maximum for
 the popup's height, otherwise it is possible that the popup will be
 clipped.
@param {Object {View}} anchor The view on which the popup window must be anchored.
@param {Number} yOffset y offset from the view's bottom edge
@param {Boolean} ignoreBottomDecorations if true, the height returned will be
        all the way to the bottom of the display, ignoring any
        bottom decorations
@return {Number} The maximum available height for the popup to be completely
         shown.
*/
getMaxAvailableHeight : function(  ) {},

/**Disposes of the popup window. This method can be invoked only after
 {@link #showAsDropDown(android.view.View)} has been executed. Failing
 that, calling this method will have no effect.
@see #showAsDropDown(android.view.View)
*/
dismiss : function(  ) {},

/**Sets the listener to be called when the window is dismissed.
@param {Object {PopupWindow.OnDismissListener}} onDismissListener The listener.
*/
setOnDismissListener : function(  ) {},

/**Updates the state of the popup window, if it is currently being displayed,
 from the currently set state.
 <p>
 This includes:
 <ul>
     <li>{@link #setClippingEnabled}(boolean)</li>
     <li>{@link #setFocusable}(boolean)</li>
     <li>{@link #setIgnoreCheekPress}()</li>
     <li>{@link #setInputMethodMode}(int)</li>
     <li>{@link #setTouchable}(boolean)</li>
     <li>{@link #setAnimationStyle}(int)</li>
     <li>{@link #setTouchModal}(boolean) (boolean)}</li>
     <li>{@link #setIsClippedToScreen}(boolean)</li>
 </ul>
*/
update : function(  ) {},

/**Updates the dimension of the popup window.
 <p>
 Calling this function also updates the window with the current popup
 state as described for {@link #update}().
@param {Number} width the new width in pixels, must be >= 0 or -1 to ignore
@param {Number} height the new height in pixels, must be >= 0 or -1 to ignore
*/
update : function(  ) {},

/**Updates the position and the dimension of the popup window.
 <p>
 Width and height can be set to -1 to update location only. Calling this
 function also updates the window with the current popup state as
 described for {@link #update}().
@param {Number} x the new x location
@param {Number} y the new y location
@param {Number} width the new width in pixels, must be >= 0 or -1 to ignore
@param {Number} height the new height in pixels, must be >= 0 or -1 to ignore
*/
update : function(  ) {},

/**Updates the position and the dimension of the popup window.
 <p>
 Width and height can be set to -1 to update location only. Calling this
 function also updates the window with the current popup state as
 described for {@link #update}().
@param {Number} x the new x location
@param {Number} y the new y location
@param {Number} width the new width in pixels, must be >= 0 or -1 to ignore
@param {Number} height the new height in pixels, must be >= 0 or -1 to ignore
@param {Boolean} force {@code true} to reposition the window even if the specified
              position already seems to correspond to the LayoutParams,
              {@code false} to only reposition if needed
*/
update : function(  ) {},

/**Updates the position and the dimension of the popup window.
 <p>
 Calling this function also updates the window with the current popup
 state as described for {@link #update}().
@param {Object {View}} anchor the popup's anchor view
@param {Number} width the new width in pixels, must be >= 0 or -1 to ignore
@param {Number} height the new height in pixels, must be >= 0 or -1 to ignore
*/
update : function(  ) {},

/**Updates the position and the dimension of the popup window.
 <p>
 Width and height can be set to -1 to update location only. Calling this
 function also updates the window with the current popup state as
 described for {@link #update}().
 <p>
 If the view later scrolls to move {@code anchor} to a different
 location, the popup will be moved correspondingly.
@param {Object {View}} anchor the popup's anchor view
@param {Number} xoff x offset from the view's left edge
@param {Number} yoff y offset from the view's bottom edge
@param {Number} width the new width in pixels, must be >= 0 or -1 to ignore
@param {Number} height the new height in pixels, must be >= 0 or -1 to ignore
*/
update : function(  ) {},


};