diff options
Diffstat (limited to 'android/3rd_party/HoloEverywhere/library/src/org/holoeverywhere/widget/ListPopupWindow.java')
| -rw-r--r-- | android/3rd_party/HoloEverywhere/library/src/org/holoeverywhere/widget/ListPopupWindow.java | 858 |
1 files changed, 858 insertions, 0 deletions
diff --git a/android/3rd_party/HoloEverywhere/library/src/org/holoeverywhere/widget/ListPopupWindow.java b/android/3rd_party/HoloEverywhere/library/src/org/holoeverywhere/widget/ListPopupWindow.java new file mode 100644 index 0000000000..de3f287e62 --- /dev/null +++ b/android/3rd_party/HoloEverywhere/library/src/org/holoeverywhere/widget/ListPopupWindow.java @@ -0,0 +1,858 @@ + +package org.holoeverywhere.widget; + +import org.holoeverywhere.R; + +import android.annotation.SuppressLint; +import android.content.Context; +import android.content.res.Resources; +import android.database.DataSetObserver; +import android.graphics.Rect; +import android.graphics.drawable.Drawable; +import android.os.Build.VERSION; +import android.os.Handler; +import android.util.AttributeSet; +import android.util.Log; +import android.view.KeyEvent; +import android.view.MotionEvent; +import android.view.View; +import android.view.View.MeasureSpec; +import android.view.View.OnTouchListener; +import android.view.ViewGroup; +import android.view.ViewParent; +import android.widget.AbsListView; +import android.widget.AbsListView.OnScrollListener; +import android.widget.AdapterView; +import android.widget.ListAdapter; + +public class ListPopupWindow { + private static class DropDownListView extends ListView { + private boolean mHijackFocus; + private boolean mListSelectionHidden; + + public DropDownListView(Context context, boolean hijackFocus) { + super(context, null, R.attr.dropDownListViewStyle); + mHijackFocus = hijackFocus; + } + + @Override + public boolean hasFocus() { + return mHijackFocus || super.hasFocus(); + } + + @Override + public boolean hasWindowFocus() { + return mHijackFocus || super.hasWindowFocus(); + } + + @Override + public boolean isFocused() { + return mHijackFocus || super.isFocused(); + } + + @Override + public boolean isInTouchMode() { + return mHijackFocus && mListSelectionHidden + || super.isInTouchMode(); + } + + @Override + public View onPrepareView(View view, int position) { + if (view instanceof android.widget.TextView) { + ((android.widget.TextView) view).setHorizontallyScrolling(true); + } + return view; + } + } + + private class ListSelectorHider implements Runnable { + @Override + public void run() { + clearListSelection(); + } + } + + private class PopupDataSetObserver extends DataSetObserver { + @Override + public void onChanged() { + if (isShowing()) { + show(); + } + } + + @Override + public void onInvalidated() { + dismiss(); + } + } + + private class PopupScrollListener implements ListView.OnScrollListener { + @Override + public void onScroll(AbsListView view, int firstVisibleItem, + int visibleItemCount, int totalItemCount) { + } + + @Override + public void onScrollStateChanged(AbsListView view, int scrollState) { + if (scrollState == OnScrollListener.SCROLL_STATE_TOUCH_SCROLL + && !isInputMethodNotNeeded() + && mPopup.getContentView() != null) { + mHandler.removeCallbacks(mResizePopupRunnable); + mResizePopupRunnable.run(); + } + } + } + + private class PopupTouchInterceptor implements OnTouchListener { + @Override + public boolean onTouch(View v, MotionEvent event) { + final int action = event.getAction(); + final int x = (int) event.getX(); + final int y = (int) event.getY(); + if (action == MotionEvent.ACTION_DOWN && mPopup != null + && mPopup.isShowing() && x >= 0 && x < mPopup.getWidth() + && y >= 0 && y < mPopup.getHeight()) { + mHandler.postDelayed(mResizePopupRunnable, + ListPopupWindow.EXPAND_LIST_TIMEOUT); + } else if (action == MotionEvent.ACTION_UP) { + mHandler.removeCallbacks(mResizePopupRunnable); + } + return false; + } + } + + private class ResizePopupRunnable implements Runnable { + @Override + public void run() { + if (mDropDownList != null + && mDropDownList.getCount() > mDropDownList.getChildCount() + && mDropDownList.getChildCount() <= mListItemExpandMaximum) { + mPopup.setInputMethodMode(PopupWindow.INPUT_METHOD_NOT_NEEDED); + show(); + } + } + } + + private static final boolean DEBUG = false; + private static final int EXPAND_LIST_TIMEOUT = 250; + public static final int INPUT_METHOD_FROM_FOCUSABLE = PopupWindow.INPUT_METHOD_FROM_FOCUSABLE; + public static final int INPUT_METHOD_NEEDED = PopupWindow.INPUT_METHOD_NEEDED; + public static final int INPUT_METHOD_NOT_NEEDED = PopupWindow.INPUT_METHOD_NOT_NEEDED; + public static final int MATCH_PARENT = ViewGroup.LayoutParams.MATCH_PARENT; + public static final int POSITION_PROMPT_ABOVE = 0; + public static final int POSITION_PROMPT_BELOW = 1; + private static final String TAG = "ListPopupWindow"; + public static final int WRAP_CONTENT = ViewGroup.LayoutParams.WRAP_CONTENT; + private ListAdapter mAdapter; + private Context mContext; + private boolean mDropDownAlwaysVisible = false; + private View mDropDownAnchorView; + private int mDropDownHeight = ViewGroup.LayoutParams.WRAP_CONTENT; + private int mDropDownHorizontalOffset; + private DropDownListView mDropDownList; + private Drawable mDropDownListHighlight; + private int mDropDownVerticalOffset; + private boolean mDropDownVerticalOffsetSet; + private int mDropDownWidth = ViewGroup.LayoutParams.WRAP_CONTENT; + private boolean mForceIgnoreOutsideTouch = false; + private Handler mHandler = new Handler(); + private final ListSelectorHider mHideSelector = new ListSelectorHider(); + private AdapterView.OnItemClickListener mItemClickListener; + private AdapterView.OnItemSelectedListener mItemSelectedListener; + int mListItemExpandMaximum = Integer.MAX_VALUE; + private boolean mModal; + private DataSetObserver mObserver; + private PopupWindow mPopup; + private int mPromptPosition = ListPopupWindow.POSITION_PROMPT_ABOVE; + private View mPromptView; + private final ResizePopupRunnable mResizePopupRunnable = new ResizePopupRunnable(); + private final PopupScrollListener mScrollListener = new PopupScrollListener(); + private Runnable mShowDropDownRunnable; + private Rect mTempRect = new Rect(); + private final PopupTouchInterceptor mTouchInterceptor = new PopupTouchInterceptor(); + + public ListPopupWindow(Context context) { + this(context, null, R.attr.listPopupWindowStyle, 0); + } + + public ListPopupWindow(Context context, AttributeSet attrs) { + this(context, attrs, R.attr.listPopupWindowStyle, 0); + } + + public ListPopupWindow(Context context, AttributeSet attrs, int defStyleAttr) { + this(context, attrs, defStyleAttr, 0); + } + + public ListPopupWindow(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) { + mPopup = new PopupWindow(mContext = context, attrs, defStyleAttr, defStyleRes); + mPopup.setInputMethodMode(PopupWindow.INPUT_METHOD_NEEDED); + } + + private int buildDropDown() { + ViewGroup dropDownView; + int otherHeights = 0; + if (mDropDownList == null) { + Context context = mContext; + mShowDropDownRunnable = new Runnable() { + @Override + public void run() { + 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() { + @Override + public void onItemSelected(AdapterView<?> parent, + View view, int position, long id) { + + if (position != -1) { + DropDownListView dropDownList = mDropDownList; + + if (dropDownList != null) { + dropDownList.mListSelectionHidden = false; + } + } + } + + @Override + public void onNothingSelected(AdapterView<?> parent) { + } + }); + mDropDownList.setOnScrollListener(mScrollListener); + if (mItemSelectedListener != null) { + mDropDownList.setOnItemSelectedListener(mItemSelectedListener); + } + dropDownView = mDropDownList; + View hintView = mPromptView; + if (hintView != null) { + LinearLayout hintContainer = new LinearLayout(context); + hintContainer + .setOrientation(android.widget.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(ListPopupWindow.TAG, "Invalid hint position " + + mPromptPosition); + break; + } + 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; + } + } + int padding = 0; + Drawable background = mPopup.getBackground(); + if (background != null) { + background.getPadding(mTempRect); + padding = mTempRect.top + mTempRect.bottom; + if (!mDropDownVerticalOffsetSet) { + mDropDownVerticalOffset = -mTempRect.top; + } + } else { + mTempRect.setEmpty(); + } + boolean ignoreBottomDecorations = mPopup.getInputMethodMode() == PopupWindow.INPUT_METHOD_NOT_NEEDED; + final int maxHeight = 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 = measureHeightOfChildren(childWidthSpec, 0, -1, + maxHeight - otherHeights, -1); + if (listContent > 0) { + otherHeights += padding; + } + return listContent + otherHeights; + } + + public void clearListSelection() { + final DropDownListView list = mDropDownList; + if (list != null) { + list.mListSelectionHidden = true; + // TODO list.hideSelector(); + list.requestLayout(); + } + } + + public void dismiss() { + mPopup.dismiss(); + removePromptView(); + mPopup.setContentView(null); + mDropDownList = null; + mHandler.removeCallbacks(mResizePopupRunnable); + } + + public View getAnchorView() { + return mDropDownAnchorView; + } + + public int getAnimationStyle() { + return mPopup.getAnimationStyle(); + } + + public Drawable getBackground() { + return mPopup.getBackground(); + } + + public int getHeight() { + return mDropDownHeight; + } + + public int getHorizontalOffset() { + return mDropDownHorizontalOffset; + } + + public int getInputMethodMode() { + return mPopup.getInputMethodMode(); + } + + public ListView getListView() { + return mDropDownList; + } + + private int getMaxAvailableHeight(View anchor, int yOffset, + boolean ignoreBottomDecorations) { + final Rect displayFrame = new Rect(); + anchor.getWindowVisibleDisplayFrame(displayFrame); + final int[] anchorPos = new int[2]; + anchor.getLocationOnScreen(anchorPos); + int bottomEdge = displayFrame.bottom; + if (ignoreBottomDecorations) { + Resources res = anchor.getContext().getResources(); + bottomEdge = res.getDisplayMetrics().heightPixels; + } + final int distanceToBottom = bottomEdge + - (anchorPos[1] + anchor.getHeight()) - yOffset; + final int distanceToTop = anchorPos[1] - displayFrame.top + yOffset; + int returnedHeight = Math.max(distanceToBottom, distanceToTop); + if (mPopup.getBackground() != null) { + mPopup.getBackground().getPadding(mTempRect); + returnedHeight -= mTempRect.top + mTempRect.bottom; + } + return returnedHeight; + } + + public int getPromptPosition() { + return mPromptPosition; + } + + public Object getSelectedItem() { + if (!isShowing()) { + return null; + } + return mDropDownList.getSelectedItem(); + } + + public long getSelectedItemId() { + if (!isShowing()) { + return AdapterView.INVALID_ROW_ID; + } + return mDropDownList.getSelectedItemId(); + } + + public int getSelectedItemPosition() { + if (!isShowing()) { + return AdapterView.INVALID_POSITION; + } + return mDropDownList.getSelectedItemPosition(); + } + + public View getSelectedView() { + if (!isShowing()) { + return null; + } + return mDropDownList.getSelectedView(); + } + + public int getSoftInputMode() { + 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() == ListPopupWindow.INPUT_METHOD_NOT_NEEDED; + } + + public boolean isModal() { + return mModal; + } + + public boolean isShowing() { + return mPopup.isShowing(); + } + + private int measureHeightOfChildren(int widthMeasureSpec, + int startPosition, int endPosition, final int maxHeight, + int disallowPartialChildPosition) { + final ListAdapter adapter = mAdapter; + if (adapter == null) { + return mDropDownList.getListPaddingTop() + + mDropDownList.getListPaddingBottom(); + } + int returnedHeight = mDropDownList.getListPaddingTop() + + mDropDownList.getListPaddingBottom(); + final int dividerHeight = mDropDownList.getDividerHeight() > 0 + && mDropDownList.getDivider() != null ? mDropDownList + .getDividerHeight() : 0; + int prevHeightWithoutPartialChild = 0; + int i; + View child; + endPosition = endPosition == -1 ? adapter.getCount() - 1 : endPosition; + for (i = startPosition; i <= endPosition; ++i) { + child = mAdapter.getView(i, null, mDropDownList); + if (mDropDownList.getCacheColorHint() != 0) { + child.setDrawingCacheBackgroundColor(mDropDownList + .getCacheColorHint()); + } + measureScrapChild(child, i, widthMeasureSpec); + if (i > 0) { + returnedHeight += dividerHeight; + } + returnedHeight += child.getMeasuredHeight(); + if (returnedHeight >= maxHeight) { + return disallowPartialChildPosition >= 0 + && i > disallowPartialChildPosition + && prevHeightWithoutPartialChild > 0 + && returnedHeight != maxHeight ? prevHeightWithoutPartialChild + : maxHeight; + } + if (disallowPartialChildPosition >= 0 + && i >= disallowPartialChildPosition) { + prevHeightWithoutPartialChild = returnedHeight; + } + } + return returnedHeight; + } + + private void measureScrapChild(View child, int position, + int widthMeasureSpec) { + ListView.LayoutParams p = (ListView.LayoutParams) child + .getLayoutParams(); + if (p == null) { + p = new ListView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.WRAP_CONTENT, 0); + child.setLayoutParams(p); + } + // TODO p.viewType = mAdapter.getItemViewType(position); + // TODO p.forceAdd = true; + int childWidthSpec = ViewGroup.getChildMeasureSpec( + widthMeasureSpec, + mDropDownList.getPaddingLeft() + + mDropDownList.getPaddingRight(), p.width); + int lpHeight = p.height; + int childHeightSpec; + if (lpHeight > 0) { + childHeightSpec = MeasureSpec.makeMeasureSpec(lpHeight, + MeasureSpec.EXACTLY); + } else { + childHeightSpec = MeasureSpec.makeMeasureSpec(0, + MeasureSpec.UNSPECIFIED); + } + child.measure(childWidthSpec, childHeightSpec); + } + + public boolean onKeyDown(int keyCode, KeyEvent event) { + if (isShowing()) { + if (keyCode != KeyEvent.KEYCODE_SPACE + && (mDropDownList.getSelectedItemPosition() >= 0 || keyCode != KeyEvent.KEYCODE_ENTER + && keyCode != KeyEvent.KEYCODE_DPAD_CENTER)) { + int curIndex = mDropDownList.getSelectedItemPosition(); + boolean consumed; + final boolean below = !mPopup.isAboveAnchor(); + final ListAdapter adapter = mAdapter; + @SuppressWarnings("unused") + boolean allEnabled; + int firstItem = Integer.MAX_VALUE; + int lastItem = Integer.MIN_VALUE; + if (adapter != null) { + allEnabled = adapter.areAllItemsEnabled(); + firstItem = 0; + lastItem = adapter.getCount() - 1; + /* + * TODO 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) { + clearListSelection(); + mPopup.setInputMethodMode(PopupWindow.INPUT_METHOD_NEEDED); + show(); + return true; + } else { + mDropDownList.mListSelectionHidden = false; + } + consumed = mDropDownList.onKeyDown(keyCode, event); + if (ListPopupWindow.DEBUG) { + Log.v(ListPopupWindow.TAG, "Key down: code=" + keyCode + + " list consumed=" + consumed); + } + + if (consumed) { + mPopup.setInputMethodMode(PopupWindow.INPUT_METHOD_NOT_NEEDED); + mDropDownList.requestFocusFromTouch(); + show(); + switch (keyCode) { + 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) { + if (curIndex == lastItem) { + return true; + } + } else if (!below && keyCode == KeyEvent.KEYCODE_DPAD_UP + && curIndex == firstItem) { + return true; + } + } + } + } + return false; + } + + @SuppressLint("NewApi") + public boolean onKeyPreIme(int keyCode, KeyEvent event) { + if (VERSION.SDK_INT < 5) { + return false; + } + if (keyCode == KeyEvent.KEYCODE_BACK && isShowing()) { + 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, KeyEvent event) { + if (isShowing() && mDropDownList.getSelectedItemPosition() >= 0) { + boolean consumed = mDropDownList.onKeyUp(keyCode, event); + if (consumed) { + switch (keyCode) { + case KeyEvent.KEYCODE_ENTER: + case KeyEvent.KEYCODE_DPAD_CENTER: + dismiss(); + break; + } + } + return consumed; + } + return false; + } + + public boolean performItemClick(int 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() { + 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) { + if (mObserver == null) { + mObserver = new PopupDataSetObserver(); + } else if (mAdapter != null) { + mAdapter.unregisterDataSetObserver(mObserver); + } + mAdapter = adapter; + if (mAdapter != null) { + mAdapter.registerDataSetObserver(mObserver); + } + if (mDropDownList != null) { + mDropDownList.setAdapter(mAdapter); + } + } + + public void setAnchorView(View anchor) { + mDropDownAnchorView = anchor; + } + + public void setAnimationStyle(int animationStyle) { + mPopup.setAnimationStyle(animationStyle); + } + + public void setBackgroundDrawable(Drawable d) { + mPopup.setBackgroundDrawable(d); + } + + public void setContentWidth(int width) { + Drawable popupBackground = mPopup.getBackground(); + if (popupBackground != null) { + popupBackground.getPadding(mTempRect); + mDropDownWidth = mTempRect.left + mTempRect.right + width; + } else { + setWidth(width); + } + } + + public void setDropDownAlwaysVisible(boolean dropDownAlwaysVisible) { + mDropDownAlwaysVisible = dropDownAlwaysVisible; + } + + public void setForceIgnoreOutsideTouch(boolean forceIgnoreOutsideTouch) { + mForceIgnoreOutsideTouch = forceIgnoreOutsideTouch; + } + + public void setHeight(int height) { + mDropDownHeight = height; + } + + public void setHorizontalOffset(int offset) { + mDropDownHorizontalOffset = offset; + } + + public void setInputMethodMode(int mode) { + mPopup.setInputMethodMode(mode); + } + + void setListItemExpandMax(int max) { + mListItemExpandMaximum = max; + } + + public void setListSelector(Drawable selector) { + mDropDownListHighlight = selector; + } + + public void setModal(boolean modal) { + mModal = true; + mPopup.setFocusable(modal); + } + + public void setOnDismissListener(PopupWindow.OnDismissListener listener) { + mPopup.setOnDismissListener(listener); + } + + public void setOnItemClickListener( + AdapterView.OnItemClickListener clickListener) { + mItemClickListener = clickListener; + } + + public void setOnItemSelectedListener( + AdapterView.OnItemSelectedListener selectedListener) { + mItemSelectedListener = selectedListener; + } + + public void setPromptPosition(int position) { + mPromptPosition = position; + } + + public void setPromptView(View prompt) { + boolean showing = isShowing(); + if (showing) { + removePromptView(); + } + mPromptView = prompt; + if (showing) { + show(); + } + } + + public void setSelection(int position) { + DropDownListView list = mDropDownList; + if (isShowing() && list != null) { + list.mListSelectionHidden = false; + list.setSelection(position); + if (list.getChoiceMode() != AbsListView.CHOICE_MODE_NONE) { + list.setItemChecked(position, true); + } + } + } + + public void setSoftInputMode(int mode) { + mPopup.setSoftInputMode(mode); + } + + public void setVerticalOffset(int offset) { + mDropDownVerticalOffset = offset; + mDropDownVerticalOffsetSet = true; + } + + public void setWidth(int width) { + mDropDownWidth = width; + } + + public void show() { + int height = buildDropDown(); + int widthSpec = 0; + int heightSpec = 0; + boolean noInputMethod = isInputMethodNotNeeded(); + mPopup.setAllowScrollingAnchorParent(!noInputMethod); + if (mPopup.isShowing()) { + if (mDropDownWidth == ViewGroup.LayoutParams.MATCH_PARENT) { + widthSpec = -1; + } else if (mDropDownWidth == ViewGroup.LayoutParams.WRAP_CONTENT) { + widthSpec = getAnchorView().getWidth(); + } else { + widthSpec = mDropDownWidth; + } + if (mDropDownHeight == ViewGroup.LayoutParams.MATCH_PARENT) { + 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); + mPopup.setOutsideTouchable(!mForceIgnoreOutsideTouch + && !mDropDownAlwaysVisible); + mPopup.setTouchInterceptor(mTouchInterceptor); + mPopup.showAsDropDown(getAnchorView(), mDropDownHorizontalOffset, + mDropDownVerticalOffset); + mDropDownList.setSelection(AdapterView.INVALID_POSITION); + if (!mModal || mDropDownList.isInTouchMode()) { + clearListSelection(); + } + if (!mModal) { + mHandler.post(mHideSelector); + } + } + } +} |