Sets the expandable and cellsUsed fields of LayoutParams. * * @param child Child to measure * @param cellSize Size of one cell * @param cellsRemaining Number of cells remaining that this view can expand to fill * @param parentHeightMeasureSpec MeasureSpec used by the parent view * @param parentHeightPadding Padding present in the parent view * @return Number of cells this child was measured to occupy */ static int measureChildForCells(View child, int cellSize, int cellsRemaining, int parentHeightMeasureSpec, int parentHeightPadding) { final LayoutParams lp = (LayoutParams) child.getLayoutParams(); final int childHeightSize = MeasureSpec.getSize(parentHeightMeasureSpec) - parentHeightPadding; final int childHeightMode = MeasureSpec.getMode(parentHeightMeasureSpec); final int childHeightSpec = MeasureSpec.makeMeasureSpec(childHeightSize, childHeightMode); final ActionMenuItemView itemView = child instanceof ActionMenuItemView ? (ActionMenuItemView) child : null; final boolean hasText = itemView != null && itemView.hasText(); int cellsUsed = 0; if (cellsRemaining > 0 && (!hasText || cellsRemaining >= 2)) { final int childWidthSpec = MeasureSpec.makeMeasureSpec( cellSize * cellsRemaining, MeasureSpec.AT_MOST); child.measure(childWidthSpec, childHeightSpec); final int measuredWidth = child.getMeasuredWidth(); cellsUsed = measuredWidth / cellSize; if (measuredWidth % cellSize != 0) cellsUsed++; if (hasText && cellsUsed < 2) cellsUsed = 2; } final boolean expandable = !lp.isOverflowButton && hasText; lp.expandable = expandable; lp.cellsUsed = cellsUsed; final int targetWidth = cellsUsed * cellSize; child.measure(MeasureSpec.makeMeasureSpec(targetWidth, MeasureSpec.EXACTLY), childHeightSpec); return cellsUsed; } @Override protected void onLayout(boolean changed, int left, int top, int right, int bottom) { if (!mFormatItems) { super.onLayout(changed, left, top, right, bottom); return; } final int childCount = getChildCount(); final int midVertical = (bottom - top) / 2; final int dividerWidth = getDividerWidth(); int overflowWidth = 0; int nonOverflowWidth = 0; int nonOverflowCount = 0; int widthRemaining = right - left - getPaddingRight() - getPaddingLeft(); boolean hasOverflow = false; final boolean isLayoutRtl = ViewUtils.isLayoutRtl(this); for (int i = 0; i < childCount; i++) { final View v = getChildAt(i); if (v.getVisibility() == GONE) { continue; } LayoutParams p = (LayoutParams) v.getLayoutParams(); if (p.isOverflowButton) { overflowWidth = v.getMeasuredWidth(); if (hasSupportDividerBeforeChildAt(i)) { overflowWidth += dividerWidth; } int height = v.getMeasuredHeight(); int r; int l; if (isLayoutRtl) { l = getPaddingLeft() + p.leftMargin; r = l + overflowWidth; } else { r = getWidth() - getPaddingRight() - p.rightMargin; l = r - overflowWidth; } int t = midVertical - (height / 2); int b = t + height; v.layout(l, t, r, b); widthRemaining -= overflowWidth; hasOverflow = true; } else { final int size = v.getMeasuredWidth() + p.leftMargin + p.rightMargin; nonOverflowWidth += size; widthRemaining -= size; if (hasSupportDividerBeforeChildAt(i)) { nonOverflowWidth += dividerWidth; } nonOverflowCount++; } } if (childCount == 1 && !hasOverflow) { // Center a single child final View v = getChildAt(0); final int width = v.getMeasuredWidth(); final int height = v.getMeasuredHeight(); final int midHorizontal = (right - left) / 2; final int l = midHorizontal - width / 2; final int t = midVertical - height / 2; v.layout(l, t, l + width, t + height); return; } final int spacerCount = nonOverflowCount - (hasOverflow ? 0 : 1); final int spacerSize = Math.max(0, spacerCount > 0 ? widthRemaining / spacerCount : 0); if (isLayoutRtl) { int startRight = getWidth() - getPaddingRight(); for (int i = 0; i < childCount; i++) { final View v = getChildAt(i); final LayoutParams lp = (LayoutParams) v.getLayoutParams(); if (v.getVisibility() == GONE || lp.isOverflowButton) { continue; } startRight -= lp.rightMargin; int width = v.getMeasuredWidth(); int height = v.getMeasuredHeight(); int t = midVertical - height / 2; v.layout(startRight - width, t, startRight, t + height); startRight -= width + lp.leftMargin + spacerSize; } } else { int startLeft = getPaddingLeft(); for (int i = 0; i < childCount; i++) { final View v = getChildAt(i); final LayoutParams lp = (LayoutParams) v.getLayoutParams(); if (v.getVisibility() == GONE || lp.isOverflowButton) { continue; } startLeft += lp.leftMargin; int width = v.getMeasuredWidth(); int height = v.getMeasuredHeight(); int t = midVertical - height / 2; v.layout(startLeft, t, startLeft + width, t + height); startLeft += width + lp.rightMargin + spacerSize; } } } @Override public void onDetachedFromWindow() { super.onDetachedFromWindow(); dismissPopupMenus(); } /** * Set the icon to use for the overflow button. * * @param icon Drawable to set, may be null to clear the icon */ public void setOverflowIcon(@Nullable Drawable icon) { getMenu(); mPresenter.setOverflowIcon(icon); } /** * Return the current drawable used as the overflow icon. * * @return The overflow icon drawable */ @Nullable public Drawable getOverflowIcon() { getMenu(); return mPresenter.getOverflowIcon(); } /** @hide */ @RestrictTo(LIBRARY_GROUP) public boolean isOverflowReserved() { return mReserveOverflow; } /** @hide */ @RestrictTo(LIBRARY_GROUP) public void setOverflowReserved(boolean reserveOverflow) { mReserveOverflow = reserveOverflow; } @Override protected LayoutParams generateDefaultLayoutParams() { LayoutParams params = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT); params.gravity = Gravity.CENTER_VERTICAL; return params; } @Override public LayoutParams generateLayoutParams(AttributeSet attrs) { return new LayoutParams(getContext(), attrs); } @Override protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) { if (p != null) { final LayoutParams result = p instanceof LayoutParams ? new LayoutParams((LayoutParams) p) : new LayoutParams(p); if (result.gravity <= Gravity.NO_GRAVITY) { result.gravity = Gravity.CENTER_VERTICAL; } return result; } return generateDefaultLayoutParams(); } @Override protected boolean checkLayoutParams(ViewGroup.LayoutParams p) { return p != null && p instanceof LayoutParams; } /** @hide */ @RestrictTo(LIBRARY_GROUP) public LayoutParams generateOverflowButtonLayoutParams() { LayoutParams result = generateDefaultLayoutParams(); result.isOverflowButton = true; return result; } /** @hide */ @Override @RestrictTo(LIBRARY_GROUP) public boolean invokeItem(MenuItemImpl item) { return mMenu.performItemAction(item, 0); } /** @hide */ @Override @RestrictTo(LIBRARY_GROUP) public int getWindowAnimations() { return 0; } /** @hide */ @Override @RestrictTo(LIBRARY_GROUP) public void initialize(MenuBuilder menu) { mMenu = menu; } /** * Returns the Menu object that this ActionMenuView is currently presenting. * *
Applications should use this method to obtain the ActionMenuView's Menu object * and inflate or add content to it as necessary.
* * @return the Menu presented by this view */ public Menu getMenu() { if (mMenu == null) { final Context context = getContext(); mMenu = new MenuBuilder(context); mMenu.setCallback(new MenuBuilderCallback()); mPresenter = new ActionMenuPresenter(context); mPresenter.setReserveOverflow(true); mPresenter.setCallback(mActionMenuPresenterCallback != null ? mActionMenuPresenterCallback : new ActionMenuPresenterCallback()); mMenu.addMenuPresenter(mPresenter, mPopupContext); mPresenter.setMenuView(this); } return mMenu; } /** * Must be called before the first call to getMenu() * @hide */ @RestrictTo(LIBRARY_GROUP) public void setMenuCallbacks(MenuPresenter.Callback pcb, MenuBuilder.Callback mcb) { mActionMenuPresenterCallback = pcb; mMenuBuilderCallback = mcb; } /** * Returns the current menu or null if one has not yet been configured. * @hide Internal use only for action bar integration */ @RestrictTo(LIBRARY_GROUP) public MenuBuilder peekMenu() { return mMenu; } /** * Show the overflow items from the associated menu. * * @return true if the menu was able to be shown, false otherwise */ public boolean showOverflowMenu() { return mPresenter != null && mPresenter.showOverflowMenu(); } /** * Hide the overflow items from the associated menu. * * @return true if the menu was able to be hidden, false otherwise */ public boolean hideOverflowMenu() { return mPresenter != null && mPresenter.hideOverflowMenu(); } /** * Check whether the overflow menu is currently showing. This may not reflect * a pending show operation in progress. * * @return true if the overflow menu is currently showing */ public boolean isOverflowMenuShowing() { return mPresenter != null && mPresenter.isOverflowMenuShowing(); } /** @hide */ @RestrictTo(LIBRARY_GROUP) public boolean isOverflowMenuShowPending() { return mPresenter != null && mPresenter.isOverflowMenuShowPending(); } /** * Dismiss any popups associated with this menu view. */ public void dismissPopupMenus() { if (mPresenter != null) { mPresenter.dismissPopupMenus(); } } /** * @hide Private LinearLayout (superclass) API. Un-hide if LinearLayout API is made public. */ @RestrictTo(LIBRARY_GROUP) protected boolean hasSupportDividerBeforeChildAt(int childIndex) { if (childIndex == 0) { return false; } final View childBefore = getChildAt(childIndex - 1); final View child = getChildAt(childIndex); boolean result = false; if (childIndex < getChildCount() && childBefore instanceof ActionMenuChildView) { result |= ((ActionMenuChildView) childBefore).needsDividerAfter(); } if (childIndex > 0 && child instanceof ActionMenuChildView) { result |= ((ActionMenuChildView) child).needsDividerBefore(); } return result; } @Override public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) { return false; } /** @hide */ @RestrictTo(LIBRARY_GROUP) public void setExpandedActionViewsExclusive(boolean exclusive) { mPresenter.setExpandedActionViewsExclusive(exclusive); } /** * Interface responsible for receiving menu item click events if the items themselves * do not have individual item click listeners. */ public interface OnMenuItemClickListener { /** * This method will be invoked when a menu item is clicked if the item itself did * not already handle the event. * * @param item {@link MenuItem} that was clicked * @returntrue if the event was handled, false otherwise.
*/
public boolean onMenuItemClick(MenuItem item);
}
private class MenuBuilderCallback implements MenuBuilder.Callback {
MenuBuilderCallback() {
}
@Override
public boolean onMenuItemSelected(MenuBuilder menu, MenuItem item) {
return mOnMenuItemClickListener != null &&
mOnMenuItemClickListener.onMenuItemClick(item);
}
@Override
public void onMenuModeChange(MenuBuilder menu) {
if (mMenuBuilderCallback != null) {
mMenuBuilderCallback.onMenuModeChange(menu);
}
}
}
private static class ActionMenuPresenterCallback implements ActionMenuPresenter.Callback {
ActionMenuPresenterCallback() {
}
@Override
public void onCloseMenu(MenuBuilder menu, boolean allMenusAreClosing) {
}
@Override
public boolean onOpenSubMenu(MenuBuilder subMenu) {
return false;
}
}
/** @hide */
@RestrictTo(LIBRARY_GROUP)
public interface ActionMenuChildView {
boolean needsDividerBefore();
boolean needsDividerAfter();
}
public static class LayoutParams extends LinearLayoutCompat.LayoutParams {
@ViewDebug.ExportedProperty()
public boolean isOverflowButton;
@ViewDebug.ExportedProperty()
public int cellsUsed;
@ViewDebug.ExportedProperty()
public int extraPixels;
@ViewDebug.ExportedProperty()
public boolean expandable;
@ViewDebug.ExportedProperty()
public boolean preventEdgeOffset;
boolean expanded;
public LayoutParams(Context c, AttributeSet attrs) {
super(c, attrs);
}
public LayoutParams(ViewGroup.LayoutParams other) {
super(other);
}
public LayoutParams(LayoutParams other) {
super((ViewGroup.LayoutParams) other);
isOverflowButton = other.isOverflowButton;
}
public LayoutParams(int width, int height) {
super(width, height);
isOverflowButton = false;
}
LayoutParams(int width, int height, boolean isOverflowButton) {
super(width, height);
this.isOverflowButton = isOverflowButton;
}
}
}