689 lines
27 KiB
Java
689 lines
27 KiB
Java
package androidx.appcompat.widget;
|
|
|
|
import android.content.Context;
|
|
import android.content.res.Configuration;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.util.AttributeSet;
|
|
import android.view.ContextThemeWrapper;
|
|
import android.view.Menu;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.view.ViewDebug;
|
|
import android.view.ViewGroup;
|
|
import android.view.accessibility.AccessibilityEvent;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.RestrictTo;
|
|
import androidx.annotation.StyleRes;
|
|
import androidx.appcompat.view.menu.ActionMenuItemView;
|
|
import androidx.appcompat.view.menu.MenuBuilder;
|
|
import androidx.appcompat.view.menu.MenuItemImpl;
|
|
import androidx.appcompat.view.menu.MenuPresenter;
|
|
import androidx.appcompat.view.menu.MenuView;
|
|
import androidx.appcompat.widget.LinearLayoutCompat;
|
|
import androidx.constraintlayout.solver.widgets.analyzer.BasicMeasure;
|
|
public class ActionMenuView extends LinearLayoutCompat implements MenuBuilder.ItemInvoker, MenuView {
|
|
public static final int GENERATED_ITEM_PADDING = 4;
|
|
public static final int MIN_CELL_SIZE = 56;
|
|
private static final String TAG = "ActionMenuView";
|
|
private MenuPresenter.Callback mActionMenuPresenterCallback;
|
|
private boolean mFormatItems;
|
|
private int mFormatItemsWidth;
|
|
private int mGeneratedItemPadding;
|
|
private MenuBuilder mMenu;
|
|
public MenuBuilder.Callback mMenuBuilderCallback;
|
|
private int mMinCellSize;
|
|
public OnMenuItemClickListener mOnMenuItemClickListener;
|
|
private Context mPopupContext;
|
|
private int mPopupTheme;
|
|
private ActionMenuPresenter mPresenter;
|
|
private boolean mReserveOverflow;
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public interface ActionMenuChildView {
|
|
boolean needsDividerAfter();
|
|
|
|
boolean needsDividerBefore();
|
|
}
|
|
|
|
public static class ActionMenuPresenterCallback implements MenuPresenter.Callback {
|
|
@Override // androidx.appcompat.view.menu.MenuPresenter.Callback
|
|
public void onCloseMenu(@NonNull MenuBuilder menuBuilder, boolean z2) {
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuPresenter.Callback
|
|
public boolean onOpenSubMenu(@NonNull MenuBuilder menuBuilder) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static class LayoutParams extends LinearLayoutCompat.LayoutParams {
|
|
@ViewDebug.ExportedProperty
|
|
public int cellsUsed;
|
|
@ViewDebug.ExportedProperty
|
|
public boolean expandable;
|
|
public boolean expanded;
|
|
@ViewDebug.ExportedProperty
|
|
public int extraPixels;
|
|
@ViewDebug.ExportedProperty
|
|
public boolean isOverflowButton;
|
|
@ViewDebug.ExportedProperty
|
|
public boolean preventEdgeOffset;
|
|
|
|
public LayoutParams(int i, int i2) {
|
|
super(i, i2);
|
|
this.isOverflowButton = false;
|
|
}
|
|
|
|
public LayoutParams(int i, int i2, boolean z2) {
|
|
super(i, i2);
|
|
this.isOverflowButton = z2;
|
|
}
|
|
|
|
public LayoutParams(Context context, AttributeSet attributeSet) {
|
|
super(context, attributeSet);
|
|
}
|
|
|
|
public LayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
super(layoutParams);
|
|
}
|
|
|
|
public LayoutParams(LayoutParams layoutParams) {
|
|
super((ViewGroup.LayoutParams) layoutParams);
|
|
this.isOverflowButton = layoutParams.isOverflowButton;
|
|
}
|
|
}
|
|
|
|
public class MenuBuilderCallback implements MenuBuilder.Callback {
|
|
public MenuBuilderCallback() {
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuBuilder.Callback
|
|
public boolean onMenuItemSelected(@NonNull MenuBuilder menuBuilder, @NonNull MenuItem menuItem) {
|
|
OnMenuItemClickListener onMenuItemClickListener = ActionMenuView.this.mOnMenuItemClickListener;
|
|
return onMenuItemClickListener != null && onMenuItemClickListener.onMenuItemClick(menuItem);
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuBuilder.Callback
|
|
public void onMenuModeChange(@NonNull MenuBuilder menuBuilder) {
|
|
MenuBuilder.Callback callback = ActionMenuView.this.mMenuBuilderCallback;
|
|
if (callback != null) {
|
|
callback.onMenuModeChange(menuBuilder);
|
|
}
|
|
}
|
|
}
|
|
|
|
public interface OnMenuItemClickListener {
|
|
boolean onMenuItemClick(MenuItem menuItem);
|
|
}
|
|
|
|
public ActionMenuView(@NonNull Context context) {
|
|
this(context, null);
|
|
}
|
|
|
|
public ActionMenuView(@NonNull Context context, @Nullable AttributeSet attributeSet) {
|
|
super(context, attributeSet);
|
|
setBaselineAligned(false);
|
|
float f = context.getResources().getDisplayMetrics().density;
|
|
this.mMinCellSize = (int) (56.0f * f);
|
|
this.mGeneratedItemPadding = (int) (f * 4.0f);
|
|
this.mPopupContext = context;
|
|
this.mPopupTheme = 0;
|
|
}
|
|
|
|
public static int measureChildForCells(View view, int i, int i2, int i3, int i4) {
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
int makeMeasureSpec = View.MeasureSpec.makeMeasureSpec(View.MeasureSpec.getSize(i3) - i4, View.MeasureSpec.getMode(i3));
|
|
ActionMenuItemView actionMenuItemView = view instanceof ActionMenuItemView ? (ActionMenuItemView) view : null;
|
|
boolean z2 = true;
|
|
boolean z3 = actionMenuItemView != null && actionMenuItemView.hasText();
|
|
int i5 = 2;
|
|
if (i2 <= 0 || (z3 && i2 < 2)) {
|
|
i5 = 0;
|
|
} else {
|
|
view.measure(View.MeasureSpec.makeMeasureSpec(i2 * i, Integer.MIN_VALUE), makeMeasureSpec);
|
|
int measuredWidth = view.getMeasuredWidth();
|
|
int i6 = measuredWidth / i;
|
|
if (measuredWidth % i != 0) {
|
|
i6++;
|
|
}
|
|
if (!z3 || i6 >= 2) {
|
|
i5 = i6;
|
|
}
|
|
}
|
|
if (layoutParams.isOverflowButton || !z3) {
|
|
z2 = false;
|
|
}
|
|
layoutParams.expandable = z2;
|
|
layoutParams.cellsUsed = i5;
|
|
view.measure(View.MeasureSpec.makeMeasureSpec(i * i5, BasicMeasure.EXACTLY), makeMeasureSpec);
|
|
return i5;
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:75:0x0177, code lost:
|
|
r11 = r1;
|
|
r26 = r2;
|
|
r25 = r9;
|
|
r24 = r10;
|
|
*/
|
|
/* JADX WARNING: Unknown variable types count: 1 */
|
|
private void onMeasureExactFormat(int i, int i2) {
|
|
int i3;
|
|
boolean z2;
|
|
int i4;
|
|
int i5;
|
|
boolean z3;
|
|
boolean z4;
|
|
int i6;
|
|
int i7;
|
|
?? r14;
|
|
int mode = View.MeasureSpec.getMode(i2);
|
|
int size = View.MeasureSpec.getSize(i);
|
|
int size2 = View.MeasureSpec.getSize(i2);
|
|
int paddingRight = getPaddingRight() + getPaddingLeft();
|
|
int paddingBottom = getPaddingBottom() + getPaddingTop();
|
|
int childMeasureSpec = ViewGroup.getChildMeasureSpec(i2, paddingBottom, -2);
|
|
int i8 = size - paddingRight;
|
|
int i9 = this.mMinCellSize;
|
|
int i10 = i8 / i9;
|
|
int i11 = i8 % i9;
|
|
if (i10 == 0) {
|
|
setMeasuredDimension(i8, 0);
|
|
return;
|
|
}
|
|
int i12 = (i11 / i10) + i9;
|
|
int childCount = getChildCount();
|
|
int i13 = 0;
|
|
int i14 = 0;
|
|
boolean z5 = false;
|
|
int i15 = 0;
|
|
int i16 = 0;
|
|
int i17 = 0;
|
|
long j = 0;
|
|
while (i14 < childCount) {
|
|
View childAt = getChildAt(i14);
|
|
if (childAt.getVisibility() == 8) {
|
|
i6 = paddingBottom;
|
|
} else {
|
|
boolean z6 = childAt instanceof ActionMenuItemView;
|
|
int i18 = i15 + 1;
|
|
if (z6) {
|
|
int i19 = this.mGeneratedItemPadding;
|
|
i7 = i18;
|
|
r14 = 0;
|
|
childAt.setPadding(i19, 0, i19, 0);
|
|
} else {
|
|
i7 = i18;
|
|
r14 = 0;
|
|
}
|
|
LayoutParams layoutParams = (LayoutParams) childAt.getLayoutParams();
|
|
layoutParams.expanded = r14;
|
|
int i20 = r14 == true ? 1 : 0;
|
|
int i21 = r14 == true ? 1 : 0;
|
|
int i22 = r14 == true ? 1 : 0;
|
|
layoutParams.extraPixels = i20;
|
|
layoutParams.cellsUsed = r14;
|
|
layoutParams.expandable = r14;
|
|
((ViewGroup.MarginLayoutParams) layoutParams).leftMargin = r14;
|
|
((ViewGroup.MarginLayoutParams) layoutParams).rightMargin = r14;
|
|
layoutParams.preventEdgeOffset = z6 && ((ActionMenuItemView) childAt).hasText();
|
|
int measureChildForCells = measureChildForCells(childAt, i12, layoutParams.isOverflowButton ? 1 : i10, childMeasureSpec, paddingBottom);
|
|
i16 = Math.max(i16, measureChildForCells);
|
|
if (layoutParams.expandable) {
|
|
i17++;
|
|
}
|
|
if (layoutParams.isOverflowButton) {
|
|
z5 = true;
|
|
}
|
|
i10 -= measureChildForCells;
|
|
i13 = Math.max(i13, childAt.getMeasuredHeight());
|
|
if (measureChildForCells == 1) {
|
|
i6 = paddingBottom;
|
|
j |= (long) (1 << i14);
|
|
i10 = i10;
|
|
} else {
|
|
i6 = paddingBottom;
|
|
}
|
|
i15 = i7;
|
|
}
|
|
i14++;
|
|
paddingBottom = i6;
|
|
size2 = size2;
|
|
}
|
|
boolean z7 = z5 && i15 == 2;
|
|
boolean z8 = false;
|
|
while (true) {
|
|
if (i17 <= 0 || i10 <= 0) {
|
|
break;
|
|
}
|
|
int i23 = 0;
|
|
int i24 = 0;
|
|
int i25 = Integer.MAX_VALUE;
|
|
long j2 = 0;
|
|
while (i24 < childCount) {
|
|
LayoutParams layoutParams2 = (LayoutParams) getChildAt(i24).getLayoutParams();
|
|
if (layoutParams2.expandable) {
|
|
int i26 = layoutParams2.cellsUsed;
|
|
if (i26 < i25) {
|
|
j2 = 1 << i24;
|
|
i25 = i26;
|
|
i23 = 1;
|
|
} else if (i26 == i25) {
|
|
i23++;
|
|
j2 |= 1 << i24;
|
|
}
|
|
}
|
|
i24++;
|
|
i13 = i13;
|
|
z8 = z8;
|
|
}
|
|
z2 = z8;
|
|
i4 = i13;
|
|
j |= j2;
|
|
if (i23 > i10) {
|
|
i5 = mode;
|
|
i3 = i8;
|
|
break;
|
|
}
|
|
int i27 = i25 + 1;
|
|
int i28 = 0;
|
|
while (i28 < childCount) {
|
|
View childAt2 = getChildAt(i28);
|
|
LayoutParams layoutParams3 = (LayoutParams) childAt2.getLayoutParams();
|
|
long j3 = (long) (1 << i28);
|
|
if ((j2 & j3) == 0) {
|
|
if (layoutParams3.cellsUsed == i27) {
|
|
j |= j3;
|
|
}
|
|
z4 = z7;
|
|
} else {
|
|
if (!z7 || !layoutParams3.preventEdgeOffset || i10 != 1) {
|
|
z4 = z7;
|
|
} else {
|
|
int i29 = this.mGeneratedItemPadding;
|
|
z4 = z7;
|
|
childAt2.setPadding(i29 + i12, 0, i29, 0);
|
|
}
|
|
layoutParams3.cellsUsed++;
|
|
layoutParams3.expanded = true;
|
|
i10--;
|
|
}
|
|
i28++;
|
|
mode = mode;
|
|
i8 = i8;
|
|
z7 = z4;
|
|
}
|
|
i13 = i4;
|
|
z8 = true;
|
|
}
|
|
boolean z9 = !z5 && i15 == 1;
|
|
if (i10 <= 0 || j == 0 || (i10 >= i15 - 1 && !z9 && i16 <= 1)) {
|
|
z3 = z2;
|
|
} else {
|
|
float bitCount = (float) Long.bitCount(j);
|
|
if (!z9) {
|
|
if ((j & 1) != 0 && !((LayoutParams) getChildAt(0).getLayoutParams()).preventEdgeOffset) {
|
|
bitCount -= 0.5f;
|
|
}
|
|
int i30 = childCount - 1;
|
|
if ((j & ((long) (1 << i30))) != 0 && !((LayoutParams) getChildAt(i30).getLayoutParams()).preventEdgeOffset) {
|
|
bitCount -= 0.5f;
|
|
}
|
|
}
|
|
int i31 = bitCount > 0.0f ? (int) (((float) (i10 * i12)) / bitCount) : 0;
|
|
z3 = z2;
|
|
for (int i32 = 0; i32 < childCount; i32++) {
|
|
if ((j & ((long) (1 << i32))) != 0) {
|
|
View childAt3 = getChildAt(i32);
|
|
LayoutParams layoutParams4 = (LayoutParams) childAt3.getLayoutParams();
|
|
if (childAt3 instanceof ActionMenuItemView) {
|
|
layoutParams4.extraPixels = i31;
|
|
layoutParams4.expanded = true;
|
|
if (i32 == 0 && !layoutParams4.preventEdgeOffset) {
|
|
((ViewGroup.MarginLayoutParams) layoutParams4).leftMargin = (-i31) / 2;
|
|
}
|
|
} else if (layoutParams4.isOverflowButton) {
|
|
layoutParams4.extraPixels = i31;
|
|
layoutParams4.expanded = true;
|
|
((ViewGroup.MarginLayoutParams) layoutParams4).rightMargin = (-i31) / 2;
|
|
} else {
|
|
if (i32 != 0) {
|
|
((ViewGroup.MarginLayoutParams) layoutParams4).leftMargin = i31 / 2;
|
|
}
|
|
if (i32 != childCount - 1) {
|
|
((ViewGroup.MarginLayoutParams) layoutParams4).rightMargin = i31 / 2;
|
|
}
|
|
}
|
|
z3 = true;
|
|
}
|
|
}
|
|
}
|
|
if (z3) {
|
|
for (int i33 = 0; i33 < childCount; i33++) {
|
|
View childAt4 = getChildAt(i33);
|
|
LayoutParams layoutParams5 = (LayoutParams) childAt4.getLayoutParams();
|
|
if (layoutParams5.expanded) {
|
|
childAt4.measure(View.MeasureSpec.makeMeasureSpec((layoutParams5.cellsUsed * i12) + layoutParams5.extraPixels, BasicMeasure.EXACTLY), childMeasureSpec);
|
|
}
|
|
}
|
|
}
|
|
setMeasuredDimension(i3, i5 != 1073741824 ? i4 : size2);
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.LinearLayoutCompat, android.view.ViewGroup
|
|
public boolean checkLayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
return layoutParams instanceof LayoutParams;
|
|
}
|
|
|
|
public void dismissPopupMenus() {
|
|
ActionMenuPresenter actionMenuPresenter = this.mPresenter;
|
|
if (actionMenuPresenter != null) {
|
|
actionMenuPresenter.dismissPopupMenus();
|
|
}
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent accessibilityEvent) {
|
|
return false;
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.LinearLayoutCompat, android.view.ViewGroup
|
|
public LayoutParams generateDefaultLayoutParams() {
|
|
LayoutParams layoutParams = new LayoutParams(-2, -2);
|
|
layoutParams.gravity = 16;
|
|
return layoutParams;
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.LinearLayoutCompat, android.view.ViewGroup
|
|
public LayoutParams generateLayoutParams(AttributeSet attributeSet) {
|
|
return new LayoutParams(getContext(), attributeSet);
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.LinearLayoutCompat, android.view.ViewGroup
|
|
public LayoutParams generateLayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
if (layoutParams == null) {
|
|
return generateDefaultLayoutParams();
|
|
}
|
|
LayoutParams layoutParams2 = layoutParams instanceof LayoutParams ? new LayoutParams((LayoutParams) layoutParams) : new LayoutParams(layoutParams);
|
|
if (layoutParams2.gravity <= 0) {
|
|
layoutParams2.gravity = 16;
|
|
}
|
|
return layoutParams2;
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public LayoutParams generateOverflowButtonLayoutParams() {
|
|
LayoutParams generateDefaultLayoutParams = generateDefaultLayoutParams();
|
|
generateDefaultLayoutParams.isOverflowButton = true;
|
|
return generateDefaultLayoutParams;
|
|
}
|
|
|
|
public Menu getMenu() {
|
|
if (this.mMenu == null) {
|
|
Context context = getContext();
|
|
MenuBuilder menuBuilder = new MenuBuilder(context);
|
|
this.mMenu = menuBuilder;
|
|
menuBuilder.setCallback(new MenuBuilderCallback());
|
|
ActionMenuPresenter actionMenuPresenter = new ActionMenuPresenter(context);
|
|
this.mPresenter = actionMenuPresenter;
|
|
actionMenuPresenter.setReserveOverflow(true);
|
|
ActionMenuPresenter actionMenuPresenter2 = this.mPresenter;
|
|
MenuPresenter.Callback callback = this.mActionMenuPresenterCallback;
|
|
if (callback == null) {
|
|
callback = new ActionMenuPresenterCallback();
|
|
}
|
|
actionMenuPresenter2.setCallback(callback);
|
|
this.mMenu.addMenuPresenter(this.mPresenter, this.mPopupContext);
|
|
this.mPresenter.setMenuView(this);
|
|
}
|
|
return this.mMenu;
|
|
}
|
|
|
|
@Nullable
|
|
public Drawable getOverflowIcon() {
|
|
getMenu();
|
|
return this.mPresenter.getOverflowIcon();
|
|
}
|
|
|
|
public int getPopupTheme() {
|
|
return this.mPopupTheme;
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuView
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public int getWindowAnimations() {
|
|
return 0;
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public boolean hasSupportDividerBeforeChildAt(int i) {
|
|
boolean z2 = false;
|
|
if (i == 0) {
|
|
return false;
|
|
}
|
|
View childAt = getChildAt(i - 1);
|
|
View childAt2 = getChildAt(i);
|
|
if (i < getChildCount() && (childAt instanceof ActionMenuChildView)) {
|
|
z2 = false | ((ActionMenuChildView) childAt).needsDividerAfter();
|
|
}
|
|
return (i <= 0 || !(childAt2 instanceof ActionMenuChildView)) ? z2 : z2 | ((ActionMenuChildView) childAt2).needsDividerBefore();
|
|
}
|
|
|
|
public boolean hideOverflowMenu() {
|
|
ActionMenuPresenter actionMenuPresenter = this.mPresenter;
|
|
return actionMenuPresenter != null && actionMenuPresenter.hideOverflowMenu();
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuView
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public void initialize(MenuBuilder menuBuilder) {
|
|
this.mMenu = menuBuilder;
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuBuilder.ItemInvoker
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public boolean invokeItem(MenuItemImpl menuItemImpl) {
|
|
return this.mMenu.performItemAction(menuItemImpl, 0);
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public boolean isOverflowMenuShowPending() {
|
|
ActionMenuPresenter actionMenuPresenter = this.mPresenter;
|
|
return actionMenuPresenter != null && actionMenuPresenter.isOverflowMenuShowPending();
|
|
}
|
|
|
|
public boolean isOverflowMenuShowing() {
|
|
ActionMenuPresenter actionMenuPresenter = this.mPresenter;
|
|
return actionMenuPresenter != null && actionMenuPresenter.isOverflowMenuShowing();
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public boolean isOverflowReserved() {
|
|
return this.mReserveOverflow;
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onConfigurationChanged(Configuration configuration) {
|
|
super.onConfigurationChanged(configuration);
|
|
ActionMenuPresenter actionMenuPresenter = this.mPresenter;
|
|
if (actionMenuPresenter != null) {
|
|
actionMenuPresenter.updateMenuView(false);
|
|
if (this.mPresenter.isOverflowMenuShowing()) {
|
|
this.mPresenter.hideOverflowMenu();
|
|
this.mPresenter.showOverflowMenu();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
public void onDetachedFromWindow() {
|
|
super.onDetachedFromWindow();
|
|
dismissPopupMenus();
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.LinearLayoutCompat, android.view.ViewGroup, android.view.View
|
|
public void onLayout(boolean z2, int i, int i2, int i3, int i4) {
|
|
int i5;
|
|
int i6;
|
|
if (!this.mFormatItems) {
|
|
super.onLayout(z2, i, i2, i3, i4);
|
|
return;
|
|
}
|
|
int childCount = getChildCount();
|
|
int i7 = (i4 - i2) / 2;
|
|
int dividerWidth = getDividerWidth();
|
|
int i8 = i3 - i;
|
|
int paddingRight = (i8 - getPaddingRight()) - getPaddingLeft();
|
|
boolean isLayoutRtl = ViewUtils.isLayoutRtl(this);
|
|
int i9 = 0;
|
|
int i10 = 0;
|
|
for (int i11 = 0; i11 < childCount; i11++) {
|
|
View childAt = getChildAt(i11);
|
|
if (childAt.getVisibility() != 8) {
|
|
LayoutParams layoutParams = (LayoutParams) childAt.getLayoutParams();
|
|
if (layoutParams.isOverflowButton) {
|
|
int measuredWidth = childAt.getMeasuredWidth();
|
|
if (hasSupportDividerBeforeChildAt(i11)) {
|
|
measuredWidth += dividerWidth;
|
|
}
|
|
int measuredHeight = childAt.getMeasuredHeight();
|
|
if (isLayoutRtl) {
|
|
i5 = getPaddingLeft() + ((ViewGroup.MarginLayoutParams) layoutParams).leftMargin;
|
|
i6 = i5 + measuredWidth;
|
|
} else {
|
|
i6 = (getWidth() - getPaddingRight()) - ((ViewGroup.MarginLayoutParams) layoutParams).rightMargin;
|
|
i5 = i6 - measuredWidth;
|
|
}
|
|
int i12 = i7 - (measuredHeight / 2);
|
|
childAt.layout(i5, i12, i6, measuredHeight + i12);
|
|
paddingRight -= measuredWidth;
|
|
i9 = 1;
|
|
} else {
|
|
paddingRight -= (childAt.getMeasuredWidth() + ((ViewGroup.MarginLayoutParams) layoutParams).leftMargin) + ((ViewGroup.MarginLayoutParams) layoutParams).rightMargin;
|
|
hasSupportDividerBeforeChildAt(i11);
|
|
i10++;
|
|
}
|
|
}
|
|
}
|
|
if (childCount == 1 && i9 == 0) {
|
|
View childAt2 = getChildAt(0);
|
|
int measuredWidth2 = childAt2.getMeasuredWidth();
|
|
int measuredHeight2 = childAt2.getMeasuredHeight();
|
|
int i13 = (i8 / 2) - (measuredWidth2 / 2);
|
|
int i14 = i7 - (measuredHeight2 / 2);
|
|
childAt2.layout(i13, i14, measuredWidth2 + i13, measuredHeight2 + i14);
|
|
return;
|
|
}
|
|
int i15 = i10 - (i9 ^ 1);
|
|
int max = Math.max(0, i15 > 0 ? paddingRight / i15 : 0);
|
|
if (isLayoutRtl) {
|
|
int width = getWidth() - getPaddingRight();
|
|
for (int i16 = 0; i16 < childCount; i16++) {
|
|
View childAt3 = getChildAt(i16);
|
|
LayoutParams layoutParams2 = (LayoutParams) childAt3.getLayoutParams();
|
|
if (childAt3.getVisibility() != 8 && !layoutParams2.isOverflowButton) {
|
|
int i17 = width - ((ViewGroup.MarginLayoutParams) layoutParams2).rightMargin;
|
|
int measuredWidth3 = childAt3.getMeasuredWidth();
|
|
int measuredHeight3 = childAt3.getMeasuredHeight();
|
|
int i18 = i7 - (measuredHeight3 / 2);
|
|
childAt3.layout(i17 - measuredWidth3, i18, i17, measuredHeight3 + i18);
|
|
width = i17 - ((measuredWidth3 + ((ViewGroup.MarginLayoutParams) layoutParams2).leftMargin) + max);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
int paddingLeft = getPaddingLeft();
|
|
for (int i19 = 0; i19 < childCount; i19++) {
|
|
View childAt4 = getChildAt(i19);
|
|
LayoutParams layoutParams3 = (LayoutParams) childAt4.getLayoutParams();
|
|
if (childAt4.getVisibility() != 8 && !layoutParams3.isOverflowButton) {
|
|
int i20 = paddingLeft + ((ViewGroup.MarginLayoutParams) layoutParams3).leftMargin;
|
|
int measuredWidth4 = childAt4.getMeasuredWidth();
|
|
int measuredHeight4 = childAt4.getMeasuredHeight();
|
|
int i21 = i7 - (measuredHeight4 / 2);
|
|
childAt4.layout(i20, i21, i20 + measuredWidth4, measuredHeight4 + i21);
|
|
paddingLeft = measuredWidth4 + ((ViewGroup.MarginLayoutParams) layoutParams3).rightMargin + max + i20;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.LinearLayoutCompat, android.view.View
|
|
public void onMeasure(int i, int i2) {
|
|
MenuBuilder menuBuilder;
|
|
boolean z2 = this.mFormatItems;
|
|
boolean z3 = View.MeasureSpec.getMode(i) == 1073741824;
|
|
this.mFormatItems = z3;
|
|
if (z2 != z3) {
|
|
this.mFormatItemsWidth = 0;
|
|
}
|
|
int size = View.MeasureSpec.getSize(i);
|
|
if (!(!this.mFormatItems || (menuBuilder = this.mMenu) == null || size == this.mFormatItemsWidth)) {
|
|
this.mFormatItemsWidth = size;
|
|
menuBuilder.onItemsChanged(true);
|
|
}
|
|
int childCount = getChildCount();
|
|
if (!this.mFormatItems || childCount <= 0) {
|
|
for (int i3 = 0; i3 < childCount; i3++) {
|
|
LayoutParams layoutParams = (LayoutParams) getChildAt(i3).getLayoutParams();
|
|
((ViewGroup.MarginLayoutParams) layoutParams).rightMargin = 0;
|
|
((ViewGroup.MarginLayoutParams) layoutParams).leftMargin = 0;
|
|
}
|
|
super.onMeasure(i, i2);
|
|
return;
|
|
}
|
|
onMeasureExactFormat(i, i2);
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public MenuBuilder peekMenu() {
|
|
return this.mMenu;
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public void setExpandedActionViewsExclusive(boolean z2) {
|
|
this.mPresenter.setExpandedActionViewsExclusive(z2);
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public void setMenuCallbacks(MenuPresenter.Callback callback, MenuBuilder.Callback callback2) {
|
|
this.mActionMenuPresenterCallback = callback;
|
|
this.mMenuBuilderCallback = callback2;
|
|
}
|
|
|
|
public void setOnMenuItemClickListener(OnMenuItemClickListener onMenuItemClickListener) {
|
|
this.mOnMenuItemClickListener = onMenuItemClickListener;
|
|
}
|
|
|
|
public void setOverflowIcon(@Nullable Drawable drawable) {
|
|
getMenu();
|
|
this.mPresenter.setOverflowIcon(drawable);
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public void setOverflowReserved(boolean z2) {
|
|
this.mReserveOverflow = z2;
|
|
}
|
|
|
|
public void setPopupTheme(@StyleRes int i) {
|
|
if (this.mPopupTheme != i) {
|
|
this.mPopupTheme = i;
|
|
if (i == 0) {
|
|
this.mPopupContext = getContext();
|
|
} else {
|
|
this.mPopupContext = new ContextThemeWrapper(getContext(), i);
|
|
}
|
|
}
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public void setPresenter(ActionMenuPresenter actionMenuPresenter) {
|
|
this.mPresenter = actionMenuPresenter;
|
|
actionMenuPresenter.setMenuView(this);
|
|
}
|
|
|
|
public boolean showOverflowMenu() {
|
|
ActionMenuPresenter actionMenuPresenter = this.mPresenter;
|
|
return actionMenuPresenter != null && actionMenuPresenter.showOverflowMenu();
|
|
}
|
|
}
|