887 lines
33 KiB
Java
887 lines
33 KiB
Java
package androidx.appcompat.widget;
|
|
|
|
import android.content.Context;
|
|
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.Handler;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.view.KeyEvent;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.ViewParent;
|
|
import android.widget.AbsListView;
|
|
import android.widget.AdapterView;
|
|
import android.widget.LinearLayout;
|
|
import android.widget.ListAdapter;
|
|
import android.widget.ListView;
|
|
import android.widget.PopupWindow;
|
|
import androidx.annotation.AttrRes;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.RestrictTo;
|
|
import androidx.annotation.StyleRes;
|
|
import androidx.appcompat.R;
|
|
import androidx.appcompat.view.menu.ShowableListMenu;
|
|
import androidx.constraintlayout.solver.widgets.analyzer.BasicMeasure;
|
|
import androidx.core.view.PointerIconCompat;
|
|
import androidx.core.view.ViewCompat;
|
|
import androidx.core.widget.PopupWindowCompat;
|
|
import c.d.b.a.a;
|
|
import java.lang.reflect.Method;
|
|
public class ListPopupWindow implements ShowableListMenu {
|
|
private static final boolean DEBUG = false;
|
|
public static final int EXPAND_LIST_TIMEOUT = 250;
|
|
public static final int INPUT_METHOD_FROM_FOCUSABLE = 0;
|
|
public static final int INPUT_METHOD_NEEDED = 1;
|
|
public static final int INPUT_METHOD_NOT_NEEDED = 2;
|
|
public static final int MATCH_PARENT = -1;
|
|
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 = -2;
|
|
private static Method sGetMaxAvailableHeightMethod;
|
|
private static Method sSetClipToWindowEnabledMethod;
|
|
private static Method sSetEpicenterBoundsMethod;
|
|
private ListAdapter mAdapter;
|
|
private Context mContext;
|
|
private boolean mDropDownAlwaysVisible;
|
|
private View mDropDownAnchorView;
|
|
private int mDropDownGravity;
|
|
private int mDropDownHeight;
|
|
private int mDropDownHorizontalOffset;
|
|
public DropDownListView mDropDownList;
|
|
private Drawable mDropDownListHighlight;
|
|
private int mDropDownVerticalOffset;
|
|
private boolean mDropDownVerticalOffsetSet;
|
|
private int mDropDownWidth;
|
|
private int mDropDownWindowLayoutType;
|
|
private Rect mEpicenterBounds;
|
|
private boolean mForceIgnoreOutsideTouch;
|
|
public final Handler mHandler;
|
|
private final ListSelectorHider mHideSelector;
|
|
private AdapterView.OnItemClickListener mItemClickListener;
|
|
private AdapterView.OnItemSelectedListener mItemSelectedListener;
|
|
public int mListItemExpandMaximum;
|
|
private boolean mModal;
|
|
private DataSetObserver mObserver;
|
|
private boolean mOverlapAnchor;
|
|
private boolean mOverlapAnchorSet;
|
|
public PopupWindow mPopup;
|
|
private int mPromptPosition;
|
|
private View mPromptView;
|
|
public final ResizePopupRunnable mResizePopupRunnable;
|
|
private final PopupScrollListener mScrollListener;
|
|
private Runnable mShowDropDownRunnable;
|
|
private final Rect mTempRect;
|
|
private final PopupTouchInterceptor mTouchInterceptor;
|
|
|
|
/* renamed from: androidx.appcompat.widget.ListPopupWindow$1 reason: invalid class name */
|
|
public class AnonymousClass1 extends ForwardingListener {
|
|
public AnonymousClass1(View view) {
|
|
super(view);
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.ForwardingListener
|
|
public ListPopupWindow getPopup() {
|
|
return ListPopupWindow.this;
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.appcompat.widget.ListPopupWindow$2 reason: invalid class name */
|
|
public class AnonymousClass2 implements Runnable {
|
|
public AnonymousClass2() {
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
View anchorView = ListPopupWindow.this.getAnchorView();
|
|
if (anchorView != null && anchorView.getWindowToken() != null) {
|
|
ListPopupWindow.this.show();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.appcompat.widget.ListPopupWindow$3 reason: invalid class name */
|
|
public class AnonymousClass3 implements AdapterView.OnItemSelectedListener {
|
|
public AnonymousClass3() {
|
|
}
|
|
|
|
@Override // android.widget.AdapterView.OnItemSelectedListener
|
|
public void onItemSelected(AdapterView<?> adapterView, View view, int i, long j) {
|
|
DropDownListView dropDownListView;
|
|
if (i != -1 && (dropDownListView = ListPopupWindow.this.mDropDownList) != null) {
|
|
dropDownListView.setListSelectionHidden(false);
|
|
}
|
|
}
|
|
|
|
@Override // android.widget.AdapterView.OnItemSelectedListener
|
|
public void onNothingSelected(AdapterView<?> adapterView) {
|
|
}
|
|
}
|
|
|
|
public class ListSelectorHider implements Runnable {
|
|
public ListSelectorHider() {
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
ListPopupWindow.this.clearListSelection();
|
|
}
|
|
}
|
|
|
|
public class PopupDataSetObserver extends DataSetObserver {
|
|
public PopupDataSetObserver() {
|
|
}
|
|
|
|
@Override // android.database.DataSetObserver
|
|
public void onChanged() {
|
|
if (ListPopupWindow.this.isShowing()) {
|
|
ListPopupWindow.this.show();
|
|
}
|
|
}
|
|
|
|
@Override // android.database.DataSetObserver
|
|
public void onInvalidated() {
|
|
ListPopupWindow.this.dismiss();
|
|
}
|
|
}
|
|
|
|
public class PopupScrollListener implements AbsListView.OnScrollListener {
|
|
public PopupScrollListener() {
|
|
}
|
|
|
|
@Override // android.widget.AbsListView.OnScrollListener
|
|
public void onScroll(AbsListView absListView, int i, int i2, int i3) {
|
|
}
|
|
|
|
@Override // android.widget.AbsListView.OnScrollListener
|
|
public void onScrollStateChanged(AbsListView absListView, int i) {
|
|
if (i == 1 && !ListPopupWindow.this.isInputMethodNotNeeded() && ListPopupWindow.this.mPopup.getContentView() != null) {
|
|
ListPopupWindow listPopupWindow = ListPopupWindow.this;
|
|
listPopupWindow.mHandler.removeCallbacks(listPopupWindow.mResizePopupRunnable);
|
|
ListPopupWindow.this.mResizePopupRunnable.run();
|
|
}
|
|
}
|
|
}
|
|
|
|
public class PopupTouchInterceptor implements View.OnTouchListener {
|
|
public PopupTouchInterceptor() {
|
|
}
|
|
|
|
@Override // android.view.View.OnTouchListener
|
|
public boolean onTouch(View view, MotionEvent motionEvent) {
|
|
PopupWindow popupWindow;
|
|
int action = motionEvent.getAction();
|
|
int x2 = (int) motionEvent.getX();
|
|
int y2 = (int) motionEvent.getY();
|
|
if (action == 0 && (popupWindow = ListPopupWindow.this.mPopup) != null && popupWindow.isShowing() && x2 >= 0 && x2 < ListPopupWindow.this.mPopup.getWidth() && y2 >= 0 && y2 < ListPopupWindow.this.mPopup.getHeight()) {
|
|
ListPopupWindow listPopupWindow = ListPopupWindow.this;
|
|
listPopupWindow.mHandler.postDelayed(listPopupWindow.mResizePopupRunnable, 250);
|
|
return false;
|
|
} else if (action != 1) {
|
|
return false;
|
|
} else {
|
|
ListPopupWindow listPopupWindow2 = ListPopupWindow.this;
|
|
listPopupWindow2.mHandler.removeCallbacks(listPopupWindow2.mResizePopupRunnable);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ResizePopupRunnable implements Runnable {
|
|
public ResizePopupRunnable() {
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
DropDownListView dropDownListView = ListPopupWindow.this.mDropDownList;
|
|
if (dropDownListView != null && ViewCompat.isAttachedToWindow(dropDownListView) && ListPopupWindow.this.mDropDownList.getCount() > ListPopupWindow.this.mDropDownList.getChildCount()) {
|
|
int childCount = ListPopupWindow.this.mDropDownList.getChildCount();
|
|
ListPopupWindow listPopupWindow = ListPopupWindow.this;
|
|
if (childCount <= listPopupWindow.mListItemExpandMaximum) {
|
|
listPopupWindow.mPopup.setInputMethodMode(2);
|
|
ListPopupWindow.this.show();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static {
|
|
if (Build.VERSION.SDK_INT <= 28) {
|
|
try {
|
|
sSetClipToWindowEnabledMethod = PopupWindow.class.getDeclaredMethod("setClipToScreenEnabled", Boolean.TYPE);
|
|
} catch (NoSuchMethodException unused) {
|
|
Log.i(TAG, "Could not find method setClipToScreenEnabled() on PopupWindow. Oh well.");
|
|
}
|
|
try {
|
|
sSetEpicenterBoundsMethod = PopupWindow.class.getDeclaredMethod("setEpicenterBounds", Rect.class);
|
|
} catch (NoSuchMethodException unused2) {
|
|
Log.i(TAG, "Could not find method setEpicenterBounds(Rect) on PopupWindow. Oh well.");
|
|
}
|
|
}
|
|
if (Build.VERSION.SDK_INT <= 23) {
|
|
try {
|
|
sGetMaxAvailableHeightMethod = PopupWindow.class.getDeclaredMethod("getMaxAvailableHeight", View.class, Integer.TYPE, Boolean.TYPE);
|
|
} catch (NoSuchMethodException unused3) {
|
|
Log.i(TAG, "Could not find method getMaxAvailableHeight(View, int, boolean) on PopupWindow. Oh well.");
|
|
}
|
|
}
|
|
}
|
|
|
|
public ListPopupWindow(@NonNull Context context) {
|
|
this(context, null, R.attr.listPopupWindowStyle);
|
|
}
|
|
|
|
public ListPopupWindow(@NonNull Context context, @Nullable AttributeSet attributeSet) {
|
|
this(context, attributeSet, R.attr.listPopupWindowStyle);
|
|
}
|
|
|
|
public ListPopupWindow(@NonNull Context context, @Nullable AttributeSet attributeSet, @AttrRes int i) {
|
|
this(context, attributeSet, i, 0);
|
|
}
|
|
|
|
public ListPopupWindow(@NonNull Context context, @Nullable AttributeSet attributeSet, @AttrRes int i, @StyleRes int i2) {
|
|
this.mDropDownHeight = -2;
|
|
this.mDropDownWidth = -2;
|
|
this.mDropDownWindowLayoutType = PointerIconCompat.TYPE_HAND;
|
|
this.mDropDownGravity = 0;
|
|
this.mDropDownAlwaysVisible = false;
|
|
this.mForceIgnoreOutsideTouch = false;
|
|
this.mListItemExpandMaximum = Integer.MAX_VALUE;
|
|
this.mPromptPosition = 0;
|
|
this.mResizePopupRunnable = new ResizePopupRunnable();
|
|
this.mTouchInterceptor = new PopupTouchInterceptor();
|
|
this.mScrollListener = new PopupScrollListener();
|
|
this.mHideSelector = new ListSelectorHider();
|
|
this.mTempRect = new Rect();
|
|
this.mContext = context;
|
|
this.mHandler = new Handler(context.getMainLooper());
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.ListPopupWindow, i, i2);
|
|
this.mDropDownHorizontalOffset = obtainStyledAttributes.getDimensionPixelOffset(R.styleable.ListPopupWindow_android_dropDownHorizontalOffset, 0);
|
|
int dimensionPixelOffset = obtainStyledAttributes.getDimensionPixelOffset(R.styleable.ListPopupWindow_android_dropDownVerticalOffset, 0);
|
|
this.mDropDownVerticalOffset = dimensionPixelOffset;
|
|
if (dimensionPixelOffset != 0) {
|
|
this.mDropDownVerticalOffsetSet = true;
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
AppCompatPopupWindow appCompatPopupWindow = new AppCompatPopupWindow(context, attributeSet, i, i2);
|
|
this.mPopup = appCompatPopupWindow;
|
|
appCompatPopupWindow.setInputMethodMode(1);
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r7v1, resolved type: android.widget.LinearLayout */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
private int buildDropDown() {
|
|
int i;
|
|
int i2;
|
|
int i3;
|
|
int i4;
|
|
boolean z2 = true;
|
|
if (this.mDropDownList == null) {
|
|
Context context = this.mContext;
|
|
this.mShowDropDownRunnable = new AnonymousClass2();
|
|
DropDownListView createDropDownListView = createDropDownListView(context, !this.mModal);
|
|
this.mDropDownList = createDropDownListView;
|
|
Drawable drawable = this.mDropDownListHighlight;
|
|
if (drawable != null) {
|
|
createDropDownListView.setSelector(drawable);
|
|
}
|
|
this.mDropDownList.setAdapter(this.mAdapter);
|
|
this.mDropDownList.setOnItemClickListener(this.mItemClickListener);
|
|
this.mDropDownList.setFocusable(true);
|
|
this.mDropDownList.setFocusableInTouchMode(true);
|
|
this.mDropDownList.setOnItemSelectedListener(new AnonymousClass3());
|
|
this.mDropDownList.setOnScrollListener(this.mScrollListener);
|
|
AdapterView.OnItemSelectedListener onItemSelectedListener = this.mItemSelectedListener;
|
|
if (onItemSelectedListener != null) {
|
|
this.mDropDownList.setOnItemSelectedListener(onItemSelectedListener);
|
|
}
|
|
DropDownListView dropDownListView = this.mDropDownList;
|
|
View view = this.mPromptView;
|
|
if (view != null) {
|
|
LinearLayout linearLayout = new LinearLayout(context);
|
|
linearLayout.setOrientation(1);
|
|
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(-1, 0, 1.0f);
|
|
int i5 = this.mPromptPosition;
|
|
if (i5 == 0) {
|
|
linearLayout.addView(view);
|
|
linearLayout.addView(dropDownListView, layoutParams);
|
|
} else if (i5 != 1) {
|
|
StringBuilder L = a.L("Invalid hint position ");
|
|
L.append(this.mPromptPosition);
|
|
Log.e(TAG, L.toString());
|
|
} else {
|
|
linearLayout.addView(dropDownListView, layoutParams);
|
|
linearLayout.addView(view);
|
|
}
|
|
int i6 = this.mDropDownWidth;
|
|
if (i6 >= 0) {
|
|
i4 = Integer.MIN_VALUE;
|
|
} else {
|
|
i6 = 0;
|
|
i4 = 0;
|
|
}
|
|
view.measure(View.MeasureSpec.makeMeasureSpec(i6, i4), 0);
|
|
LinearLayout.LayoutParams layoutParams2 = (LinearLayout.LayoutParams) view.getLayoutParams();
|
|
i = view.getMeasuredHeight() + layoutParams2.topMargin + layoutParams2.bottomMargin;
|
|
dropDownListView = linearLayout;
|
|
} else {
|
|
i = 0;
|
|
}
|
|
this.mPopup.setContentView(dropDownListView);
|
|
} else {
|
|
ViewGroup viewGroup = (ViewGroup) this.mPopup.getContentView();
|
|
View view2 = this.mPromptView;
|
|
if (view2 != null) {
|
|
LinearLayout.LayoutParams layoutParams3 = (LinearLayout.LayoutParams) view2.getLayoutParams();
|
|
i = layoutParams3.bottomMargin + view2.getMeasuredHeight() + layoutParams3.topMargin;
|
|
} else {
|
|
i = 0;
|
|
}
|
|
}
|
|
Drawable background = this.mPopup.getBackground();
|
|
if (background != null) {
|
|
background.getPadding(this.mTempRect);
|
|
Rect rect = this.mTempRect;
|
|
int i7 = rect.top;
|
|
i2 = rect.bottom + i7;
|
|
if (!this.mDropDownVerticalOffsetSet) {
|
|
this.mDropDownVerticalOffset = -i7;
|
|
}
|
|
} else {
|
|
this.mTempRect.setEmpty();
|
|
i2 = 0;
|
|
}
|
|
if (this.mPopup.getInputMethodMode() != 2) {
|
|
z2 = false;
|
|
}
|
|
int maxAvailableHeight = getMaxAvailableHeight(getAnchorView(), this.mDropDownVerticalOffset, z2);
|
|
if (this.mDropDownAlwaysVisible || this.mDropDownHeight == -1) {
|
|
return maxAvailableHeight + i2;
|
|
}
|
|
int i8 = this.mDropDownWidth;
|
|
if (i8 == -2) {
|
|
int i9 = this.mContext.getResources().getDisplayMetrics().widthPixels;
|
|
Rect rect2 = this.mTempRect;
|
|
i3 = View.MeasureSpec.makeMeasureSpec(i9 - (rect2.left + rect2.right), Integer.MIN_VALUE);
|
|
} else if (i8 != -1) {
|
|
i3 = View.MeasureSpec.makeMeasureSpec(i8, BasicMeasure.EXACTLY);
|
|
} else {
|
|
int i10 = this.mContext.getResources().getDisplayMetrics().widthPixels;
|
|
Rect rect3 = this.mTempRect;
|
|
i3 = View.MeasureSpec.makeMeasureSpec(i10 - (rect3.left + rect3.right), BasicMeasure.EXACTLY);
|
|
}
|
|
int measureHeightOfChildrenCompat = this.mDropDownList.measureHeightOfChildrenCompat(i3, 0, -1, maxAvailableHeight - i, -1);
|
|
if (measureHeightOfChildrenCompat > 0) {
|
|
i += this.mDropDownList.getPaddingBottom() + this.mDropDownList.getPaddingTop() + i2;
|
|
}
|
|
return measureHeightOfChildrenCompat + i;
|
|
}
|
|
|
|
private int getMaxAvailableHeight(View view, int i, boolean z2) {
|
|
if (Build.VERSION.SDK_INT > 23) {
|
|
return this.mPopup.getMaxAvailableHeight(view, i, z2);
|
|
}
|
|
Method method = sGetMaxAvailableHeightMethod;
|
|
if (method != null) {
|
|
try {
|
|
return ((Integer) method.invoke(this.mPopup, view, Integer.valueOf(i), Boolean.valueOf(z2))).intValue();
|
|
} catch (Exception unused) {
|
|
Log.i(TAG, "Could not call getMaxAvailableHeightMethod(View, int, boolean) on PopupWindow. Using the public version.");
|
|
}
|
|
}
|
|
return this.mPopup.getMaxAvailableHeight(view, i);
|
|
}
|
|
|
|
private static boolean isConfirmKey(int i) {
|
|
return i == 66 || i == 23;
|
|
}
|
|
|
|
private void removePromptView() {
|
|
View view = this.mPromptView;
|
|
if (view != null) {
|
|
ViewParent parent = view.getParent();
|
|
if (parent instanceof ViewGroup) {
|
|
((ViewGroup) parent).removeView(this.mPromptView);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void setPopupClipToScreenEnabled(boolean z2) {
|
|
if (Build.VERSION.SDK_INT <= 28) {
|
|
Method method = sSetClipToWindowEnabledMethod;
|
|
if (method != null) {
|
|
try {
|
|
method.invoke(this.mPopup, Boolean.valueOf(z2));
|
|
} catch (Exception unused) {
|
|
Log.i(TAG, "Could not call setClipToScreenEnabled() on PopupWindow. Oh well.");
|
|
}
|
|
}
|
|
} else {
|
|
this.mPopup.setIsClippedToScreen(z2);
|
|
}
|
|
}
|
|
|
|
public void clearListSelection() {
|
|
DropDownListView dropDownListView = this.mDropDownList;
|
|
if (dropDownListView != null) {
|
|
dropDownListView.setListSelectionHidden(true);
|
|
dropDownListView.requestLayout();
|
|
}
|
|
}
|
|
|
|
public View.OnTouchListener createDragToOpenListener(View view) {
|
|
return new AnonymousClass1(view);
|
|
}
|
|
|
|
@NonNull
|
|
public DropDownListView createDropDownListView(Context context, boolean z2) {
|
|
return new DropDownListView(context, z2);
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.ShowableListMenu
|
|
public void dismiss() {
|
|
this.mPopup.dismiss();
|
|
removePromptView();
|
|
this.mPopup.setContentView(null);
|
|
this.mDropDownList = null;
|
|
this.mHandler.removeCallbacks(this.mResizePopupRunnable);
|
|
}
|
|
|
|
@Nullable
|
|
public View getAnchorView() {
|
|
return this.mDropDownAnchorView;
|
|
}
|
|
|
|
@StyleRes
|
|
public int getAnimationStyle() {
|
|
return this.mPopup.getAnimationStyle();
|
|
}
|
|
|
|
@Nullable
|
|
public Drawable getBackground() {
|
|
return this.mPopup.getBackground();
|
|
}
|
|
|
|
@Nullable
|
|
public Rect getEpicenterBounds() {
|
|
if (this.mEpicenterBounds != null) {
|
|
return new Rect(this.mEpicenterBounds);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public int getHeight() {
|
|
return this.mDropDownHeight;
|
|
}
|
|
|
|
public int getHorizontalOffset() {
|
|
return this.mDropDownHorizontalOffset;
|
|
}
|
|
|
|
public int getInputMethodMode() {
|
|
return this.mPopup.getInputMethodMode();
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.ShowableListMenu
|
|
@Nullable
|
|
public ListView getListView() {
|
|
return this.mDropDownList;
|
|
}
|
|
|
|
public int getPromptPosition() {
|
|
return this.mPromptPosition;
|
|
}
|
|
|
|
@Nullable
|
|
public Object getSelectedItem() {
|
|
if (!isShowing()) {
|
|
return null;
|
|
}
|
|
return this.mDropDownList.getSelectedItem();
|
|
}
|
|
|
|
public long getSelectedItemId() {
|
|
if (!isShowing()) {
|
|
return Long.MIN_VALUE;
|
|
}
|
|
return this.mDropDownList.getSelectedItemId();
|
|
}
|
|
|
|
public int getSelectedItemPosition() {
|
|
if (!isShowing()) {
|
|
return -1;
|
|
}
|
|
return this.mDropDownList.getSelectedItemPosition();
|
|
}
|
|
|
|
@Nullable
|
|
public View getSelectedView() {
|
|
if (!isShowing()) {
|
|
return null;
|
|
}
|
|
return this.mDropDownList.getSelectedView();
|
|
}
|
|
|
|
public int getSoftInputMode() {
|
|
return this.mPopup.getSoftInputMode();
|
|
}
|
|
|
|
public int getVerticalOffset() {
|
|
if (!this.mDropDownVerticalOffsetSet) {
|
|
return 0;
|
|
}
|
|
return this.mDropDownVerticalOffset;
|
|
}
|
|
|
|
public int getWidth() {
|
|
return this.mDropDownWidth;
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public boolean isDropDownAlwaysVisible() {
|
|
return this.mDropDownAlwaysVisible;
|
|
}
|
|
|
|
public boolean isInputMethodNotNeeded() {
|
|
return this.mPopup.getInputMethodMode() == 2;
|
|
}
|
|
|
|
public boolean isModal() {
|
|
return this.mModal;
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.ShowableListMenu
|
|
public boolean isShowing() {
|
|
return this.mPopup.isShowing();
|
|
}
|
|
|
|
public boolean onKeyDown(int i, @NonNull KeyEvent keyEvent) {
|
|
if (isShowing() && i != 62 && (this.mDropDownList.getSelectedItemPosition() >= 0 || !isConfirmKey(i))) {
|
|
int selectedItemPosition = this.mDropDownList.getSelectedItemPosition();
|
|
boolean z2 = !this.mPopup.isAboveAnchor();
|
|
ListAdapter listAdapter = this.mAdapter;
|
|
int i2 = Integer.MAX_VALUE;
|
|
int i3 = Integer.MIN_VALUE;
|
|
if (listAdapter != null) {
|
|
boolean areAllItemsEnabled = listAdapter.areAllItemsEnabled();
|
|
int lookForSelectablePosition = areAllItemsEnabled ? 0 : this.mDropDownList.lookForSelectablePosition(0, true);
|
|
int count = areAllItemsEnabled ? listAdapter.getCount() - 1 : this.mDropDownList.lookForSelectablePosition(listAdapter.getCount() - 1, false);
|
|
i2 = lookForSelectablePosition;
|
|
i3 = count;
|
|
}
|
|
if ((!z2 || i != 19 || selectedItemPosition > i2) && (z2 || i != 20 || selectedItemPosition < i3)) {
|
|
this.mDropDownList.setListSelectionHidden(false);
|
|
if (this.mDropDownList.onKeyDown(i, keyEvent)) {
|
|
this.mPopup.setInputMethodMode(2);
|
|
this.mDropDownList.requestFocusFromTouch();
|
|
show();
|
|
if (i == 19 || i == 20 || i == 23 || i == 66) {
|
|
return true;
|
|
}
|
|
} else if (!z2 || i != 20) {
|
|
if (!z2 && i == 19 && selectedItemPosition == i2) {
|
|
return true;
|
|
}
|
|
} else if (selectedItemPosition == i3) {
|
|
return true;
|
|
}
|
|
} else {
|
|
clearListSelection();
|
|
this.mPopup.setInputMethodMode(1);
|
|
show();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean onKeyPreIme(int i, @NonNull KeyEvent keyEvent) {
|
|
if (i != 4 || !isShowing()) {
|
|
return false;
|
|
}
|
|
View view = this.mDropDownAnchorView;
|
|
if (keyEvent.getAction() == 0 && keyEvent.getRepeatCount() == 0) {
|
|
KeyEvent.DispatcherState keyDispatcherState = view.getKeyDispatcherState();
|
|
if (keyDispatcherState != null) {
|
|
keyDispatcherState.startTracking(keyEvent, this);
|
|
}
|
|
return true;
|
|
} else if (keyEvent.getAction() != 1) {
|
|
return false;
|
|
} else {
|
|
KeyEvent.DispatcherState keyDispatcherState2 = view.getKeyDispatcherState();
|
|
if (keyDispatcherState2 != null) {
|
|
keyDispatcherState2.handleUpEvent(keyEvent);
|
|
}
|
|
if (!keyEvent.isTracking() || keyEvent.isCanceled()) {
|
|
return false;
|
|
}
|
|
dismiss();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public boolean onKeyUp(int i, @NonNull KeyEvent keyEvent) {
|
|
if (!isShowing() || this.mDropDownList.getSelectedItemPosition() < 0) {
|
|
return false;
|
|
}
|
|
boolean onKeyUp = this.mDropDownList.onKeyUp(i, keyEvent);
|
|
if (onKeyUp && isConfirmKey(i)) {
|
|
dismiss();
|
|
}
|
|
return onKeyUp;
|
|
}
|
|
|
|
public boolean performItemClick(int i) {
|
|
if (!isShowing()) {
|
|
return false;
|
|
}
|
|
if (this.mItemClickListener == null) {
|
|
return true;
|
|
}
|
|
DropDownListView dropDownListView = this.mDropDownList;
|
|
this.mItemClickListener.onItemClick(dropDownListView, dropDownListView.getChildAt(i - dropDownListView.getFirstVisiblePosition()), i, dropDownListView.getAdapter().getItemId(i));
|
|
return true;
|
|
}
|
|
|
|
public void postShow() {
|
|
this.mHandler.post(this.mShowDropDownRunnable);
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.AppCompatSpinner.SpinnerPopup
|
|
public void setAdapter(@Nullable ListAdapter listAdapter) {
|
|
DataSetObserver dataSetObserver = this.mObserver;
|
|
if (dataSetObserver == null) {
|
|
this.mObserver = new PopupDataSetObserver();
|
|
} else {
|
|
ListAdapter listAdapter2 = this.mAdapter;
|
|
if (listAdapter2 != null) {
|
|
listAdapter2.unregisterDataSetObserver(dataSetObserver);
|
|
}
|
|
}
|
|
this.mAdapter = listAdapter;
|
|
if (listAdapter != null) {
|
|
listAdapter.registerDataSetObserver(this.mObserver);
|
|
}
|
|
DropDownListView dropDownListView = this.mDropDownList;
|
|
if (dropDownListView != null) {
|
|
dropDownListView.setAdapter(this.mAdapter);
|
|
}
|
|
}
|
|
|
|
public void setAnchorView(@Nullable View view) {
|
|
this.mDropDownAnchorView = view;
|
|
}
|
|
|
|
public void setAnimationStyle(@StyleRes int i) {
|
|
this.mPopup.setAnimationStyle(i);
|
|
}
|
|
|
|
public void setBackgroundDrawable(@Nullable Drawable drawable) {
|
|
this.mPopup.setBackgroundDrawable(drawable);
|
|
}
|
|
|
|
public void setContentWidth(int i) {
|
|
Drawable background = this.mPopup.getBackground();
|
|
if (background != null) {
|
|
background.getPadding(this.mTempRect);
|
|
Rect rect = this.mTempRect;
|
|
this.mDropDownWidth = rect.left + rect.right + i;
|
|
return;
|
|
}
|
|
setWidth(i);
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public void setDropDownAlwaysVisible(boolean z2) {
|
|
this.mDropDownAlwaysVisible = z2;
|
|
}
|
|
|
|
public void setDropDownGravity(int i) {
|
|
this.mDropDownGravity = i;
|
|
}
|
|
|
|
public void setEpicenterBounds(@Nullable Rect rect) {
|
|
this.mEpicenterBounds = rect != null ? new Rect(rect) : null;
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public void setForceIgnoreOutsideTouch(boolean z2) {
|
|
this.mForceIgnoreOutsideTouch = z2;
|
|
}
|
|
|
|
public void setHeight(int i) {
|
|
if (i >= 0 || -2 == i || -1 == i) {
|
|
this.mDropDownHeight = i;
|
|
return;
|
|
}
|
|
throw new IllegalArgumentException("Invalid height. Must be a positive value, MATCH_PARENT, or WRAP_CONTENT.");
|
|
}
|
|
|
|
public void setHorizontalOffset(int i) {
|
|
this.mDropDownHorizontalOffset = i;
|
|
}
|
|
|
|
public void setInputMethodMode(int i) {
|
|
this.mPopup.setInputMethodMode(i);
|
|
}
|
|
|
|
public void setListItemExpandMax(int i) {
|
|
this.mListItemExpandMaximum = i;
|
|
}
|
|
|
|
public void setListSelector(Drawable drawable) {
|
|
this.mDropDownListHighlight = drawable;
|
|
}
|
|
|
|
public void setModal(boolean z2) {
|
|
this.mModal = z2;
|
|
this.mPopup.setFocusable(z2);
|
|
}
|
|
|
|
public void setOnDismissListener(@Nullable PopupWindow.OnDismissListener onDismissListener) {
|
|
this.mPopup.setOnDismissListener(onDismissListener);
|
|
}
|
|
|
|
public void setOnItemClickListener(@Nullable AdapterView.OnItemClickListener onItemClickListener) {
|
|
this.mItemClickListener = onItemClickListener;
|
|
}
|
|
|
|
public void setOnItemSelectedListener(@Nullable AdapterView.OnItemSelectedListener onItemSelectedListener) {
|
|
this.mItemSelectedListener = onItemSelectedListener;
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public void setOverlapAnchor(boolean z2) {
|
|
this.mOverlapAnchorSet = true;
|
|
this.mOverlapAnchor = z2;
|
|
}
|
|
|
|
public void setPromptPosition(int i) {
|
|
this.mPromptPosition = i;
|
|
}
|
|
|
|
public void setPromptView(@Nullable View view) {
|
|
boolean isShowing = isShowing();
|
|
if (isShowing) {
|
|
removePromptView();
|
|
}
|
|
this.mPromptView = view;
|
|
if (isShowing) {
|
|
show();
|
|
}
|
|
}
|
|
|
|
public void setSelection(int i) {
|
|
DropDownListView dropDownListView = this.mDropDownList;
|
|
if (isShowing() && dropDownListView != null) {
|
|
dropDownListView.setListSelectionHidden(false);
|
|
dropDownListView.setSelection(i);
|
|
if (dropDownListView.getChoiceMode() != 0) {
|
|
dropDownListView.setItemChecked(i, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setSoftInputMode(int i) {
|
|
this.mPopup.setSoftInputMode(i);
|
|
}
|
|
|
|
public void setVerticalOffset(int i) {
|
|
this.mDropDownVerticalOffset = i;
|
|
this.mDropDownVerticalOffsetSet = true;
|
|
}
|
|
|
|
public void setWidth(int i) {
|
|
this.mDropDownWidth = i;
|
|
}
|
|
|
|
public void setWindowLayoutType(int i) {
|
|
this.mDropDownWindowLayoutType = i;
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.ShowableListMenu
|
|
public void show() {
|
|
int buildDropDown = buildDropDown();
|
|
boolean isInputMethodNotNeeded = isInputMethodNotNeeded();
|
|
PopupWindowCompat.setWindowLayoutType(this.mPopup, this.mDropDownWindowLayoutType);
|
|
boolean z2 = true;
|
|
if (!this.mPopup.isShowing()) {
|
|
int i = this.mDropDownWidth;
|
|
if (i == -1) {
|
|
i = -1;
|
|
} else if (i == -2) {
|
|
i = getAnchorView().getWidth();
|
|
}
|
|
int i2 = this.mDropDownHeight;
|
|
if (i2 == -1) {
|
|
buildDropDown = -1;
|
|
} else if (i2 != -2) {
|
|
buildDropDown = i2;
|
|
}
|
|
this.mPopup.setWidth(i);
|
|
this.mPopup.setHeight(buildDropDown);
|
|
setPopupClipToScreenEnabled(true);
|
|
this.mPopup.setOutsideTouchable(!this.mForceIgnoreOutsideTouch && !this.mDropDownAlwaysVisible);
|
|
this.mPopup.setTouchInterceptor(this.mTouchInterceptor);
|
|
if (this.mOverlapAnchorSet) {
|
|
PopupWindowCompat.setOverlapAnchor(this.mPopup, this.mOverlapAnchor);
|
|
}
|
|
if (Build.VERSION.SDK_INT <= 28) {
|
|
Method method = sSetEpicenterBoundsMethod;
|
|
if (method != null) {
|
|
try {
|
|
method.invoke(this.mPopup, this.mEpicenterBounds);
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Could not invoke setEpicenterBounds on PopupWindow", e);
|
|
}
|
|
}
|
|
} else {
|
|
this.mPopup.setEpicenterBounds(this.mEpicenterBounds);
|
|
}
|
|
PopupWindowCompat.showAsDropDown(this.mPopup, getAnchorView(), this.mDropDownHorizontalOffset, this.mDropDownVerticalOffset, this.mDropDownGravity);
|
|
this.mDropDownList.setSelection(-1);
|
|
if (!this.mModal || this.mDropDownList.isInTouchMode()) {
|
|
clearListSelection();
|
|
}
|
|
if (!this.mModal) {
|
|
this.mHandler.post(this.mHideSelector);
|
|
}
|
|
} else if (ViewCompat.isAttachedToWindow(getAnchorView())) {
|
|
int i3 = this.mDropDownWidth;
|
|
if (i3 == -1) {
|
|
i3 = -1;
|
|
} else if (i3 == -2) {
|
|
i3 = getAnchorView().getWidth();
|
|
}
|
|
int i4 = this.mDropDownHeight;
|
|
if (i4 == -1) {
|
|
if (!isInputMethodNotNeeded) {
|
|
buildDropDown = -1;
|
|
}
|
|
if (isInputMethodNotNeeded) {
|
|
this.mPopup.setWidth(this.mDropDownWidth == -1 ? -1 : 0);
|
|
this.mPopup.setHeight(0);
|
|
} else {
|
|
this.mPopup.setWidth(this.mDropDownWidth == -1 ? -1 : 0);
|
|
this.mPopup.setHeight(-1);
|
|
}
|
|
} else if (i4 != -2) {
|
|
buildDropDown = i4;
|
|
}
|
|
PopupWindow popupWindow = this.mPopup;
|
|
if (this.mForceIgnoreOutsideTouch || this.mDropDownAlwaysVisible) {
|
|
z2 = false;
|
|
}
|
|
popupWindow.setOutsideTouchable(z2);
|
|
this.mPopup.update(getAnchorView(), this.mDropDownHorizontalOffset, this.mDropDownVerticalOffset, i3 < 0 ? -1 : i3, buildDropDown < 0 ? -1 : buildDropDown);
|
|
}
|
|
}
|
|
}
|