| Fields Summary |
|---|
| private static final String | TAG |
| private static final boolean | DEBUG |
| private static final int | EXPAND_LIST_TIMEOUTThis value controls the length of time that the user
must leave a pointer down without scrolling to expand
the autocomplete dropdown list to cover the IME. |
| private android.content.Context | mContext |
| private PopupWindow | mPopup |
| private ListAdapter | mAdapter |
| private DropDownListView | mDropDownList |
| private int | mDropDownHeight |
| private int | mDropDownWidth |
| private int | mDropDownHorizontalOffset |
| private int | mDropDownVerticalOffset |
| private boolean | mDropDownVerticalOffsetSet |
| private int | mDropDownGravity |
| private boolean | mDropDownAlwaysVisible |
| private boolean | mForceIgnoreOutsideTouch |
| int | mListItemExpandMaximum |
| private android.view.View | mPromptView |
| private int | mPromptPosition |
| private android.database.DataSetObserver | mObserver |
| private android.view.View | mDropDownAnchorView |
| private android.graphics.drawable.Drawable | mDropDownListHighlight |
| private AdapterView.OnItemClickListener | mItemClickListener |
| private AdapterView.OnItemSelectedListener | mItemSelectedListener |
| private final ResizePopupRunnable | mResizePopupRunnable |
| private final PopupTouchInterceptor | mTouchInterceptor |
| private final PopupScrollListener | mScrollListener |
| private final ListSelectorHider | mHideSelector |
| private Runnable | mShowDropDownRunnable |
| private android.os.Handler | mHandler |
| private android.graphics.Rect | mTempRect |
| private boolean | mModal |
| private int | mLayoutDirection |
| public static final int | POSITION_PROMPT_ABOVEThe provided prompt view should appear above list content. |
| public static final int | POSITION_PROMPT_BELOWThe provided prompt view should appear below list content. |
| public static final int | MATCH_PARENTAlias for {@link ViewGroup.LayoutParams#MATCH_PARENT}.
If used to specify a popup width, the popup will match the width of the anchor view.
If used to specify a popup height, the popup will fill available space. |
| public static final int | WRAP_CONTENTAlias for {@link ViewGroup.LayoutParams#WRAP_CONTENT}.
If used to specify a popup width, the popup will use the width of its content. |
| public static final int | INPUT_METHOD_FROM_FOCUSABLEMode 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. |
| public static final int | INPUT_METHOD_NEEDEDMode 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. |
| public static final int | INPUT_METHOD_NOT_NEEDEDMode 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. |
| Methods Summary |
|---|
| private int | buildDropDown()Builds the popup window's content and returns the height the popup
should have. Returns -1 when the content already exists.
ViewGroup dropDownView;
int otherHeights = 0;
if (mDropDownList == null) {
Context context = mContext;
/**
* This Runnable exists for the sole purpose of checking if the view layout has got
* completed and if so call showDropDown to display the drop down. This is used to show
* the drop down as soon as possible after user opens up the search dialog, without
* waiting for the normal UI pipeline to do it's job which is slower than this method.
*/
mShowDropDownRunnable = new Runnable() {
public void run() {
// View layout should be all done before displaying the drop down.
View view = getAnchorView();
if (view != null && view.getWindowToken() != null) {
show();
}
}
};
mDropDownList = new DropDownListView(context, !mModal);
if (mDropDownListHighlight != null) {
mDropDownList.setSelector(mDropDownListHighlight);
}
mDropDownList.setAdapter(mAdapter);
mDropDownList.setOnItemClickListener(mItemClickListener);
mDropDownList.setFocusable(true);
mDropDownList.setFocusableInTouchMode(true);
mDropDownList.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
public void onItemSelected(AdapterView<?> parent, View view,
int position, long id) {
if (position != -1) {
DropDownListView dropDownList = mDropDownList;
if (dropDownList != null) {
dropDownList.mListSelectionHidden = false;
}
}
}
public void onNothingSelected(AdapterView<?> parent) {
}
});
mDropDownList.setOnScrollListener(mScrollListener);
if (mItemSelectedListener != null) {
mDropDownList.setOnItemSelectedListener(mItemSelectedListener);
}
dropDownView = mDropDownList;
View hintView = mPromptView;
if (hintView != null) {
// if a hint has been specified, we accomodate more space for it and
// add a text view in the drop down menu, at the bottom of the list
LinearLayout hintContainer = new LinearLayout(context);
hintContainer.setOrientation(LinearLayout.VERTICAL);
LinearLayout.LayoutParams hintParams = new LinearLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, 0, 1.0f
);
switch (mPromptPosition) {
case POSITION_PROMPT_BELOW:
hintContainer.addView(dropDownView, hintParams);
hintContainer.addView(hintView);
break;
case POSITION_PROMPT_ABOVE:
hintContainer.addView(hintView);
hintContainer.addView(dropDownView, hintParams);
break;
default:
Log.e(TAG, "Invalid hint position " + mPromptPosition);
break;
}
// measure the hint's height to find how much more vertical space
// we need to add to the drop down's height
int widthSpec = MeasureSpec.makeMeasureSpec(mDropDownWidth, MeasureSpec.AT_MOST);
int heightSpec = MeasureSpec.UNSPECIFIED;
hintView.measure(widthSpec, heightSpec);
hintParams = (LinearLayout.LayoutParams) hintView.getLayoutParams();
otherHeights = hintView.getMeasuredHeight() + hintParams.topMargin
+ hintParams.bottomMargin;
dropDownView = hintContainer;
}
mPopup.setContentView(dropDownView);
} else {
dropDownView = (ViewGroup) mPopup.getContentView();
final View view = mPromptView;
if (view != null) {
LinearLayout.LayoutParams hintParams =
(LinearLayout.LayoutParams) view.getLayoutParams();
otherHeights = view.getMeasuredHeight() + hintParams.topMargin
+ hintParams.bottomMargin;
}
}
// getMaxAvailableHeight() subtracts the padding, so we put it back
// to get the available height for the whole window
int padding = 0;
Drawable background = mPopup.getBackground();
if (background != null) {
background.getPadding(mTempRect);
padding = mTempRect.top + mTempRect.bottom;
// If we don't have an explicit vertical offset, determine one from the window
// background so that content will line up.
if (!mDropDownVerticalOffsetSet) {
mDropDownVerticalOffset = -mTempRect.top;
}
} else {
mTempRect.setEmpty();
}
// Max height available on the screen for a popup.
boolean ignoreBottomDecorations =
mPopup.getInputMethodMode() == PopupWindow.INPUT_METHOD_NOT_NEEDED;
final int maxHeight = mPopup.getMaxAvailableHeight(
getAnchorView(), mDropDownVerticalOffset, ignoreBottomDecorations);
if (mDropDownAlwaysVisible || mDropDownHeight == ViewGroup.LayoutParams.MATCH_PARENT) {
return maxHeight + padding;
}
final int childWidthSpec;
switch (mDropDownWidth) {
case ViewGroup.LayoutParams.WRAP_CONTENT:
childWidthSpec = MeasureSpec.makeMeasureSpec(
mContext.getResources().getDisplayMetrics().widthPixels -
(mTempRect.left + mTempRect.right),
MeasureSpec.AT_MOST);
break;
case ViewGroup.LayoutParams.MATCH_PARENT:
childWidthSpec = MeasureSpec.makeMeasureSpec(
mContext.getResources().getDisplayMetrics().widthPixels -
(mTempRect.left + mTempRect.right),
MeasureSpec.EXACTLY);
break;
default:
childWidthSpec = MeasureSpec.makeMeasureSpec(mDropDownWidth, MeasureSpec.EXACTLY);
break;
}
final int listContent = mDropDownList.measureHeightOfChildren(childWidthSpec,
0, ListView.NO_POSITION, maxHeight - otherHeights, -1);
// add padding only if the list has items in it, that way we don't show
// the popup if it is not needed
if (listContent > 0) otherHeights += padding;
return listContent + otherHeights;
|
| public void | clearListSelection()Clear any current list selection.
Only valid when {@link #isShowing()} == {@code true}.
final DropDownListView list = mDropDownList;
if (list != null) {
// WARNING: Please read the comment where mListSelectionHidden is declared
list.mListSelectionHidden = true;
list.hideSelector();
list.requestLayout();
}
|
| public android.view.View.OnTouchListener | createDragToOpenListener(android.view.View src)Returns an {@link OnTouchListener} that can be added to the source view
to implement drag-to-open behavior. Generally, the source view should be
the same view that was passed to {@link #setAnchorView}.
When the listener is set on a view, touching that view and dragging
outside of its bounds will open the popup window. Lifting will select the
currently touched list item.
Example usage:
ListPopupWindow myPopup = new ListPopupWindow(context);
myPopup.setAnchor(myAnchor);
OnTouchListener dragListener = myPopup.createDragToOpenListener(myAnchor);
myAnchor.setOnTouchListener(dragListener);
return new ForwardingListener(src) {
@Override
public ListPopupWindow getPopup() {
return ListPopupWindow.this;
}
};
|
| public void | dismiss()Dismiss the popup window.
mPopup.dismiss();
removePromptView();
mPopup.setContentView(null);
mDropDownList = null;
mHandler.removeCallbacks(mResizePopupRunnable);
|
| public android.view.View | getAnchorView()Returns the view that will be used to anchor this popup.
return mDropDownAnchorView;
|
| public int | getAnimationStyle()Returns the animation style that will be used when the popup window is
shown or dismissed.
return mPopup.getAnimationStyle();
|
| public android.graphics.drawable.Drawable | getBackground()
return mPopup.getBackground();
|
| public int | getHeight()
return mDropDownHeight;
|
| public int | getHorizontalOffset()
return mDropDownHorizontalOffset;
|
| public int | getInputMethodMode()Return the current value in {@link #setInputMethodMode(int)}.
return mPopup.getInputMethodMode();
|
| public ListView | getListView()
return mDropDownList;
|
| public int | getPromptPosition()
return mPromptPosition;
|
| public java.lang.Object | getSelectedItem()
if (!isShowing()) {
return null;
}
return mDropDownList.getSelectedItem();
|
| public long | getSelectedItemId()
if (!isShowing()) {
return ListView.INVALID_ROW_ID;
}
return mDropDownList.getSelectedItemId();
|
| public int | getSelectedItemPosition()
if (!isShowing()) {
return ListView.INVALID_POSITION;
}
return mDropDownList.getSelectedItemPosition();
|
| public android.view.View | getSelectedView()
if (!isShowing()) {
return null;
}
return mDropDownList.getSelectedView();
|
| public int | getSoftInputMode()Returns the current value in {@link #setSoftInputMode(int)}.
return mPopup.getSoftInputMode();
|
| public int | getVerticalOffset()
if (!mDropDownVerticalOffsetSet) {
return 0;
}
return mDropDownVerticalOffset;
|
| public int | getWidth()
return mDropDownWidth;
|
| public boolean | isDropDownAlwaysVisible()
return mDropDownAlwaysVisible;
|
| public boolean | isInputMethodNotNeeded()
return mPopup.getInputMethodMode() == INPUT_METHOD_NOT_NEEDED;
|
| public boolean | isModal()Returns whether the popup window will be modal when shown.
return mModal;
|
| public boolean | isShowing()
return mPopup.isShowing();
|
| public boolean | onKeyDown(int keyCode, android.view.KeyEvent event)Filter key down events. By forwarding key down events to this function,
views using non-modal ListPopupWindow can have it handle key selection of items.
// when the drop down is shown, we drive it directly
if (isShowing()) {
// the key events are forwarded to the list in the drop down view
// note that ListView handles space but we don't want that to happen
// also if selection is not currently in the drop down, then don't
// let center or enter presses go there since that would cause it
// to select one of its items
if (keyCode != KeyEvent.KEYCODE_SPACE
&& (mDropDownList.getSelectedItemPosition() >= 0
|| !KeyEvent.isConfirmKey(keyCode))) {
int curIndex = mDropDownList.getSelectedItemPosition();
boolean consumed;
final boolean below = !mPopup.isAboveAnchor();
final ListAdapter adapter = mAdapter;
boolean allEnabled;
int firstItem = Integer.MAX_VALUE;
int lastItem = Integer.MIN_VALUE;
if (adapter != null) {
allEnabled = adapter.areAllItemsEnabled();
firstItem = allEnabled ? 0 :
mDropDownList.lookForSelectablePosition(0, true);
lastItem = allEnabled ? adapter.getCount() - 1 :
mDropDownList.lookForSelectablePosition(adapter.getCount() - 1, false);
}
if ((below && keyCode == KeyEvent.KEYCODE_DPAD_UP && curIndex <= firstItem) ||
(!below && keyCode == KeyEvent.KEYCODE_DPAD_DOWN && curIndex >= lastItem)) {
// When the selection is at the top, we block the key
// event to prevent focus from moving.
clearListSelection();
mPopup.setInputMethodMode(PopupWindow.INPUT_METHOD_NEEDED);
show();
return true;
} else {
// WARNING: Please read the comment where mListSelectionHidden
// is declared
mDropDownList.mListSelectionHidden = false;
}
consumed = mDropDownList.onKeyDown(keyCode, event);
if (DEBUG) Log.v(TAG, "Key down: code=" + keyCode + " list consumed=" + consumed);
if (consumed) {
// If it handled the key event, then the user is
// navigating in the list, so we should put it in front.
mPopup.setInputMethodMode(PopupWindow.INPUT_METHOD_NOT_NEEDED);
// Here's a little trick we need to do to make sure that
// the list view is actually showing its focus indicator,
// by ensuring it has focus and getting its window out
// of touch mode.
mDropDownList.requestFocusFromTouch();
show();
switch (keyCode) {
// avoid passing the focus from the text view to the
// next component
case KeyEvent.KEYCODE_ENTER:
case KeyEvent.KEYCODE_DPAD_CENTER:
case KeyEvent.KEYCODE_DPAD_DOWN:
case KeyEvent.KEYCODE_DPAD_UP:
return true;
}
} else {
if (below && keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
// when the selection is at the bottom, we block the
// event to avoid going to the next focusable widget
if (curIndex == lastItem) {
return true;
}
} else if (!below && keyCode == KeyEvent.KEYCODE_DPAD_UP &&
curIndex == firstItem) {
return true;
}
}
}
}
return false;
|
| public boolean | onKeyPreIme(int keyCode, android.view.KeyEvent event)Filter pre-IME key events. By forwarding {@link View#onKeyPreIme(int, KeyEvent)}
events to this function, views using ListPopupWindow can have it dismiss the popup
when the back key is pressed.
if (keyCode == KeyEvent.KEYCODE_BACK && isShowing()) {
// special case for the back key, we do not even try to send it
// to the drop down list but instead, consume it immediately
final View anchorView = mDropDownAnchorView;
if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
KeyEvent.DispatcherState state = anchorView.getKeyDispatcherState();
if (state != null) {
state.startTracking(event, this);
}
return true;
} else if (event.getAction() == KeyEvent.ACTION_UP) {
KeyEvent.DispatcherState state = anchorView.getKeyDispatcherState();
if (state != null) {
state.handleUpEvent(event);
}
if (event.isTracking() && !event.isCanceled()) {
dismiss();
return true;
}
}
}
return false;
|
| public boolean | onKeyUp(int keyCode, android.view.KeyEvent event)Filter key down events. By forwarding key up events to this function,
views using non-modal ListPopupWindow can have it handle key selection of items.
if (isShowing() && mDropDownList.getSelectedItemPosition() >= 0) {
boolean consumed = mDropDownList.onKeyUp(keyCode, event);
if (consumed && KeyEvent.isConfirmKey(keyCode)) {
// if the list accepts the key events and the key event was a click, the text view
// gets the selected item from the drop down as its content
dismiss();
}
return consumed;
}
return false;
|
| public boolean | performItemClick(int position)Perform an item click operation on the specified list adapter position.
if (isShowing()) {
if (mItemClickListener != null) {
final DropDownListView list = mDropDownList;
final View child = list.getChildAt(position - list.getFirstVisiblePosition());
final ListAdapter adapter = list.getAdapter();
mItemClickListener.onItemClick(list, child, position, adapter.getItemId(position));
}
return true;
}
return false;
|
| public void | postShow()Post a {@link #show()} call to the UI thread.
mHandler.post(mShowDropDownRunnable);
|
| private void | removePromptView()
if (mPromptView != null) {
final ViewParent parent = mPromptView.getParent();
if (parent instanceof ViewGroup) {
final ViewGroup group = (ViewGroup) parent;
group.removeView(mPromptView);
}
}
|
| public void | setAdapter(ListAdapter adapter)Sets the adapter that provides the data and the views to represent the data
in this popup window.
if (mObserver == null) {
mObserver = new PopupDataSetObserver();
} else if (mAdapter != null) {
mAdapter.unregisterDataSetObserver(mObserver);
}
mAdapter = adapter;
if (mAdapter != null) {
adapter.registerDataSetObserver(mObserver);
}
if (mDropDownList != null) {
mDropDownList.setAdapter(mAdapter);
}
|
| public void | setAnchorView(android.view.View anchor)Sets the popup's anchor view. This popup will always be positioned relative to
the anchor view when shown.
mDropDownAnchorView = anchor;
|
| public void | setAnimationStyle(int animationStyle)Set an animation style to use when the popup window is shown or dismissed.
mPopup.setAnimationStyle(animationStyle);
|
| public void | setBackgroundDrawable(android.graphics.drawable.Drawable d)Sets a drawable to be the background for the popup window.
mPopup.setBackgroundDrawable(d);
|
| public void | setContentWidth(int width)Sets the width of the popup window by the size of its content. The final width may be
larger to accommodate styled window dressing.
Drawable popupBackground = mPopup.getBackground();
if (popupBackground != null) {
popupBackground.getPadding(mTempRect);
mDropDownWidth = mTempRect.left + mTempRect.right + width;
} else {
setWidth(width);
}
|
| public void | setDropDownAlwaysVisible(boolean dropDownAlwaysVisible)Sets whether the drop-down should remain visible under certain conditions.
The drop-down will occupy the entire screen below {@link #getAnchorView} regardless
of the size or content of the list. {@link #getBackground()} will fill any space
that is not used by the list.
mDropDownAlwaysVisible = dropDownAlwaysVisible;
|
| public void | setDropDownGravity(int gravity)Set the gravity of the dropdown list. This is commonly used to
set gravity to START or END for alignment with the anchor.
mDropDownGravity = gravity;
|
| public void | setForceIgnoreOutsideTouch(boolean forceIgnoreOutsideTouch)Forces outside touches to be ignored. Normally if {@link #isDropDownAlwaysVisible()} is
false, we allow outside touch to dismiss the dropdown. If this is set to true, then we
ignore outside touch even when the drop down is not set to always visible.
mForceIgnoreOutsideTouch = forceIgnoreOutsideTouch;
|
| public void | setHeight(int height)Sets the height of the popup window in pixels. Can also be {@link #MATCH_PARENT}.
mDropDownHeight = height;
|
| public void | setHorizontalOffset(int offset)Set the horizontal offset of this popup from its anchor view in pixels.
mDropDownHorizontalOffset = offset;
|
| public void | setInputMethodMode(int mode)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}.
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 the {@link #show()}
method.
mPopup.setInputMethodMode(mode);
|
| void | setListItemExpandMax(int max)The maximum number of list items that can be visible and still have
the list expand when touched.
mListItemExpandMaximum = max;
|
| public void | setListSelector(android.graphics.drawable.Drawable selector)Sets a drawable to use as the list item selector.
mDropDownListHighlight = selector;
|
| public void | setModal(boolean modal)Set whether this window should be modal when shown.
If a popup window is modal, it will receive all touch and key input.
If the user touches outside the popup window's content area the popup window
will be dismissed.
mModal = modal;
mPopup.setFocusable(modal);
|
| public void | setOnDismissListener(PopupWindow.OnDismissListener listener)Set a listener to receive a callback when the popup is dismissed.
mPopup.setOnDismissListener(listener);
|
| public void | setOnItemClickListener(AdapterView.OnItemClickListener clickListener)Sets a listener to receive events when a list item is clicked.
mItemClickListener = clickListener;
|
| public void | setOnItemSelectedListener(AdapterView.OnItemSelectedListener selectedListener)Sets a listener to receive events when a list item is selected.
mItemSelectedListener = selectedListener;
|
| public void | setPromptPosition(int position)Set where the optional prompt view should appear. The default is
{@link #POSITION_PROMPT_ABOVE}.
mPromptPosition = position;
|
| public void | setPromptView(android.view.View prompt)Set a view to act as a user prompt for this popup window. Where the prompt view will appear
is controlled by {@link #setPromptPosition(int)}.
boolean showing = isShowing();
if (showing) {
removePromptView();
}
mPromptView = prompt;
if (showing) {
show();
}
|
| public void | setSelection(int position)Set the selected position of the list.
Only valid when {@link #isShowing()} == {@code true}.
DropDownListView list = mDropDownList;
if (isShowing() && list != null) {
list.mListSelectionHidden = false;
list.setSelection(position);
if (list.getChoiceMode() != ListView.CHOICE_MODE_NONE) {
list.setItemChecked(position, true);
}
}
|
| public void | setSoftInputMode(int mode)Sets the operating mode for the soft input area.
mPopup.setSoftInputMode(mode);
|
| public void | setVerticalOffset(int offset)Set the vertical offset of this popup from its anchor view in pixels.
mDropDownVerticalOffset = offset;
mDropDownVerticalOffsetSet = true;
|
| public void | setWidth(int width)Sets the width of the popup window in pixels. Can also be {@link #MATCH_PARENT}
or {@link #WRAP_CONTENT}.
mDropDownWidth = width;
|
| public void | show()Show the popup list. If the list is already showing, this method
will recalculate the popup's size and position.
int height = buildDropDown();
int widthSpec = 0;
int heightSpec = 0;
boolean noInputMethod = isInputMethodNotNeeded();
mPopup.setAllowScrollingAnchorParent(!noInputMethod);
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);
mPopup.setClipToScreenEnabled(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);
mPopup.showAsDropDown(getAnchorView(), mDropDownHorizontalOffset,
mDropDownVerticalOffset, mDropDownGravity);
mDropDownList.setSelection(ListView.INVALID_POSITION);
if (!mModal || mDropDownList.isInTouchMode()) {
clearListSelection();
}
if (!mModal) {
mHandler.post(mHideSelector);
}
}
|
