1340 lines
47 KiB
Java
1340 lines
47 KiB
Java
/*
|
|
* Copyright (C) 2007 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.widget;
|
|
|
|
import static android.view.flags.Flags.enableArrowIconOnHoverWhenClickable;
|
|
import static android.view.flags.Flags.FLAG_ENABLE_ARROW_ICON_ON_HOVER_WHEN_CLICKABLE;
|
|
|
|
import android.annotation.DrawableRes;
|
|
import android.annotation.FlaggedApi;
|
|
import android.annotation.Nullable;
|
|
import android.annotation.TestApi;
|
|
import android.annotation.Widget;
|
|
import android.app.AlertDialog;
|
|
import android.compat.annotation.UnsupportedAppUsage;
|
|
import android.content.Context;
|
|
import android.content.DialogInterface;
|
|
import android.content.DialogInterface.OnClickListener;
|
|
import android.content.res.Resources;
|
|
import android.content.res.Resources.Theme;
|
|
import android.content.res.TypedArray;
|
|
import android.database.DataSetObserver;
|
|
import android.graphics.Rect;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.os.Build;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.view.ContextThemeWrapper;
|
|
import android.view.Gravity;
|
|
import android.view.InputDevice;
|
|
import android.view.MotionEvent;
|
|
import android.view.PointerIcon;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.ViewTreeObserver;
|
|
import android.view.ViewTreeObserver.OnGlobalLayoutListener;
|
|
import android.view.accessibility.AccessibilityNodeInfo;
|
|
import android.view.inspector.InspectableProperty;
|
|
import android.widget.PopupWindow.OnDismissListener;
|
|
|
|
import com.android.internal.R;
|
|
import com.android.internal.view.menu.ShowableListMenu;
|
|
|
|
/**
|
|
* A view that displays one child at a time and lets the user pick among them.
|
|
* The items in the Spinner come from the {@link Adapter} associated with
|
|
* this view.
|
|
*
|
|
* <p>See the <a href="{@docRoot}guide/topics/ui/controls/spinner.html">Spinners</a> guide.</p>
|
|
*
|
|
* @attr ref android.R.styleable#Spinner_dropDownSelector
|
|
* @attr ref android.R.styleable#Spinner_dropDownWidth
|
|
* @attr ref android.R.styleable#Spinner_gravity
|
|
* @attr ref android.R.styleable#Spinner_popupBackground
|
|
* @attr ref android.R.styleable#Spinner_prompt
|
|
* @attr ref android.R.styleable#Spinner_spinnerMode
|
|
* @attr ref android.R.styleable#ListPopupWindow_dropDownVerticalOffset
|
|
* @attr ref android.R.styleable#ListPopupWindow_dropDownHorizontalOffset
|
|
*/
|
|
@Widget
|
|
public class Spinner extends AbsSpinner implements OnClickListener {
|
|
private static final String TAG = "Spinner";
|
|
|
|
// Only measure this many items to get a decent max width.
|
|
private static final int MAX_ITEMS_MEASURED = 15;
|
|
|
|
/**
|
|
* Use a dialog window for selecting spinner options.
|
|
*/
|
|
public static final int MODE_DIALOG = 0;
|
|
|
|
/**
|
|
* Use a dropdown anchored to the Spinner for selecting spinner options.
|
|
*/
|
|
public static final int MODE_DROPDOWN = 1;
|
|
|
|
/**
|
|
* Use the theme-supplied value to select the dropdown mode.
|
|
*/
|
|
private static final int MODE_THEME = -1;
|
|
|
|
private final Rect mTempRect = new Rect();
|
|
|
|
/** Context used to inflate the popup window or dialog. */
|
|
private final Context mPopupContext;
|
|
|
|
/** Forwarding listener used to implement drag-to-open. */
|
|
@UnsupportedAppUsage
|
|
private ForwardingListener mForwardingListener;
|
|
|
|
/** Temporary holder for setAdapter() calls from the super constructor. */
|
|
private SpinnerAdapter mTempAdapter;
|
|
|
|
@UnsupportedAppUsage
|
|
private SpinnerPopup mPopup;
|
|
int mDropDownWidth;
|
|
|
|
private int mGravity;
|
|
private boolean mDisableChildrenWhenDisabled;
|
|
|
|
/**
|
|
* Constructs a new spinner with the given context's theme.
|
|
*
|
|
* @param context The Context the view is running in, through which it can
|
|
* access the current theme, resources, etc.
|
|
*/
|
|
public Spinner(Context context) {
|
|
this(context, null);
|
|
}
|
|
|
|
/**
|
|
* Constructs a new spinner with the given context's theme and the supplied
|
|
* mode of displaying choices. <code>mode</code> may be one of
|
|
* {@link #MODE_DIALOG} or {@link #MODE_DROPDOWN}.
|
|
*
|
|
* @param context The Context the view is running in, through which it can
|
|
* access the current theme, resources, etc.
|
|
* @param mode Constant describing how the user will select choices from
|
|
* the spinner.
|
|
*
|
|
* @see #MODE_DIALOG
|
|
* @see #MODE_DROPDOWN
|
|
*/
|
|
public Spinner(Context context, int mode) {
|
|
this(context, null, com.android.internal.R.attr.spinnerStyle, mode);
|
|
}
|
|
|
|
/**
|
|
* Constructs a new spinner with the given context's theme and the supplied
|
|
* attribute set.
|
|
*
|
|
* @param context The Context the view is running in, through which it can
|
|
* access the current theme, resources, etc.
|
|
* @param attrs The attributes of the XML tag that is inflating the view.
|
|
*/
|
|
public Spinner(Context context, AttributeSet attrs) {
|
|
this(context, attrs, com.android.internal.R.attr.spinnerStyle);
|
|
}
|
|
|
|
/**
|
|
* Constructs a new spinner with the given context's theme, the supplied
|
|
* attribute set, and default style attribute.
|
|
*
|
|
* @param context The Context the view is running in, through which it can
|
|
* access the current theme, resources, etc.
|
|
* @param attrs The attributes of the XML tag that is inflating the view.
|
|
* @param defStyleAttr An attribute in the current theme that contains a
|
|
* reference to a style resource that supplies default
|
|
* values for the view. Can be 0 to not look for
|
|
* defaults.
|
|
*/
|
|
public Spinner(Context context, AttributeSet attrs, int defStyleAttr) {
|
|
this(context, attrs, defStyleAttr, 0, MODE_THEME);
|
|
}
|
|
|
|
/**
|
|
* Constructs a new spinner with the given context's theme, the supplied
|
|
* attribute set, and default style attribute. <code>mode</code> may be one
|
|
* of {@link #MODE_DIALOG} or {@link #MODE_DROPDOWN} and determines how the
|
|
* user will select choices from the spinner.
|
|
*
|
|
* @param context The Context the view is running in, through which it can
|
|
* access the current theme, resources, etc.
|
|
* @param attrs The attributes of the XML tag that is inflating the view.
|
|
* @param defStyleAttr An attribute in the current theme that contains a
|
|
* reference to a style resource that supplies default
|
|
* values for the view. Can be 0 to not look for defaults.
|
|
* @param mode Constant describing how the user will select choices from the
|
|
* spinner.
|
|
*
|
|
* @see #MODE_DIALOG
|
|
* @see #MODE_DROPDOWN
|
|
*/
|
|
public Spinner(Context context, AttributeSet attrs, int defStyleAttr, int mode) {
|
|
this(context, attrs, defStyleAttr, 0, mode);
|
|
}
|
|
|
|
/**
|
|
* Constructs a new spinner with the given context's theme, the supplied
|
|
* attribute set, and default styles. <code>mode</code> may be one of
|
|
* {@link #MODE_DIALOG} or {@link #MODE_DROPDOWN} and determines how the
|
|
* user will select choices from the spinner.
|
|
*
|
|
* @param context The Context the view is running in, through which it can
|
|
* access the current theme, resources, etc.
|
|
* @param attrs The attributes of the XML tag that is inflating the view.
|
|
* @param defStyleAttr An attribute in the current theme that contains a
|
|
* reference to a style resource that supplies default
|
|
* values for the view. Can be 0 to not look for
|
|
* defaults.
|
|
* @param defStyleRes A resource identifier of a style resource that
|
|
* supplies default values for the view, used only if
|
|
* defStyleAttr is 0 or can not be found in the theme.
|
|
* Can be 0 to not look for defaults.
|
|
* @param mode Constant describing how the user will select choices from
|
|
* the spinner.
|
|
*
|
|
* @see #MODE_DIALOG
|
|
* @see #MODE_DROPDOWN
|
|
*/
|
|
public Spinner(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes,
|
|
int mode) {
|
|
this(context, attrs, defStyleAttr, defStyleRes, mode, null);
|
|
}
|
|
|
|
/**
|
|
* Constructs a new spinner with the given context, the supplied attribute
|
|
* set, default styles, popup mode (one of {@link #MODE_DIALOG} or
|
|
* {@link #MODE_DROPDOWN}), and the theme against which the popup should be
|
|
* inflated.
|
|
*
|
|
* @param context The context against which the view is inflated, which
|
|
* provides access to the current theme, resources, etc.
|
|
* @param attrs The attributes of the XML tag that is inflating the view.
|
|
* @param defStyleAttr An attribute in the current theme that contains a
|
|
* reference to a style resource that supplies default
|
|
* values for the view. Can be 0 to not look for
|
|
* defaults.
|
|
* @param defStyleRes A resource identifier of a style resource that
|
|
* supplies default values for the view, used only if
|
|
* defStyleAttr is 0 or can not be found in the theme.
|
|
* Can be 0 to not look for defaults.
|
|
* @param mode Constant describing how the user will select choices from
|
|
* the spinner.
|
|
* @param popupTheme The theme against which the dialog or dropdown popup
|
|
* should be inflated. May be {@code null} to use the
|
|
* view theme. If set, this will override any value
|
|
* specified by
|
|
* {@link android.R.styleable#Spinner_popupTheme}.
|
|
*
|
|
* @see #MODE_DIALOG
|
|
* @see #MODE_DROPDOWN
|
|
*/
|
|
public Spinner(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes, int mode,
|
|
Theme popupTheme) {
|
|
super(context, attrs, defStyleAttr, defStyleRes);
|
|
|
|
final TypedArray a = context.obtainStyledAttributes(
|
|
attrs, R.styleable.Spinner, defStyleAttr, defStyleRes);
|
|
saveAttributeDataForStyleable(context, R.styleable.Spinner,
|
|
attrs, a, defStyleAttr, defStyleRes);
|
|
|
|
if (popupTheme != null) {
|
|
mPopupContext = new ContextThemeWrapper(context, popupTheme);
|
|
} else {
|
|
final int popupThemeResId = a.getResourceId(R.styleable.Spinner_popupTheme, 0);
|
|
if (popupThemeResId != 0) {
|
|
mPopupContext = new ContextThemeWrapper(context, popupThemeResId);
|
|
} else {
|
|
mPopupContext = context;
|
|
}
|
|
}
|
|
|
|
if (mode == MODE_THEME) {
|
|
mode = a.getInt(R.styleable.Spinner_spinnerMode, MODE_DIALOG);
|
|
}
|
|
|
|
switch (mode) {
|
|
case MODE_DIALOG: {
|
|
mPopup = new DialogPopup();
|
|
mPopup.setPromptText(a.getString(R.styleable.Spinner_prompt));
|
|
break;
|
|
}
|
|
|
|
case MODE_DROPDOWN: {
|
|
final DropdownPopup popup = new DropdownPopup(
|
|
mPopupContext, attrs, defStyleAttr, defStyleRes);
|
|
final TypedArray pa = mPopupContext.obtainStyledAttributes(
|
|
attrs, R.styleable.Spinner, defStyleAttr, defStyleRes);
|
|
mDropDownWidth = pa.getLayoutDimension(R.styleable.Spinner_dropDownWidth,
|
|
ViewGroup.LayoutParams.WRAP_CONTENT);
|
|
if (pa.hasValueOrEmpty(R.styleable.Spinner_dropDownSelector)) {
|
|
popup.setListSelector(pa.getDrawable(
|
|
R.styleable.Spinner_dropDownSelector));
|
|
}
|
|
popup.setBackgroundDrawable(pa.getDrawable(R.styleable.Spinner_popupBackground));
|
|
popup.setPromptText(a.getString(R.styleable.Spinner_prompt));
|
|
pa.recycle();
|
|
|
|
mPopup = popup;
|
|
mForwardingListener = new ForwardingListener(this) {
|
|
@Override
|
|
public ShowableListMenu getPopup() {
|
|
return popup;
|
|
}
|
|
|
|
@Override
|
|
public boolean onForwardingStarted() {
|
|
if (!mPopup.isShowing()) {
|
|
mPopup.show(getTextDirection(), getTextAlignment());
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
|
|
mGravity = a.getInt(R.styleable.Spinner_gravity, Gravity.CENTER);
|
|
mDisableChildrenWhenDisabled = a.getBoolean(
|
|
R.styleable.Spinner_disableChildrenWhenDisabled, false);
|
|
|
|
a.recycle();
|
|
|
|
// Base constructor can call setAdapter before we initialize mPopup.
|
|
// Finish setting things up if this happened.
|
|
if (mTempAdapter != null) {
|
|
setAdapter(mTempAdapter);
|
|
mTempAdapter = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return the context used to inflate the Spinner's popup or dialog window
|
|
*/
|
|
public Context getPopupContext() {
|
|
return mPopupContext;
|
|
}
|
|
|
|
/**
|
|
* Set the background drawable for the spinner's popup window of choices.
|
|
* Only valid in {@link #MODE_DROPDOWN}; this method is a no-op in other modes.
|
|
*
|
|
* @param background Background drawable
|
|
*
|
|
* @attr ref android.R.styleable#Spinner_popupBackground
|
|
*/
|
|
public void setPopupBackgroundDrawable(Drawable background) {
|
|
if (!(mPopup instanceof DropdownPopup)) {
|
|
Log.e(TAG, "setPopupBackgroundDrawable: incompatible spinner mode; ignoring...");
|
|
return;
|
|
}
|
|
mPopup.setBackgroundDrawable(background);
|
|
}
|
|
|
|
/**
|
|
* Set the background drawable for the spinner's popup window of choices.
|
|
* Only valid in {@link #MODE_DROPDOWN}; this method is a no-op in other modes.
|
|
*
|
|
* @param resId Resource ID of a background drawable
|
|
*
|
|
* @attr ref android.R.styleable#Spinner_popupBackground
|
|
*/
|
|
public void setPopupBackgroundResource(@DrawableRes int resId) {
|
|
setPopupBackgroundDrawable(getPopupContext().getDrawable(resId));
|
|
}
|
|
|
|
/**
|
|
* Get the background drawable for the spinner's popup window of choices.
|
|
* Only valid in {@link #MODE_DROPDOWN}; other modes will return null.
|
|
*
|
|
* @return background Background drawable
|
|
*
|
|
* @attr ref android.R.styleable#Spinner_popupBackground
|
|
*/
|
|
@InspectableProperty
|
|
public Drawable getPopupBackground() {
|
|
return mPopup.getBackground();
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
@TestApi
|
|
public boolean isPopupShowing() {
|
|
return (mPopup != null) && mPopup.isShowing();
|
|
}
|
|
|
|
/**
|
|
* Set a vertical offset in pixels for the spinner's popup window of choices.
|
|
* Only valid in {@link #MODE_DROPDOWN}; this method is a no-op in other modes.
|
|
*
|
|
* @param pixels Vertical offset in pixels
|
|
*
|
|
* @attr ref android.R.styleable#ListPopupWindow_dropDownVerticalOffset
|
|
*/
|
|
public void setDropDownVerticalOffset(int pixels) {
|
|
mPopup.setVerticalOffset(pixels);
|
|
}
|
|
|
|
/**
|
|
* Get the configured vertical offset in pixels for the spinner's popup window of choices.
|
|
* Only valid in {@link #MODE_DROPDOWN}; other modes will return 0.
|
|
*
|
|
* @return Vertical offset in pixels
|
|
*
|
|
* @attr ref android.R.styleable#ListPopupWindow_dropDownVerticalOffset
|
|
*/
|
|
@InspectableProperty
|
|
public int getDropDownVerticalOffset() {
|
|
return mPopup.getVerticalOffset();
|
|
}
|
|
|
|
/**
|
|
* Set a horizontal offset in pixels for the spinner's popup window of choices.
|
|
* Only valid in {@link #MODE_DROPDOWN}; this method is a no-op in other modes.
|
|
*
|
|
* @param pixels Horizontal offset in pixels
|
|
*
|
|
* @attr ref android.R.styleable#ListPopupWindow_dropDownHorizontalOffset
|
|
*/
|
|
public void setDropDownHorizontalOffset(int pixels) {
|
|
mPopup.setHorizontalOffset(pixels);
|
|
}
|
|
|
|
/**
|
|
* Get the configured horizontal offset in pixels for the spinner's popup window of choices.
|
|
* Only valid in {@link #MODE_DROPDOWN}; other modes will return 0.
|
|
*
|
|
* @return Horizontal offset in pixels
|
|
*
|
|
* @attr ref android.R.styleable#ListPopupWindow_dropDownHorizontalOffset
|
|
*/
|
|
@InspectableProperty
|
|
public int getDropDownHorizontalOffset() {
|
|
return mPopup.getHorizontalOffset();
|
|
}
|
|
|
|
/**
|
|
* Set the width of the spinner's popup window of choices in pixels. This value
|
|
* may also be set to {@link android.view.ViewGroup.LayoutParams#MATCH_PARENT}
|
|
* to match the width of the Spinner itself, or
|
|
* {@link android.view.ViewGroup.LayoutParams#WRAP_CONTENT} to wrap to the measured size
|
|
* of contained dropdown list items.
|
|
*
|
|
* <p>Only valid in {@link #MODE_DROPDOWN}; this method is a no-op in other modes.</p>
|
|
*
|
|
* @param pixels Width in pixels, WRAP_CONTENT, or MATCH_PARENT
|
|
*
|
|
* @attr ref android.R.styleable#Spinner_dropDownWidth
|
|
*/
|
|
public void setDropDownWidth(int pixels) {
|
|
if (!(mPopup instanceof DropdownPopup)) {
|
|
Log.e(TAG, "Cannot set dropdown width for MODE_DIALOG, ignoring");
|
|
return;
|
|
}
|
|
mDropDownWidth = pixels;
|
|
}
|
|
|
|
/**
|
|
* Get the configured width of the spinner's popup window of choices in pixels.
|
|
* The returned value may also be {@link android.view.ViewGroup.LayoutParams#MATCH_PARENT}
|
|
* meaning the popup window will match the width of the Spinner itself, or
|
|
* {@link android.view.ViewGroup.LayoutParams#WRAP_CONTENT} to wrap to the measured size
|
|
* of contained dropdown list items.
|
|
*
|
|
* @return Width in pixels, WRAP_CONTENT, or MATCH_PARENT
|
|
*
|
|
* @attr ref android.R.styleable#Spinner_dropDownWidth
|
|
*/
|
|
@InspectableProperty
|
|
public int getDropDownWidth() {
|
|
return mDropDownWidth;
|
|
}
|
|
|
|
@Override
|
|
public void setEnabled(boolean enabled) {
|
|
super.setEnabled(enabled);
|
|
if (mDisableChildrenWhenDisabled) {
|
|
final int count = getChildCount();
|
|
for (int i = 0; i < count; i++) {
|
|
getChildAt(i).setEnabled(enabled);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Describes how the selected item view is positioned. Currently only the horizontal component
|
|
* is used. The default is determined by the current theme.
|
|
*
|
|
* @param gravity See {@link android.view.Gravity}
|
|
*
|
|
* @attr ref android.R.styleable#Spinner_gravity
|
|
*/
|
|
public void setGravity(int gravity) {
|
|
if (mGravity != gravity) {
|
|
if ((gravity & Gravity.HORIZONTAL_GRAVITY_MASK) == 0) {
|
|
gravity |= Gravity.START;
|
|
}
|
|
mGravity = gravity;
|
|
requestLayout();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Describes how the selected item view is positioned. The default is determined by the
|
|
* current theme.
|
|
*
|
|
* @return A {@link android.view.Gravity Gravity} value
|
|
*/
|
|
@InspectableProperty(valueType = InspectableProperty.ValueType.GRAVITY)
|
|
public int getGravity() {
|
|
return mGravity;
|
|
}
|
|
|
|
/**
|
|
* Sets the {@link SpinnerAdapter} used to provide the data which backs
|
|
* this Spinner.
|
|
* <p>
|
|
* If this Spinner has a popup theme set in XML via the
|
|
* {@link android.R.styleable#Spinner_popupTheme popupTheme} attribute, the
|
|
* adapter should inflate drop-down views using the same theme. The easiest
|
|
* way to achieve this is by using {@link #getPopupContext()} to obtain a
|
|
* layout inflater for use in
|
|
* {@link SpinnerAdapter#getDropDownView(int, View, ViewGroup)}.
|
|
* <p>
|
|
* Spinner overrides {@link Adapter#getViewTypeCount()} on the
|
|
* Adapter associated with this view. Calling
|
|
* {@link Adapter#getItemViewType(int) getItemViewType(int)} on the object
|
|
* returned from {@link #getAdapter()} will always return 0. Calling
|
|
* {@link Adapter#getViewTypeCount() getViewTypeCount()} will always return
|
|
* 1. On API {@link Build.VERSION_CODES#LOLLIPOP} and above, attempting to set an
|
|
* adapter with more than one view type will throw an
|
|
* {@link IllegalArgumentException}.
|
|
*
|
|
* @param adapter the adapter to set
|
|
*
|
|
* @see AbsSpinner#setAdapter(SpinnerAdapter)
|
|
* @throws IllegalArgumentException if the adapter has more than one view
|
|
* type
|
|
*/
|
|
@Override
|
|
public void setAdapter(SpinnerAdapter adapter) {
|
|
// The super constructor may call setAdapter before we're prepared.
|
|
// Postpone doing anything until we've finished construction.
|
|
if (mPopup == null) {
|
|
mTempAdapter = adapter;
|
|
return;
|
|
}
|
|
|
|
super.setAdapter(adapter);
|
|
|
|
mRecycler.clear();
|
|
|
|
final int targetSdkVersion = mContext.getApplicationInfo().targetSdkVersion;
|
|
if (targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP
|
|
&& adapter != null && adapter.getViewTypeCount() != 1) {
|
|
throw new IllegalArgumentException("Spinner adapter view type count must be 1");
|
|
}
|
|
|
|
final Context popupContext = mPopupContext == null ? mContext : mPopupContext;
|
|
mPopup.setAdapter(new DropDownAdapter(adapter, popupContext.getTheme()));
|
|
}
|
|
|
|
@Override
|
|
public int getBaseline() {
|
|
View child = null;
|
|
|
|
if (getChildCount() > 0) {
|
|
child = getChildAt(0);
|
|
} else if (mAdapter != null && mAdapter.getCount() > 0) {
|
|
child = makeView(0, false);
|
|
mRecycler.put(0, child);
|
|
}
|
|
|
|
if (child != null) {
|
|
final int childBaseline = child.getBaseline();
|
|
return childBaseline >= 0 ? child.getTop() + childBaseline : -1;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onDetachedFromWindow() {
|
|
super.onDetachedFromWindow();
|
|
|
|
if (mPopup != null && mPopup.isShowing()) {
|
|
mPopup.dismiss();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <p>A spinner does not support item click events. Calling this method
|
|
* will raise an exception.</p>
|
|
* <p>Instead use {@link AdapterView#setOnItemSelectedListener}.
|
|
*
|
|
* @param l this listener will be ignored
|
|
*/
|
|
@Override
|
|
public void setOnItemClickListener(OnItemClickListener l) {
|
|
throw new RuntimeException("setOnItemClickListener cannot be used with a spinner.");
|
|
}
|
|
|
|
/**
|
|
* @hide internal use only
|
|
*/
|
|
@UnsupportedAppUsage
|
|
public void setOnItemClickListenerInt(OnItemClickListener l) {
|
|
super.setOnItemClickListener(l);
|
|
}
|
|
|
|
@Override
|
|
public boolean onTouchEvent(MotionEvent event) {
|
|
if (mForwardingListener != null && mForwardingListener.onTouch(this, event)) {
|
|
return true;
|
|
}
|
|
|
|
return super.onTouchEvent(event);
|
|
}
|
|
|
|
@Override
|
|
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
|
|
if (mPopup != null && MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.AT_MOST) {
|
|
final int measuredWidth = getMeasuredWidth();
|
|
setMeasuredDimension(Math.min(Math.max(measuredWidth,
|
|
measureContentWidth(getAdapter(), getBackground())),
|
|
MeasureSpec.getSize(widthMeasureSpec)),
|
|
getMeasuredHeight());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see android.view.View#onLayout(boolean,int,int,int,int)
|
|
*
|
|
* Creates and positions all views
|
|
*
|
|
*/
|
|
@Override
|
|
protected void onLayout(boolean changed, int l, int t, int r, int b) {
|
|
super.onLayout(changed, l, t, r, b);
|
|
mInLayout = true;
|
|
layout(0, false);
|
|
mInLayout = false;
|
|
}
|
|
|
|
/**
|
|
* Creates and positions all views for this Spinner.
|
|
*
|
|
* @param delta Change in the selected position. +1 means selection is moving to the right,
|
|
* so views are scrolling to the left. -1 means selection is moving to the left.
|
|
*/
|
|
@Override
|
|
void layout(int delta, boolean animate) {
|
|
int childrenLeft = mSpinnerPadding.left;
|
|
int childrenWidth = mRight - mLeft - mSpinnerPadding.left - mSpinnerPadding.right;
|
|
|
|
if (mDataChanged) {
|
|
handleDataChanged();
|
|
}
|
|
|
|
// Handle the empty set by removing all views
|
|
if (mItemCount == 0) {
|
|
resetList();
|
|
return;
|
|
}
|
|
|
|
if (mNextSelectedPosition >= 0) {
|
|
setSelectedPositionInt(mNextSelectedPosition);
|
|
}
|
|
|
|
recycleAllViews();
|
|
|
|
// Clear out old views
|
|
removeAllViewsInLayout();
|
|
|
|
// Make selected view and position it
|
|
mFirstPosition = mSelectedPosition;
|
|
|
|
if (mAdapter != null) {
|
|
View sel = makeView(mSelectedPosition, true);
|
|
int width = sel.getMeasuredWidth();
|
|
int selectedOffset = childrenLeft;
|
|
final int layoutDirection = getLayoutDirection();
|
|
final int absoluteGravity = Gravity.getAbsoluteGravity(mGravity, layoutDirection);
|
|
switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
|
|
case Gravity.CENTER_HORIZONTAL:
|
|
selectedOffset = childrenLeft + (childrenWidth / 2) - (width / 2);
|
|
break;
|
|
case Gravity.RIGHT:
|
|
selectedOffset = childrenLeft + childrenWidth - width;
|
|
break;
|
|
}
|
|
sel.offsetLeftAndRight(selectedOffset);
|
|
}
|
|
|
|
// Flush any cached views that did not get reused above
|
|
mRecycler.clear();
|
|
|
|
invalidate();
|
|
|
|
checkSelectionChanged();
|
|
|
|
mDataChanged = false;
|
|
mNeedSync = false;
|
|
setNextSelectedPositionInt(mSelectedPosition);
|
|
}
|
|
|
|
/**
|
|
* Obtain a view, either by pulling an existing view from the recycler or
|
|
* by getting a new one from the adapter. If we are animating, make sure
|
|
* there is enough information in the view's layout parameters to animate
|
|
* from the old to new positions.
|
|
*
|
|
* @param position Position in the spinner for the view to obtain
|
|
* @param addChild true to add the child to the spinner, false to obtain and configure only.
|
|
* @return A view for the given position
|
|
*/
|
|
private View makeView(int position, boolean addChild) {
|
|
View child;
|
|
|
|
if (!mDataChanged) {
|
|
child = mRecycler.get(position);
|
|
if (child != null) {
|
|
// Position the view
|
|
setUpChild(child, addChild);
|
|
|
|
return child;
|
|
}
|
|
}
|
|
|
|
// Nothing found in the recycler -- ask the adapter for a view
|
|
child = mAdapter.getView(position, null, this);
|
|
|
|
// Position the view
|
|
setUpChild(child, addChild);
|
|
|
|
return child;
|
|
}
|
|
|
|
/**
|
|
* Helper for makeAndAddView to set the position of a view
|
|
* and fill out its layout paramters.
|
|
*
|
|
* @param child The view to position
|
|
* @param addChild true if the child should be added to the Spinner during setup
|
|
*/
|
|
private void setUpChild(View child, boolean addChild) {
|
|
|
|
// Respect layout params that are already in the view. Otherwise
|
|
// make some up...
|
|
ViewGroup.LayoutParams lp = child.getLayoutParams();
|
|
if (lp == null) {
|
|
lp = generateDefaultLayoutParams();
|
|
}
|
|
|
|
addViewInLayout(child, 0, lp);
|
|
|
|
child.setSelected(hasFocus());
|
|
if (mDisableChildrenWhenDisabled) {
|
|
child.setEnabled(isEnabled());
|
|
}
|
|
|
|
// Get measure specs
|
|
int childHeightSpec = ViewGroup.getChildMeasureSpec(mHeightMeasureSpec,
|
|
mSpinnerPadding.top + mSpinnerPadding.bottom, lp.height);
|
|
int childWidthSpec = ViewGroup.getChildMeasureSpec(mWidthMeasureSpec,
|
|
mSpinnerPadding.left + mSpinnerPadding.right, lp.width);
|
|
|
|
// Measure child
|
|
child.measure(childWidthSpec, childHeightSpec);
|
|
|
|
int childLeft;
|
|
int childRight;
|
|
|
|
// Position vertically based on gravity setting
|
|
int childTop = mSpinnerPadding.top
|
|
+ ((getMeasuredHeight() - mSpinnerPadding.bottom -
|
|
mSpinnerPadding.top - child.getMeasuredHeight()) / 2);
|
|
int childBottom = childTop + child.getMeasuredHeight();
|
|
|
|
int width = child.getMeasuredWidth();
|
|
childLeft = 0;
|
|
childRight = childLeft + width;
|
|
|
|
child.layout(childLeft, childTop, childRight, childBottom);
|
|
|
|
if (!addChild) {
|
|
removeViewInLayout(child);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean performClick() {
|
|
boolean handled = super.performClick();
|
|
|
|
if (!handled) {
|
|
handled = true;
|
|
|
|
if (!mPopup.isShowing()) {
|
|
mPopup.show(getTextDirection(), getTextAlignment());
|
|
}
|
|
}
|
|
|
|
return handled;
|
|
}
|
|
|
|
@Override
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
setSelection(which);
|
|
dialog.dismiss();
|
|
}
|
|
|
|
/**
|
|
* Sets selection and dismisses the spinner's popup if it can be dismissed.
|
|
* For ease of use in tests, where publicly obtaining the spinner's popup is difficult.
|
|
*
|
|
* @param which index of the item to be selected.
|
|
* @hide
|
|
*/
|
|
@TestApi
|
|
public void onClick(int which) {
|
|
setSelection(which);
|
|
if (mPopup != null && mPopup.isShowing()) {
|
|
mPopup.dismiss();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public CharSequence getAccessibilityClassName() {
|
|
return Spinner.class.getName();
|
|
}
|
|
|
|
/** @hide */
|
|
@Override
|
|
public void onInitializeAccessibilityNodeInfoInternal(AccessibilityNodeInfo info) {
|
|
super.onInitializeAccessibilityNodeInfoInternal(info);
|
|
|
|
if (mAdapter != null) {
|
|
info.setCanOpenPopup(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the prompt to display when the dialog is shown.
|
|
* @param prompt the prompt to set
|
|
*/
|
|
public void setPrompt(CharSequence prompt) {
|
|
mPopup.setPromptText(prompt);
|
|
}
|
|
|
|
/**
|
|
* Sets the prompt to display when the dialog is shown.
|
|
* @param promptId the resource ID of the prompt to display when the dialog is shown
|
|
*/
|
|
public void setPromptId(int promptId) {
|
|
setPrompt(getContext().getText(promptId));
|
|
}
|
|
|
|
/**
|
|
* @return The prompt to display when the dialog is shown
|
|
*/
|
|
@InspectableProperty
|
|
public CharSequence getPrompt() {
|
|
return mPopup.getHintText();
|
|
}
|
|
|
|
int measureContentWidth(SpinnerAdapter adapter, Drawable background) {
|
|
if (adapter == null) {
|
|
return 0;
|
|
}
|
|
|
|
int width = 0;
|
|
View itemView = null;
|
|
int itemType = 0;
|
|
final int widthMeasureSpec =
|
|
MeasureSpec.makeSafeMeasureSpec(getMeasuredWidth(), MeasureSpec.UNSPECIFIED);
|
|
final int heightMeasureSpec =
|
|
MeasureSpec.makeSafeMeasureSpec(getMeasuredHeight(), MeasureSpec.UNSPECIFIED);
|
|
|
|
// Make sure the number of items we'll measure is capped. If it's a huge data set
|
|
// with wildly varying sizes, oh well.
|
|
int start = Math.max(0, getSelectedItemPosition());
|
|
final int end = Math.min(adapter.getCount(), start + MAX_ITEMS_MEASURED);
|
|
final int count = end - start;
|
|
start = Math.max(0, start - (MAX_ITEMS_MEASURED - count));
|
|
for (int i = start; i < end; i++) {
|
|
final int positionType = adapter.getItemViewType(i);
|
|
if (positionType != itemType) {
|
|
itemType = positionType;
|
|
itemView = null;
|
|
}
|
|
itemView = adapter.getView(i, itemView, this);
|
|
if (itemView.getLayoutParams() == null) {
|
|
itemView.setLayoutParams(new ViewGroup.LayoutParams(
|
|
ViewGroup.LayoutParams.WRAP_CONTENT,
|
|
ViewGroup.LayoutParams.WRAP_CONTENT));
|
|
}
|
|
itemView.measure(widthMeasureSpec, heightMeasureSpec);
|
|
width = Math.max(width, itemView.getMeasuredWidth());
|
|
}
|
|
|
|
// Add background padding to measured width
|
|
if (background != null) {
|
|
background.getPadding(mTempRect);
|
|
width += mTempRect.left + mTempRect.right;
|
|
}
|
|
|
|
return width;
|
|
}
|
|
|
|
@Override
|
|
public Parcelable onSaveInstanceState() {
|
|
final SavedState ss = new SavedState(super.onSaveInstanceState());
|
|
ss.showDropdown = mPopup != null && mPopup.isShowing();
|
|
return ss;
|
|
}
|
|
|
|
@Override
|
|
public void onRestoreInstanceState(Parcelable state) {
|
|
SavedState ss = (SavedState) state;
|
|
|
|
super.onRestoreInstanceState(ss.getSuperState());
|
|
|
|
if (ss.showDropdown) {
|
|
ViewTreeObserver vto = getViewTreeObserver();
|
|
if (vto != null) {
|
|
final OnGlobalLayoutListener listener = new OnGlobalLayoutListener() {
|
|
@Override
|
|
public void onGlobalLayout() {
|
|
if (!mPopup.isShowing()) {
|
|
mPopup.show(getTextDirection(), getTextAlignment());
|
|
}
|
|
final ViewTreeObserver vto = getViewTreeObserver();
|
|
if (vto != null) {
|
|
vto.removeOnGlobalLayoutListener(this);
|
|
}
|
|
}
|
|
};
|
|
vto.addOnGlobalLayoutListener(listener);
|
|
}
|
|
}
|
|
}
|
|
|
|
@FlaggedApi(FLAG_ENABLE_ARROW_ICON_ON_HOVER_WHEN_CLICKABLE)
|
|
@Override
|
|
public PointerIcon onResolvePointerIcon(MotionEvent event, int pointerIndex) {
|
|
if (getPointerIcon() == null && isClickable() && isEnabled()
|
|
&& event.isFromSource(InputDevice.SOURCE_MOUSE)) {
|
|
int pointerIcon = enableArrowIconOnHoverWhenClickable()
|
|
? PointerIcon.TYPE_ARROW
|
|
: PointerIcon.TYPE_HAND;
|
|
return PointerIcon.getSystemIcon(getContext(), pointerIcon);
|
|
}
|
|
return super.onResolvePointerIcon(event, pointerIndex);
|
|
}
|
|
|
|
static class SavedState extends AbsSpinner.SavedState {
|
|
boolean showDropdown;
|
|
|
|
SavedState(Parcelable superState) {
|
|
super(superState);
|
|
}
|
|
|
|
private SavedState(Parcel in) {
|
|
super(in);
|
|
showDropdown = in.readByte() != 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(Parcel out, int flags) {
|
|
super.writeToParcel(out, flags);
|
|
out.writeByte((byte) (showDropdown ? 1 : 0));
|
|
}
|
|
|
|
public static final @android.annotation.NonNull Parcelable.Creator<SavedState> CREATOR =
|
|
new Parcelable.Creator<SavedState>() {
|
|
public SavedState createFromParcel(Parcel in) {
|
|
return new SavedState(in);
|
|
}
|
|
|
|
public SavedState[] newArray(int size) {
|
|
return new SavedState[size];
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* <p>Wrapper class for an Adapter. Transforms the embedded Adapter instance
|
|
* into a ListAdapter.</p>
|
|
*/
|
|
private static class DropDownAdapter implements ListAdapter, SpinnerAdapter {
|
|
private SpinnerAdapter mAdapter;
|
|
private ListAdapter mListAdapter;
|
|
|
|
/**
|
|
* Creates a new ListAdapter wrapper for the specified adapter.
|
|
*
|
|
* @param adapter the SpinnerAdapter to transform into a ListAdapter
|
|
* @param dropDownTheme the theme against which to inflate drop-down
|
|
* views, may be {@null} to use default theme
|
|
*/
|
|
public DropDownAdapter(@Nullable SpinnerAdapter adapter,
|
|
@Nullable Resources.Theme dropDownTheme) {
|
|
mAdapter = adapter;
|
|
|
|
if (adapter instanceof ListAdapter) {
|
|
mListAdapter = (ListAdapter) adapter;
|
|
}
|
|
|
|
if (dropDownTheme != null && adapter instanceof ThemedSpinnerAdapter) {
|
|
final ThemedSpinnerAdapter themedAdapter = (ThemedSpinnerAdapter) adapter;
|
|
if (themedAdapter.getDropDownViewTheme() == null) {
|
|
themedAdapter.setDropDownViewTheme(dropDownTheme);
|
|
}
|
|
}
|
|
}
|
|
|
|
public int getCount() {
|
|
return mAdapter == null ? 0 : mAdapter.getCount();
|
|
}
|
|
|
|
public Object getItem(int position) {
|
|
return mAdapter == null ? null : mAdapter.getItem(position);
|
|
}
|
|
|
|
public long getItemId(int position) {
|
|
return mAdapter == null ? -1 : mAdapter.getItemId(position);
|
|
}
|
|
|
|
public View getView(int position, View convertView, ViewGroup parent) {
|
|
return getDropDownView(position, convertView, parent);
|
|
}
|
|
|
|
public View getDropDownView(int position, View convertView, ViewGroup parent) {
|
|
return (mAdapter == null) ? null : mAdapter.getDropDownView(position, convertView, parent);
|
|
}
|
|
|
|
public boolean hasStableIds() {
|
|
return mAdapter != null && mAdapter.hasStableIds();
|
|
}
|
|
|
|
public void registerDataSetObserver(DataSetObserver observer) {
|
|
if (mAdapter != null) {
|
|
mAdapter.registerDataSetObserver(observer);
|
|
}
|
|
}
|
|
|
|
public void unregisterDataSetObserver(DataSetObserver observer) {
|
|
if (mAdapter != null) {
|
|
mAdapter.unregisterDataSetObserver(observer);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If the wrapped SpinnerAdapter is also a ListAdapter, delegate this call.
|
|
* Otherwise, return true.
|
|
*/
|
|
public boolean areAllItemsEnabled() {
|
|
final ListAdapter adapter = mListAdapter;
|
|
if (adapter != null) {
|
|
return adapter.areAllItemsEnabled();
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If the wrapped SpinnerAdapter is also a ListAdapter, delegate this call.
|
|
* Otherwise, return true.
|
|
*/
|
|
public boolean isEnabled(int position) {
|
|
final ListAdapter adapter = mListAdapter;
|
|
if (adapter != null) {
|
|
return adapter.isEnabled(position);
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public int getItemViewType(int position) {
|
|
return 0;
|
|
}
|
|
|
|
public int getViewTypeCount() {
|
|
return 1;
|
|
}
|
|
|
|
public boolean isEmpty() {
|
|
return getCount() == 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implements some sort of popup selection interface for selecting a spinner option.
|
|
* Allows for different spinner modes.
|
|
*/
|
|
private interface SpinnerPopup {
|
|
public void setAdapter(ListAdapter adapter);
|
|
|
|
/**
|
|
* Show the popup
|
|
*/
|
|
public void show(int textDirection, int textAlignment);
|
|
|
|
/**
|
|
* Dismiss the popup
|
|
*/
|
|
public void dismiss();
|
|
|
|
/**
|
|
* @return true if the popup is showing, false otherwise.
|
|
*/
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
public boolean isShowing();
|
|
|
|
/**
|
|
* Set hint text to be displayed to the user. This should provide
|
|
* a description of the choice being made.
|
|
* @param hintText Hint text to set.
|
|
*/
|
|
public void setPromptText(CharSequence hintText);
|
|
public CharSequence getHintText();
|
|
|
|
public void setBackgroundDrawable(Drawable bg);
|
|
public void setVerticalOffset(int px);
|
|
public void setHorizontalOffset(int px);
|
|
public Drawable getBackground();
|
|
public int getVerticalOffset();
|
|
public int getHorizontalOffset();
|
|
}
|
|
|
|
private class DialogPopup implements SpinnerPopup, DialogInterface.OnClickListener {
|
|
private AlertDialog mPopup;
|
|
private ListAdapter mListAdapter;
|
|
private CharSequence mPrompt;
|
|
|
|
public void dismiss() {
|
|
if (mPopup != null) {
|
|
mPopup.dismiss();
|
|
mPopup = null;
|
|
}
|
|
}
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
public boolean isShowing() {
|
|
return mPopup != null ? mPopup.isShowing() : false;
|
|
}
|
|
|
|
public void setAdapter(ListAdapter adapter) {
|
|
mListAdapter = adapter;
|
|
}
|
|
|
|
public void setPromptText(CharSequence hintText) {
|
|
mPrompt = hintText;
|
|
}
|
|
|
|
public CharSequence getHintText() {
|
|
return mPrompt;
|
|
}
|
|
|
|
public void show(int textDirection, int textAlignment) {
|
|
if (mListAdapter == null) {
|
|
return;
|
|
}
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getPopupContext());
|
|
if (mPrompt != null) {
|
|
builder.setTitle(mPrompt);
|
|
}
|
|
mPopup = builder.setSingleChoiceItems(mListAdapter,
|
|
getSelectedItemPosition(), this).create();
|
|
final ListView listView = mPopup.getListView();
|
|
listView.setTextDirection(textDirection);
|
|
listView.setTextAlignment(textAlignment);
|
|
mPopup.show();
|
|
}
|
|
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
setSelection(which);
|
|
if (mOnItemClickListener != null) {
|
|
performItemClick(null, which, mListAdapter.getItemId(which));
|
|
}
|
|
dismiss();
|
|
}
|
|
|
|
@Override
|
|
public void setBackgroundDrawable(Drawable bg) {
|
|
Log.e(TAG, "Cannot set popup background for MODE_DIALOG, ignoring");
|
|
}
|
|
|
|
@Override
|
|
public void setVerticalOffset(int px) {
|
|
Log.e(TAG, "Cannot set vertical offset for MODE_DIALOG, ignoring");
|
|
}
|
|
|
|
@Override
|
|
public void setHorizontalOffset(int px) {
|
|
Log.e(TAG, "Cannot set horizontal offset for MODE_DIALOG, ignoring");
|
|
}
|
|
|
|
@Override
|
|
public Drawable getBackground() {
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public int getVerticalOffset() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public int getHorizontalOffset() {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private class DropdownPopup extends ListPopupWindow implements SpinnerPopup {
|
|
private CharSequence mHintText;
|
|
private ListAdapter mAdapter;
|
|
|
|
public DropdownPopup(
|
|
Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
|
|
super(context, attrs, defStyleAttr, defStyleRes);
|
|
|
|
setAnchorView(Spinner.this);
|
|
setModal(true);
|
|
setPromptPosition(POSITION_PROMPT_ABOVE);
|
|
setOnItemClickListener(new OnItemClickListener() {
|
|
public void onItemClick(AdapterView parent, View v, int position, long id) {
|
|
Spinner.this.setSelection(position);
|
|
if (mOnItemClickListener != null) {
|
|
Spinner.this.performItemClick(v, position, mAdapter.getItemId(position));
|
|
}
|
|
dismiss();
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void setAdapter(ListAdapter adapter) {
|
|
super.setAdapter(adapter);
|
|
mAdapter = adapter;
|
|
}
|
|
|
|
public CharSequence getHintText() {
|
|
return mHintText;
|
|
}
|
|
|
|
public void setPromptText(CharSequence hintText) {
|
|
// Hint text is ignored for dropdowns, but maintain it here.
|
|
mHintText = hintText;
|
|
}
|
|
|
|
void computeContentWidth() {
|
|
final Drawable background = getBackground();
|
|
int hOffset = 0;
|
|
if (background != null) {
|
|
background.getPadding(mTempRect);
|
|
hOffset = isLayoutRtl() ? mTempRect.right : -mTempRect.left;
|
|
} else {
|
|
mTempRect.left = mTempRect.right = 0;
|
|
}
|
|
|
|
final int spinnerPaddingLeft = Spinner.this.getPaddingLeft();
|
|
final int spinnerPaddingRight = Spinner.this.getPaddingRight();
|
|
final int spinnerWidth = Spinner.this.getWidth();
|
|
|
|
if (mDropDownWidth == WRAP_CONTENT) {
|
|
int contentWidth = measureContentWidth(
|
|
(SpinnerAdapter) mAdapter, getBackground());
|
|
final int contentWidthLimit = mContext.getResources()
|
|
.getDisplayMetrics().widthPixels - mTempRect.left - mTempRect.right;
|
|
if (contentWidth > contentWidthLimit) {
|
|
contentWidth = contentWidthLimit;
|
|
}
|
|
setContentWidth(Math.max(
|
|
contentWidth, spinnerWidth - spinnerPaddingLeft - spinnerPaddingRight));
|
|
} else if (mDropDownWidth == MATCH_PARENT) {
|
|
setContentWidth(spinnerWidth - spinnerPaddingLeft - spinnerPaddingRight);
|
|
} else {
|
|
setContentWidth(mDropDownWidth);
|
|
}
|
|
|
|
if (isLayoutRtl()) {
|
|
hOffset += spinnerWidth - spinnerPaddingRight - getWidth();
|
|
} else {
|
|
hOffset += spinnerPaddingLeft;
|
|
}
|
|
setHorizontalOffset(hOffset);
|
|
}
|
|
|
|
public void show(int textDirection, int textAlignment) {
|
|
final boolean wasShowing = isShowing();
|
|
|
|
computeContentWidth();
|
|
|
|
setInputMethodMode(ListPopupWindow.INPUT_METHOD_NOT_NEEDED);
|
|
super.show();
|
|
final ListView listView = getListView();
|
|
listView.setChoiceMode(ListView.CHOICE_MODE_SINGLE);
|
|
listView.setTextDirection(textDirection);
|
|
listView.setTextAlignment(textAlignment);
|
|
setSelection(Spinner.this.getSelectedItemPosition());
|
|
|
|
if (wasShowing) {
|
|
// Skip setting up the layout/dismiss listener below. If we were previously
|
|
// showing it will still stick around.
|
|
return;
|
|
}
|
|
|
|
// Make sure we hide if our anchor goes away.
|
|
// TODO: This might be appropriate to push all the way down to PopupWindow,
|
|
// but it may have other side effects to investigate first. (Text editing handles, etc.)
|
|
final ViewTreeObserver vto = getViewTreeObserver();
|
|
if (vto != null) {
|
|
final OnGlobalLayoutListener layoutListener = new OnGlobalLayoutListener() {
|
|
@Override
|
|
public void onGlobalLayout() {
|
|
if (!Spinner.this.isVisibleToUser()) {
|
|
dismiss();
|
|
} else {
|
|
computeContentWidth();
|
|
|
|
// Use super.show here to update; we don't want to move the selected
|
|
// position or adjust other things that would be reset otherwise.
|
|
DropdownPopup.super.show();
|
|
}
|
|
}
|
|
};
|
|
vto.addOnGlobalLayoutListener(layoutListener);
|
|
setOnDismissListener(new OnDismissListener() {
|
|
@Override public void onDismiss() {
|
|
final ViewTreeObserver vto = getViewTreeObserver();
|
|
if (vto != null) {
|
|
vto.removeOnGlobalLayoutListener(layoutListener);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|