Source code
package android.support.v7.widget;
import android.content.Context;
import android.graphics.drawable.Drawable;
import android.os.Build.VERSION;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.Parcelable.Creator;
import android.support.annotation.ColorInt;
import android.support.annotation.DrawableRes;
import android.support.annotation.MenuRes;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.StringRes;
import android.support.annotation.StyleRes;
import android.support.v4.view.GravityCompat;
import android.support.v4.view.MarginLayoutParamsCompat;
import android.support.v4.view.MenuItemCompat;
import android.support.v4.view.MotionEventCompat;
import android.support.v4.view.ViewCompat;
import android.support.v7.appcompat.R;
import android.support.v7.internal.view.SupportMenuInflater;
import android.support.v7.internal.view.menu.MenuBuilder;
import android.support.v7.internal.view.menu.MenuItemImpl;
import android.support.v7.internal.view.menu.MenuPresenter;
import android.support.v7.internal.view.menu.MenuPresenter.Callback;
import android.support.v7.internal.view.menu.MenuView;
import android.support.v7.internal.view.menu.SubMenuBuilder;
import android.support.v7.internal.widget.DecorToolbar;
import android.support.v7.internal.widget.RtlSpacingHelper;
import android.support.v7.internal.widget.TintManager;
import android.support.v7.internal.widget.TintTypedArray;
import android.support.v7.internal.widget.ToolbarWidgetWrapper;
import android.support.v7.internal.widget.ViewUtils;
import android.support.v7.view.CollapsibleActionView;
import android.text.Layout;
import android.text.TextUtils;
import android.text.TextUtils.TruncateAt;
import android.util.AttributeSet;
import android.view.ContextThemeWrapper;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.BaseSavedState;
import android.view.View.MeasureSpec;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.view.ViewGroup.MarginLayoutParams;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.TextView;
import java.util.ArrayList;
import java.util.List;
public class Toolbar extends ViewGroup {
private static final String TAG = "Toolbar";
private Callback mActionMenuPresenterCallback;
private int mButtonGravity;
private ImageButton mCollapseButtonView;
private CharSequence mCollapseDescription;
private Drawable mCollapseIcon;
private boolean mCollapsible;
private final RtlSpacingHelper mContentInsets;
private boolean mEatingHover;
private boolean mEatingTouch;
View mExpandedActionView;
private ExpandedActionViewMenuPresenter mExpandedMenuPresenter;
private int mGravity;
private final ArrayList<View> mHiddenViews;
private ImageView mLogoView;
private int mMaxButtonHeight;
private MenuBuilder.Callback mMenuBuilderCallback;
private ActionMenuView mMenuView;
private final android.support.v7.widget.ActionMenuView.OnMenuItemClickListener mMenuViewItemClickListener;
private ImageButton mNavButtonView;
private OnMenuItemClickListener mOnMenuItemClickListener;
private ActionMenuPresenter mOuterActionMenuPresenter;
private Context mPopupContext;
private int mPopupTheme;
private final Runnable mShowOverflowMenuRunnable;
private CharSequence mSubtitleText;
private int mSubtitleTextAppearance;
private int mSubtitleTextColor;
private TextView mSubtitleTextView;
private final int[] mTempMargins;
private final ArrayList<View> mTempViews;
private final TintManager mTintManager;
private int mTitleMarginBottom;
private int mTitleMarginEnd;
private int mTitleMarginStart;
private int mTitleMarginTop;
private CharSequence mTitleText;
private int mTitleTextAppearance;
private int mTitleTextColor;
private TextView mTitleTextView;
private ToolbarWidgetWrapper mWrapper;
public interface OnMenuItemClickListener {
boolean onMenuItemClick(MenuItem menuItem);
}
public static class SavedState extends BaseSavedState {
public static final Creator<SavedState> CREATOR = new Creator<SavedState>() {
public SavedState createFromParcel(Parcel source) {
return new SavedState(source);
}
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
int expandedMenuItemId;
boolean isOverflowOpen;
public SavedState(Parcel source) {
super(source);
this.expandedMenuItemId = source.readInt();
this.isOverflowOpen = source.readInt() != 0;
}
public SavedState(Parcelable superState) {
super(superState);
}
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeInt(this.expandedMenuItemId);
out.writeInt(this.isOverflowOpen ? 1 : 0);
}
}
private class ExpandedActionViewMenuPresenter implements MenuPresenter {
MenuItemImpl mCurrentExpandedItem;
MenuBuilder mMenu;
private ExpandedActionViewMenuPresenter() {
}
public void initForMenu(Context context, MenuBuilder menu) {
if (!(this.mMenu == null || this.mCurrentExpandedItem == null)) {
this.mMenu.collapseItemActionView(this.mCurrentExpandedItem);
}
this.mMenu = menu;
}
public MenuView getMenuView(ViewGroup root) {
return null;
}
public void updateMenuView(boolean cleared) {
if (this.mCurrentExpandedItem != null) {
boolean found = false;
if (this.mMenu != null) {
int count = this.mMenu.size();
for (int i = 0; i < count; i++) {
if (this.mMenu.getItem(i) == this.mCurrentExpandedItem) {
found = true;
break;
}
}
}
if (!found) {
collapseItemActionView(this.mMenu, this.mCurrentExpandedItem);
}
}
}
public void setCallback(Callback cb) {
}
public boolean onSubMenuSelected(SubMenuBuilder subMenu) {
return false;
}
public void onCloseMenu(MenuBuilder menu, boolean allMenusAreClosing) {
}
public boolean flagActionItems() {
return false;
}
public boolean expandItemActionView(MenuBuilder menu, MenuItemImpl item) {
Toolbar.this.ensureCollapseButtonView();
if (Toolbar.this.mCollapseButtonView.getParent() != Toolbar.this) {
Toolbar.this.addView(Toolbar.this.mCollapseButtonView);
}
Toolbar.this.mExpandedActionView = item.getActionView();
this.mCurrentExpandedItem = item;
if (Toolbar.this.mExpandedActionView.getParent() != Toolbar.this) {
LayoutParams lp = Toolbar.this.generateDefaultLayoutParams();
lp.gravity = 8388611 | (Toolbar.this.mButtonGravity & 112);
lp.mViewType = 2;
Toolbar.this.mExpandedActionView.setLayoutParams(lp);
Toolbar.this.addView(Toolbar.this.mExpandedActionView);
}
Toolbar.this.removeChildrenForExpandedActionView();
Toolbar.this.requestLayout();
item.setActionViewExpanded(true);
if (Toolbar.this.mExpandedActionView instanceof CollapsibleActionView) {
((CollapsibleActionView) Toolbar.this.mExpandedActionView).onActionViewExpanded();
}
return true;
}
public boolean collapseItemActionView(MenuBuilder menu, MenuItemImpl item) {
if (Toolbar.this.mExpandedActionView instanceof CollapsibleActionView) {
((CollapsibleActionView) Toolbar.this.mExpandedActionView).onActionViewCollapsed();
}
Toolbar.this.removeView(Toolbar.this.mExpandedActionView);
Toolbar.this.removeView(Toolbar.this.mCollapseButtonView);
Toolbar.this.mExpandedActionView = null;
Toolbar.this.addChildrenForExpandedActionView();
this.mCurrentExpandedItem = null;
Toolbar.this.requestLayout();
item.setActionViewExpanded(false);
return true;
}
public int getId() {
return 0;
}
public Parcelable onSaveInstanceState() {
return null;
}
public void onRestoreInstanceState(Parcelable state) {
}
}
public static class LayoutParams extends android.support.v7.app.ActionBar.LayoutParams {
static final int CUSTOM = 0;
static final int EXPANDED = 2;
static final int SYSTEM = 1;
int mViewType;
public LayoutParams(@NonNull Context c, AttributeSet attrs) {
super(c, attrs);
this.mViewType = 0;
}
public LayoutParams(int width, int height) {
super(width, height);
this.mViewType = 0;
this.gravity = 8388627;
}
public LayoutParams(int width, int height, int gravity) {
super(width, height);
this.mViewType = 0;
this.gravity = gravity;
}
public LayoutParams(int gravity) {
this(-2, -1, gravity);
}
public LayoutParams(LayoutParams source) {
super((android.support.v7.app.ActionBar.LayoutParams) source);
this.mViewType = 0;
this.mViewType = source.mViewType;
}
public LayoutParams(android.support.v7.app.ActionBar.LayoutParams source) {
super(source);
this.mViewType = 0;
}
public LayoutParams(MarginLayoutParams source) {
super((android.view.ViewGroup.LayoutParams) source);
this.mViewType = 0;
copyMarginsFromCompat(source);
}
public LayoutParams(android.view.ViewGroup.LayoutParams source) {
super(source);
this.mViewType = 0;
}
void copyMarginsFromCompat(MarginLayoutParams source) {
this.leftMargin = source.leftMargin;
this.topMargin = source.topMargin;
this.rightMargin = source.rightMargin;
this.bottomMargin = source.bottomMargin;
}
}
public Toolbar(Context context) {
this(context, null);
}
public Toolbar(Context context, @Nullable AttributeSet attrs) {
this(context, attrs, R.attr.toolbarStyle);
}
public Toolbar(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
this.mContentInsets = new RtlSpacingHelper();
this.mGravity = 8388627;
this.mTempViews = new ArrayList();
this.mHiddenViews = new ArrayList();
this.mTempMargins = new int[2];
this.mMenuViewItemClickListener = new android.support.v7.widget.ActionMenuView.OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
if (Toolbar.this.mOnMenuItemClickListener != null) {
return Toolbar.this.mOnMenuItemClickListener.onMenuItemClick(item);
}
return false;
}
};
this.mShowOverflowMenuRunnable = new Runnable() {
public void run() {
Toolbar.this.showOverflowMenu();
}
};
TintTypedArray a = TintTypedArray.obtainStyledAttributes(getContext(), attrs, R.styleable.Toolbar, defStyleAttr, 0);
this.mTitleTextAppearance = a.getResourceId(R.styleable.Toolbar_titleTextAppearance, 0);
this.mSubtitleTextAppearance = a.getResourceId(R.styleable.Toolbar_subtitleTextAppearance, 0);
this.mGravity = a.getInteger(R.styleable.Toolbar_android_gravity, this.mGravity);
this.mButtonGravity = 48;
int dimensionPixelOffset = a.getDimensionPixelOffset(R.styleable.Toolbar_titleMargins, 0);
this.mTitleMarginBottom = dimensionPixelOffset;
this.mTitleMarginTop = dimensionPixelOffset;
this.mTitleMarginEnd = dimensionPixelOffset;
this.mTitleMarginStart = dimensionPixelOffset;
int marginStart = a.getDimensionPixelOffset(R.styleable.Toolbar_titleMarginStart, -1);
if (marginStart >= 0) {
this.mTitleMarginStart = marginStart;
}
int marginEnd = a.getDimensionPixelOffset(R.styleable.Toolbar_titleMarginEnd, -1);
if (marginEnd >= 0) {
this.mTitleMarginEnd = marginEnd;
}
int marginTop = a.getDimensionPixelOffset(R.styleable.Toolbar_titleMarginTop, -1);
if (marginTop >= 0) {
this.mTitleMarginTop = marginTop;
}
int marginBottom = a.getDimensionPixelOffset(R.styleable.Toolbar_titleMarginBottom, -1);
if (marginBottom >= 0) {
this.mTitleMarginBottom = marginBottom;
}
this.mMaxButtonHeight = a.getDimensionPixelSize(R.styleable.Toolbar_maxButtonHeight, -1);
int contentInsetStart = a.getDimensionPixelOffset(R.styleable.Toolbar_contentInsetStart, Integer.MIN_VALUE);
int contentInsetEnd = a.getDimensionPixelOffset(R.styleable.Toolbar_contentInsetEnd, Integer.MIN_VALUE);
this.mContentInsets.setAbsolute(a.getDimensionPixelSize(R.styleable.Toolbar_contentInsetLeft, 0), a.getDimensionPixelSize(R.styleable.Toolbar_contentInsetRight, 0));
if (!(contentInsetStart == Integer.MIN_VALUE && contentInsetEnd == Integer.MIN_VALUE)) {
this.mContentInsets.setRelative(contentInsetStart, contentInsetEnd);
}
this.mCollapseIcon = a.getDrawable(R.styleable.Toolbar_collapseIcon);
this.mCollapseDescription = a.getText(R.styleable.Toolbar_collapseContentDescription);
CharSequence title = a.getText(R.styleable.Toolbar_title);
if (!TextUtils.isEmpty(title)) {
setTitle(title);
}
CharSequence subtitle = a.getText(R.styleable.Toolbar_subtitle);
if (!TextUtils.isEmpty(subtitle)) {
setSubtitle(subtitle);
}
this.mPopupContext = getContext();
setPopupTheme(a.getResourceId(R.styleable.Toolbar_popupTheme, 0));
Drawable navIcon = a.getDrawable(R.styleable.Toolbar_navigationIcon);
if (navIcon != null) {
setNavigationIcon(navIcon);
}
CharSequence navDesc = a.getText(R.styleable.Toolbar_navigationContentDescription);
if (!TextUtils.isEmpty(navDesc)) {
setNavigationContentDescription(navDesc);
}
Drawable logo = a.getDrawable(R.styleable.Toolbar_logo);
if (logo != null) {
setLogo(logo);
}
CharSequence logoDesc = a.getText(R.styleable.Toolbar_logoDescription);
if (!TextUtils.isEmpty(logoDesc)) {
setLogoDescription(logoDesc);
}
if (a.hasValue(R.styleable.Toolbar_titleTextColor)) {
setTitleTextColor(a.getColor(R.styleable.Toolbar_titleTextColor, -1));
}
if (a.hasValue(R.styleable.Toolbar_subtitleTextColor)) {
setSubtitleTextColor(a.getColor(R.styleable.Toolbar_subtitleTextColor, -1));
}
a.recycle();
this.mTintManager = a.getTintManager();
}
public void setPopupTheme(@StyleRes int resId) {
if (this.mPopupTheme != resId) {
this.mPopupTheme = resId;
if (resId == 0) {
this.mPopupContext = getContext();
} else {
this.mPopupContext = new ContextThemeWrapper(getContext(), resId);
}
}
}
public int getPopupTheme() {
return this.mPopupTheme;
}
public void onRtlPropertiesChanged(int layoutDirection) {
boolean z = true;
if (VERSION.SDK_INT >= 17) {
super.onRtlPropertiesChanged(layoutDirection);
}
RtlSpacingHelper rtlSpacingHelper = this.mContentInsets;
if (layoutDirection != 1) {
z = false;
}
rtlSpacingHelper.setDirection(z);
}
public void setLogo(@DrawableRes int resId) {
setLogo(this.mTintManager.getDrawable(resId));
}
public boolean canShowOverflowMenu() {
return getVisibility() == 0 && this.mMenuView != null && this.mMenuView.isOverflowReserved();
}
public boolean isOverflowMenuShowing() {
return this.mMenuView != null && this.mMenuView.isOverflowMenuShowing();
}
public boolean isOverflowMenuShowPending() {
return this.mMenuView != null && this.mMenuView.isOverflowMenuShowPending();
}
public boolean showOverflowMenu() {
return this.mMenuView != null && this.mMenuView.showOverflowMenu();
}
public boolean hideOverflowMenu() {
return this.mMenuView != null && this.mMenuView.hideOverflowMenu();
}
public void setMenu(MenuBuilder menu, ActionMenuPresenter outerPresenter) {
if (menu != null || this.mMenuView != null) {
ensureMenuView();
MenuBuilder oldMenu = this.mMenuView.peekMenu();
if (oldMenu != menu) {
if (oldMenu != null) {
oldMenu.removeMenuPresenter(this.mOuterActionMenuPresenter);
oldMenu.removeMenuPresenter(this.mExpandedMenuPresenter);
}
if (this.mExpandedMenuPresenter == null) {
this.mExpandedMenuPresenter = new ExpandedActionViewMenuPresenter();
}
outerPresenter.setExpandedActionViewsExclusive(true);
if (menu != null) {
menu.addMenuPresenter(outerPresenter, this.mPopupContext);
menu.addMenuPresenter(this.mExpandedMenuPresenter, this.mPopupContext);
} else {
outerPresenter.initForMenu(this.mPopupContext, null);
this.mExpandedMenuPresenter.initForMenu(this.mPopupContext, null);
outerPresenter.updateMenuView(true);
this.mExpandedMenuPresenter.updateMenuView(true);
}
this.mMenuView.setPopupTheme(this.mPopupTheme);
this.mMenuView.setPresenter(outerPresenter);
this.mOuterActionMenuPresenter = outerPresenter;
}
}
}
public void dismissPopupMenus() {
if (this.mMenuView != null) {
this.mMenuView.dismissPopupMenus();
}
}
public boolean isTitleTruncated() {
if (this.mTitleTextView == null) {
return false;
}
Layout titleLayout = this.mTitleTextView.getLayout();
if (titleLayout == null) {
return false;
}
int lineCount = titleLayout.getLineCount();
for (int i = 0; i < lineCount; i++) {
if (titleLayout.getEllipsisCount(i) > 0) {
return true;
}
}
return false;
}
public void setLogo(Drawable drawable) {
if (drawable != null) {
ensureLogoView();
if (!isChildOrHidden(this.mLogoView)) {
addSystemView(this.mLogoView, true);
}
} else if (this.mLogoView != null && isChildOrHidden(this.mLogoView)) {
removeView(this.mLogoView);
this.mHiddenViews.remove(this.mLogoView);
}
if (this.mLogoView != null) {
this.mLogoView.setImageDrawable(drawable);
}
}
public Drawable getLogo() {
return this.mLogoView != null ? this.mLogoView.getDrawable() : null;
}
public void setLogoDescription(@StringRes int resId) {
setLogoDescription(getContext().getText(resId));
}
public void setLogoDescription(CharSequence description) {
if (!TextUtils.isEmpty(description)) {
ensureLogoView();
}
if (this.mLogoView != null) {
this.mLogoView.setContentDescription(description);
}
}
public CharSequence getLogoDescription() {
return this.mLogoView != null ? this.mLogoView.getContentDescription() : null;
}
private void ensureLogoView() {
if (this.mLogoView == null) {
this.mLogoView = new ImageView(getContext());
}
}
public boolean hasExpandedActionView() {
return (this.mExpandedMenuPresenter == null || this.mExpandedMenuPresenter.mCurrentExpandedItem == null) ? false : true;
}
public void collapseActionView() {
MenuItemImpl item = this.mExpandedMenuPresenter == null ? null : this.mExpandedMenuPresenter.mCurrentExpandedItem;
if (item != null) {
item.collapseActionView();
}
}
public CharSequence getTitle() {
return this.mTitleText;
}
public void setTitle(@StringRes int resId) {
setTitle(getContext().getText(resId));
}
public void setTitle(CharSequence title) {
if (!TextUtils.isEmpty(title)) {
if (this.mTitleTextView == null) {
Context context = getContext();
this.mTitleTextView = new TextView(context);
this.mTitleTextView.setSingleLine();
this.mTitleTextView.setEllipsize(TruncateAt.END);
if (this.mTitleTextAppearance != 0) {
this.mTitleTextView.setTextAppearance(context, this.mTitleTextAppearance);
}
if (this.mTitleTextColor != 0) {
this.mTitleTextView.setTextColor(this.mTitleTextColor);
}
}
if (!isChildOrHidden(this.mTitleTextView)) {
addSystemView(this.mTitleTextView, true);
}
} else if (this.mTitleTextView != null && isChildOrHidden(this.mTitleTextView)) {
removeView(this.mTitleTextView);
this.mHiddenViews.remove(this.mTitleTextView);
}
if (this.mTitleTextView != null) {
this.mTitleTextView.setText(title);
}
this.mTitleText = title;
}
public CharSequence getSubtitle() {
return this.mSubtitleText;
}
public void setSubtitle(@StringRes int resId) {
setSubtitle(getContext().getText(resId));
}
public void setSubtitle(CharSequence subtitle) {
if (!TextUtils.isEmpty(subtitle)) {
if (this.mSubtitleTextView == null) {
Context context = getContext();
this.mSubtitleTextView = new TextView(context);
this.mSubtitleTextView.setSingleLine();
this.mSubtitleTextView.setEllipsize(TruncateAt.END);
if (this.mSubtitleTextAppearance != 0) {
this.mSubtitleTextView.setTextAppearance(context, this.mSubtitleTextAppearance);
}
if (this.mSubtitleTextColor != 0) {
this.mSubtitleTextView.setTextColor(this.mSubtitleTextColor);
}
}
if (!isChildOrHidden(this.mSubtitleTextView)) {
addSystemView(this.mSubtitleTextView, true);
}
} else if (this.mSubtitleTextView != null && isChildOrHidden(this.mSubtitleTextView)) {
removeView(this.mSubtitleTextView);
this.mHiddenViews.remove(this.mSubtitleTextView);
}
if (this.mSubtitleTextView != null) {
this.mSubtitleTextView.setText(subtitle);
}
this.mSubtitleText = subtitle;
}
public void setTitleTextAppearance(Context context, @StyleRes int resId) {
this.mTitleTextAppearance = resId;
if (this.mTitleTextView != null) {
this.mTitleTextView.setTextAppearance(context, resId);
}
}
public void setSubtitleTextAppearance(Context context, @StyleRes int resId) {
this.mSubtitleTextAppearance = resId;
if (this.mSubtitleTextView != null) {
this.mSubtitleTextView.setTextAppearance(context, resId);
}
}
public void setTitleTextColor(@ColorInt int color) {
this.mTitleTextColor = color;
if (this.mTitleTextView != null) {
this.mTitleTextView.setTextColor(color);
}
}
public void setSubtitleTextColor(@ColorInt int color) {
this.mSubtitleTextColor = color;
if (this.mSubtitleTextView != null) {
this.mSubtitleTextView.setTextColor(color);
}
}
@Nullable
public CharSequence getNavigationContentDescription() {
return this.mNavButtonView != null ? this.mNavButtonView.getContentDescription() : null;
}
public void setNavigationContentDescription(@StringRes int resId) {
setNavigationContentDescription(resId != 0 ? getContext().getText(resId) : null);
}
public void setNavigationContentDescription(@Nullable CharSequence description) {
if (!TextUtils.isEmpty(description)) {
ensureNavButtonView();
}
if (this.mNavButtonView != null) {
this.mNavButtonView.setContentDescription(description);
}
}
public void setNavigationIcon(@DrawableRes int resId) {
setNavigationIcon(this.mTintManager.getDrawable(resId));
}
public void setNavigationIcon(@Nullable Drawable icon) {
if (icon != null) {
ensureNavButtonView();
if (!isChildOrHidden(this.mNavButtonView)) {
addSystemView(this.mNavButtonView, true);
}
} else if (this.mNavButtonView != null && isChildOrHidden(this.mNavButtonView)) {
removeView(this.mNavButtonView);
this.mHiddenViews.remove(this.mNavButtonView);
}
if (this.mNavButtonView != null) {
this.mNavButtonView.setImageDrawable(icon);
}
}
@Nullable
public Drawable getNavigationIcon() {
return this.mNavButtonView != null ? this.mNavButtonView.getDrawable() : null;
}
public void setNavigationOnClickListener(OnClickListener listener) {
ensureNavButtonView();
this.mNavButtonView.setOnClickListener(listener);
}
public Menu getMenu() {
ensureMenu();
return this.mMenuView.getMenu();
}
public void setOverflowIcon(@Nullable Drawable icon) {
ensureMenu();
this.mMenuView.setOverflowIcon(icon);
}
@Nullable
public Drawable getOverflowIcon() {
ensureMenu();
return this.mMenuView.getOverflowIcon();
}
private void ensureMenu() {
ensureMenuView();
if (this.mMenuView.peekMenu() == null) {
MenuBuilder menu = (MenuBuilder) this.mMenuView.getMenu();
if (this.mExpandedMenuPresenter == null) {
this.mExpandedMenuPresenter = new ExpandedActionViewMenuPresenter();
}
this.mMenuView.setExpandedActionViewsExclusive(true);
menu.addMenuPresenter(this.mExpandedMenuPresenter, this.mPopupContext);
}
}
private void ensureMenuView() {
if (this.mMenuView == null) {
this.mMenuView = new ActionMenuView(getContext());
this.mMenuView.setPopupTheme(this.mPopupTheme);
this.mMenuView.setOnMenuItemClickListener(this.mMenuViewItemClickListener);
this.mMenuView.setMenuCallbacks(this.mActionMenuPresenterCallback, this.mMenuBuilderCallback);
LayoutParams lp = generateDefaultLayoutParams();
lp.gravity = GravityCompat.END | (this.mButtonGravity & 112);
this.mMenuView.setLayoutParams(lp);
addSystemView(this.mMenuView, false);
}
}
private MenuInflater getMenuInflater() {
return new SupportMenuInflater(getContext());
}
public void inflateMenu(@MenuRes int resId) {
getMenuInflater().inflate(resId, getMenu());
}
public void setOnMenuItemClickListener(OnMenuItemClickListener listener) {
this.mOnMenuItemClickListener = listener;
}
public void setContentInsetsRelative(int contentInsetStart, int contentInsetEnd) {
this.mContentInsets.setRelative(contentInsetStart, contentInsetEnd);
}
public int getContentInsetStart() {
return this.mContentInsets.getStart();
}
public int getContentInsetEnd() {
return this.mContentInsets.getEnd();
}
public void setContentInsetsAbsolute(int contentInsetLeft, int contentInsetRight) {
this.mContentInsets.setAbsolute(contentInsetLeft, contentInsetRight);
}
public int getContentInsetLeft() {
return this.mContentInsets.getLeft();
}
public int getContentInsetRight() {
return this.mContentInsets.getRight();
}
private void ensureNavButtonView() {
if (this.mNavButtonView == null) {
this.mNavButtonView = new ImageButton(getContext(), null, R.attr.toolbarNavigationButtonStyle);
LayoutParams lp = generateDefaultLayoutParams();
lp.gravity = 8388611 | (this.mButtonGravity & 112);
this.mNavButtonView.setLayoutParams(lp);
}
}
private void ensureCollapseButtonView() {
if (this.mCollapseButtonView == null) {
this.mCollapseButtonView = new ImageButton(getContext(), null, R.attr.toolbarNavigationButtonStyle);
this.mCollapseButtonView.setImageDrawable(this.mCollapseIcon);
this.mCollapseButtonView.setContentDescription(this.mCollapseDescription);
LayoutParams lp = generateDefaultLayoutParams();
lp.gravity = 8388611 | (this.mButtonGravity & 112);
lp.mViewType = 2;
this.mCollapseButtonView.setLayoutParams(lp);
this.mCollapseButtonView.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
Toolbar.this.collapseActionView();
}
});
}
}
private void addSystemView(View v, boolean allowHide) {
LayoutParams lp;
android.view.ViewGroup.LayoutParams vlp = v.getLayoutParams();
if (vlp == null) {
lp = generateDefaultLayoutParams();
} else if (checkLayoutParams(vlp)) {
lp = (LayoutParams) vlp;
} else {
lp = generateLayoutParams(vlp);
}
lp.mViewType = 1;
if (!allowHide || this.mExpandedActionView == null) {
addView(v, lp);
return;
}
v.setLayoutParams(lp);
this.mHiddenViews.add(v);
}
protected Parcelable onSaveInstanceState() {
SavedState state = new SavedState(super.onSaveInstanceState());
if (!(this.mExpandedMenuPresenter == null || this.mExpandedMenuPresenter.mCurrentExpandedItem == null)) {
state.expandedMenuItemId = this.mExpandedMenuPresenter.mCurrentExpandedItem.getItemId();
}
state.isOverflowOpen = isOverflowMenuShowing();
return state;
}
protected void onRestoreInstanceState(Parcelable state) {
SavedState ss = (SavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
Menu menu = this.mMenuView != null ? this.mMenuView.peekMenu() : null;
if (!(ss.expandedMenuItemId == 0 || this.mExpandedMenuPresenter == null || menu == null)) {
MenuItem item = menu.findItem(ss.expandedMenuItemId);
if (item != null) {
MenuItemCompat.expandActionView(item);
}
}
if (ss.isOverflowOpen) {
postShowOverflowMenu();
}
}
private void postShowOverflowMenu() {
removeCallbacks(this.mShowOverflowMenuRunnable);
post(this.mShowOverflowMenuRunnable);
}
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
removeCallbacks(this.mShowOverflowMenuRunnable);
}
public boolean onTouchEvent(MotionEvent ev) {
int action = MotionEventCompat.getActionMasked(ev);
if (action == 0) {
this.mEatingTouch = false;
}
if (!this.mEatingTouch) {
boolean handled = super.onTouchEvent(ev);
if (action == 0 && !handled) {
this.mEatingTouch = true;
}
}
if (action == 1 || action == 3) {
this.mEatingTouch = false;
}
return true;
}
public boolean onHoverEvent(MotionEvent ev) {
int action = MotionEventCompat.getActionMasked(ev);
if (action == 9) {
this.mEatingHover = false;
}
if (!this.mEatingHover) {
boolean handled = super.onHoverEvent(ev);
if (action == 9 && !handled) {
this.mEatingHover = true;
}
}
if (action == 10 || action == 3) {
this.mEatingHover = false;
}
return true;
}
private void measureChildConstrained(View child, int parentWidthSpec, int widthUsed, int parentHeightSpec, int heightUsed, int heightConstraint) {
MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
int childWidthSpec = getChildMeasureSpec(parentWidthSpec, (((getPaddingLeft() + getPaddingRight()) + lp.leftMargin) + lp.rightMargin) + widthUsed, lp.width);
int childHeightSpec = getChildMeasureSpec(parentHeightSpec, (((getPaddingTop() + getPaddingBottom()) + lp.topMargin) + lp.bottomMargin) + heightUsed, lp.height);
int childHeightMode = MeasureSpec.getMode(childHeightSpec);
if (childHeightMode != 1073741824 && heightConstraint >= 0) {
childHeightSpec = MeasureSpec.makeMeasureSpec(childHeightMode != 0 ? Math.min(MeasureSpec.getSize(childHeightSpec), heightConstraint) : heightConstraint, 1073741824);
}
child.measure(childWidthSpec, childHeightSpec);
}
private int measureChildCollapseMargins(View child, int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed, int[] collapsingMargins) {
MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
int leftDiff = lp.leftMargin - collapsingMargins[0];
int rightDiff = lp.rightMargin - collapsingMargins[1];
int hMargins = Math.max(0, leftDiff) + Math.max(0, rightDiff);
collapsingMargins[0] = Math.max(0, -leftDiff);
collapsingMargins[1] = Math.max(0, -rightDiff);
child.measure(getChildMeasureSpec(parentWidthMeasureSpec, ((getPaddingLeft() + getPaddingRight()) + hMargins) + widthUsed, lp.width), getChildMeasureSpec(parentHeightMeasureSpec, (((getPaddingTop() + getPaddingBottom()) + lp.topMargin) + lp.bottomMargin) + heightUsed, lp.height));
return child.getMeasuredWidth() + hMargins;
}
private boolean shouldCollapse() {
if (!this.mCollapsible) {
return false;
}
int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
View child = getChildAt(i);
if (shouldLayout(child) && child.getMeasuredWidth() > 0 && child.getMeasuredHeight() > 0) {
return false;
}
}
return true;
}
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int marginStartIndex;
int marginEndIndex;
int i;
int height = 0;
int childState = 0;
int[] collapsingMargins = this.mTempMargins;
if (ViewUtils.isLayoutRtl(this)) {
marginStartIndex = 1;
marginEndIndex = 0;
} else {
marginStartIndex = 0;
marginEndIndex = 1;
}
int navWidth = 0;
if (shouldLayout(this.mNavButtonView)) {
measureChildConstrained(this.mNavButtonView, widthMeasureSpec, 0, heightMeasureSpec, 0, this.mMaxButtonHeight);
navWidth = this.mNavButtonView.getMeasuredWidth() + getHorizontalMargins(this.mNavButtonView);
i = 0;
height = Math.max(i, this.mNavButtonView.getMeasuredHeight() + getVerticalMargins(this.mNavButtonView));
childState = ViewUtils.combineMeasuredStates(0, ViewCompat.getMeasuredState(this.mNavButtonView));
}
if (shouldLayout(this.mCollapseButtonView)) {
measureChildConstrained(this.mCollapseButtonView, widthMeasureSpec, 0, heightMeasureSpec, 0, this.mMaxButtonHeight);
navWidth = this.mCollapseButtonView.getMeasuredWidth() + getHorizontalMargins(this.mCollapseButtonView);
i = height;
height = Math.max(i, this.mCollapseButtonView.getMeasuredHeight() + getVerticalMargins(this.mCollapseButtonView));
childState = ViewUtils.combineMeasuredStates(childState, ViewCompat.getMeasuredState(this.mCollapseButtonView));
}
int contentInsetStart = getContentInsetStart();
int width = 0 + Math.max(contentInsetStart, navWidth);
collapsingMargins[marginStartIndex] = Math.max(0, contentInsetStart - navWidth);
int menuWidth = 0;
if (shouldLayout(this.mMenuView)) {
measureChildConstrained(this.mMenuView, widthMeasureSpec, width, heightMeasureSpec, 0, this.mMaxButtonHeight);
menuWidth = this.mMenuView.getMeasuredWidth() + getHorizontalMargins(this.mMenuView);
i = height;
height = Math.max(i, this.mMenuView.getMeasuredHeight() + getVerticalMargins(this.mMenuView));
childState = ViewUtils.combineMeasuredStates(childState, ViewCompat.getMeasuredState(this.mMenuView));
}
int contentInsetEnd = getContentInsetEnd();
width += Math.max(contentInsetEnd, menuWidth);
collapsingMargins[marginEndIndex] = Math.max(0, contentInsetEnd - menuWidth);
if (shouldLayout(this.mExpandedActionView)) {
width += measureChildCollapseMargins(this.mExpandedActionView, widthMeasureSpec, width, heightMeasureSpec, 0, collapsingMargins);
i = height;
height = Math.max(i, this.mExpandedActionView.getMeasuredHeight() + getVerticalMargins(this.mExpandedActionView));
childState = ViewUtils.combineMeasuredStates(childState, ViewCompat.getMeasuredState(this.mExpandedActionView));
}
if (shouldLayout(this.mLogoView)) {
width += measureChildCollapseMargins(this.mLogoView, widthMeasureSpec, width, heightMeasureSpec, 0, collapsingMargins);
i = height;
height = Math.max(i, this.mLogoView.getMeasuredHeight() + getVerticalMargins(this.mLogoView));
childState = ViewUtils.combineMeasuredStates(childState, ViewCompat.getMeasuredState(this.mLogoView));
}
int childCount = getChildCount();
for (int i2 = 0; i2 < childCount; i2++) {
View child = getChildAt(i2);
if (((LayoutParams) child.getLayoutParams()).mViewType == 0 && shouldLayout(child)) {
width += measureChildCollapseMargins(child, widthMeasureSpec, width, heightMeasureSpec, 0, collapsingMargins);
height = Math.max(height, child.getMeasuredHeight() + getVerticalMargins(child));
childState = ViewUtils.combineMeasuredStates(childState, ViewCompat.getMeasuredState(child));
}
}
int titleWidth = 0;
int titleHeight = 0;
int titleVertMargins = this.mTitleMarginTop + this.mTitleMarginBottom;
int titleHorizMargins = this.mTitleMarginStart + this.mTitleMarginEnd;
if (shouldLayout(this.mTitleTextView)) {
titleWidth = measureChildCollapseMargins(this.mTitleTextView, widthMeasureSpec, width + titleHorizMargins, heightMeasureSpec, titleVertMargins, collapsingMargins);
titleWidth = this.mTitleTextView.getMeasuredWidth() + getHorizontalMargins(this.mTitleTextView);
titleHeight = this.mTitleTextView.getMeasuredHeight() + getVerticalMargins(this.mTitleTextView);
childState = ViewUtils.combineMeasuredStates(childState, ViewCompat.getMeasuredState(this.mTitleTextView));
}
if (shouldLayout(this.mSubtitleTextView)) {
i = titleWidth;
titleWidth = Math.max(i, measureChildCollapseMargins(this.mSubtitleTextView, widthMeasureSpec, width + titleHorizMargins, heightMeasureSpec, titleHeight + titleVertMargins, collapsingMargins));
titleHeight += this.mSubtitleTextView.getMeasuredHeight() + getVerticalMargins(this.mSubtitleTextView);
childState = ViewUtils.combineMeasuredStates(childState, ViewCompat.getMeasuredState(this.mSubtitleTextView));
}
width += titleWidth;
height = Math.max(height, titleHeight) + (getPaddingTop() + getPaddingBottom());
i = widthMeasureSpec;
int measuredWidth = ViewCompat.resolveSizeAndState(Math.max(width + (getPaddingLeft() + getPaddingRight()), getSuggestedMinimumWidth()), i, ViewCompat.MEASURED_STATE_MASK & childState);
i = heightMeasureSpec;
int measuredHeight = ViewCompat.resolveSizeAndState(Math.max(height, getSuggestedMinimumHeight()), i, childState << 16);
if (shouldCollapse()) {
measuredHeight = 0;
}
setMeasuredDimension(measuredWidth, measuredHeight);
}
protected void onLayout(boolean changed, int l, int t, int r, int b) {
int i;
boolean isRtl = ViewCompat.getLayoutDirection(this) == 1;
int width = getWidth();
int height = getHeight();
int paddingLeft = getPaddingLeft();
int paddingRight = getPaddingRight();
int paddingTop = getPaddingTop();
int paddingBottom = getPaddingBottom();
int left = paddingLeft;
int right = width - paddingRight;
int[] collapsingMargins = this.mTempMargins;
collapsingMargins[1] = 0;
collapsingMargins[0] = 0;
int alignmentHeight = ViewCompat.getMinimumHeight(this);
if (shouldLayout(this.mNavButtonView)) {
if (isRtl) {
right = layoutChildRight(this.mNavButtonView, right, collapsingMargins, alignmentHeight);
} else {
left = layoutChildLeft(this.mNavButtonView, left, collapsingMargins, alignmentHeight);
}
}
if (shouldLayout(this.mCollapseButtonView)) {
if (isRtl) {
right = layoutChildRight(this.mCollapseButtonView, right, collapsingMargins, alignmentHeight);
} else {
left = layoutChildLeft(this.mCollapseButtonView, left, collapsingMargins, alignmentHeight);
}
}
if (shouldLayout(this.mMenuView)) {
if (isRtl) {
left = layoutChildLeft(this.mMenuView, left, collapsingMargins, alignmentHeight);
} else {
right = layoutChildRight(this.mMenuView, right, collapsingMargins, alignmentHeight);
}
}
collapsingMargins[0] = Math.max(0, getContentInsetLeft() - left);
collapsingMargins[1] = Math.max(0, getContentInsetRight() - ((width - paddingRight) - right));
left = Math.max(left, getContentInsetLeft());
right = Math.min(right, (width - paddingRight) - getContentInsetRight());
if (shouldLayout(this.mExpandedActionView)) {
if (isRtl) {
right = layoutChildRight(this.mExpandedActionView, right, collapsingMargins, alignmentHeight);
} else {
left = layoutChildLeft(this.mExpandedActionView, left, collapsingMargins, alignmentHeight);
}
}
if (shouldLayout(this.mLogoView)) {
if (isRtl) {
right = layoutChildRight(this.mLogoView, right, collapsingMargins, alignmentHeight);
} else {
left = layoutChildLeft(this.mLogoView, left, collapsingMargins, alignmentHeight);
}
}
boolean layoutTitle = shouldLayout(this.mTitleTextView);
boolean layoutSubtitle = shouldLayout(this.mSubtitleTextView);
int titleHeight = 0;
if (layoutTitle) {
LayoutParams lp = (LayoutParams) this.mTitleTextView.getLayoutParams();
titleHeight = 0 + ((lp.topMargin + this.mTitleTextView.getMeasuredHeight()) + lp.bottomMargin);
}
if (layoutSubtitle) {
lp = (LayoutParams) this.mSubtitleTextView.getLayoutParams();
titleHeight += (lp.topMargin + this.mSubtitleTextView.getMeasuredHeight()) + lp.bottomMargin;
}
if (layoutTitle || layoutSubtitle) {
int titleTop;
LayoutParams toplp = (LayoutParams) (layoutTitle ? this.mTitleTextView : this.mSubtitleTextView).getLayoutParams();
LayoutParams bottomlp = (LayoutParams) (layoutSubtitle ? this.mSubtitleTextView : this.mTitleTextView).getLayoutParams();
boolean titleHasWidth = (layoutTitle && this.mTitleTextView.getMeasuredWidth() > 0) || (layoutSubtitle && this.mSubtitleTextView.getMeasuredWidth() > 0);
switch (this.mGravity & 112) {
case 48:
titleTop = (getPaddingTop() + toplp.topMargin) + this.mTitleMarginTop;
break;
case 80:
titleTop = (((height - paddingBottom) - bottomlp.bottomMargin) - this.mTitleMarginBottom) - titleHeight;
break;
default:
int spaceAbove = (((height - paddingTop) - paddingBottom) - titleHeight) / 2;
if (spaceAbove < toplp.topMargin + this.mTitleMarginTop) {
spaceAbove = toplp.topMargin + this.mTitleMarginTop;
} else {
int spaceBelow = (((height - paddingBottom) - titleHeight) - spaceAbove) - paddingTop;
if (spaceBelow < toplp.bottomMargin + this.mTitleMarginBottom) {
spaceAbove = Math.max(0, spaceAbove - ((bottomlp.bottomMargin + this.mTitleMarginBottom) - spaceBelow));
}
}
titleTop = paddingTop + spaceAbove;
break;
}
int titleRight;
int subtitleRight;
int titleLeft;
int titleBottom;
int subtitleBottom;
if (isRtl) {
int rd = (titleHasWidth ? this.mTitleMarginStart : 0) - collapsingMargins[1];
right -= Math.max(0, rd);
collapsingMargins[1] = Math.max(0, -rd);
titleRight = right;
subtitleRight = right;
if (layoutTitle) {
lp = (LayoutParams) this.mTitleTextView.getLayoutParams();
titleLeft = titleRight - this.mTitleTextView.getMeasuredWidth();
titleBottom = titleTop + this.mTitleTextView.getMeasuredHeight();
this.mTitleTextView.layout(titleLeft, titleTop, titleRight, titleBottom);
titleRight = titleLeft - this.mTitleMarginEnd;
titleTop = titleBottom + lp.bottomMargin;
}
if (layoutSubtitle) {
lp = (LayoutParams) this.mSubtitleTextView.getLayoutParams();
titleTop += lp.topMargin;
subtitleBottom = titleTop + this.mSubtitleTextView.getMeasuredHeight();
this.mSubtitleTextView.layout(subtitleRight - this.mSubtitleTextView.getMeasuredWidth(), titleTop, subtitleRight, subtitleBottom);
subtitleRight -= this.mTitleMarginEnd;
titleTop = subtitleBottom + lp.bottomMargin;
}
if (titleHasWidth) {
right = Math.min(titleRight, subtitleRight);
}
} else {
int ld = (titleHasWidth ? this.mTitleMarginStart : 0) - collapsingMargins[0];
left += Math.max(0, ld);
collapsingMargins[0] = Math.max(0, -ld);
titleLeft = left;
int subtitleLeft = left;
if (layoutTitle) {
lp = (LayoutParams) this.mTitleTextView.getLayoutParams();
titleRight = titleLeft + this.mTitleTextView.getMeasuredWidth();
titleBottom = titleTop + this.mTitleTextView.getMeasuredHeight();
this.mTitleTextView.layout(titleLeft, titleTop, titleRight, titleBottom);
titleLeft = titleRight + this.mTitleMarginEnd;
titleTop = titleBottom + lp.bottomMargin;
}
if (layoutSubtitle) {
lp = (LayoutParams) this.mSubtitleTextView.getLayoutParams();
titleTop += lp.topMargin;
subtitleRight = subtitleLeft + this.mSubtitleTextView.getMeasuredWidth();
subtitleBottom = titleTop + this.mSubtitleTextView.getMeasuredHeight();
this.mSubtitleTextView.layout(subtitleLeft, titleTop, subtitleRight, subtitleBottom);
subtitleLeft = subtitleRight + this.mTitleMarginEnd;
titleTop = subtitleBottom + lp.bottomMargin;
}
if (titleHasWidth) {
left = Math.max(titleLeft, subtitleLeft);
}
}
}
addCustomViewsWithGravity(this.mTempViews, 3);
int leftViewsCount = this.mTempViews.size();
for (i = 0; i < leftViewsCount; i++) {
left = layoutChildLeft((View) this.mTempViews.get(i), left, collapsingMargins, alignmentHeight);
}
addCustomViewsWithGravity(this.mTempViews, 5);
int rightViewsCount = this.mTempViews.size();
for (i = 0; i < rightViewsCount; i++) {
right = layoutChildRight((View) this.mTempViews.get(i), right, collapsingMargins, alignmentHeight);
}
addCustomViewsWithGravity(this.mTempViews, 1);
int centerViewsWidth = getViewListMeasuredWidth(this.mTempViews, collapsingMargins);
int centerLeft = (paddingLeft + (((width - paddingLeft) - paddingRight) / 2)) - (centerViewsWidth / 2);
int centerRight = centerLeft + centerViewsWidth;
if (centerLeft < left) {
centerLeft = left;
} else if (centerRight > right) {
centerLeft -= centerRight - right;
}
int centerViewsCount = this.mTempViews.size();
for (i = 0; i < centerViewsCount; i++) {
centerLeft = layoutChildLeft((View) this.mTempViews.get(i), centerLeft, collapsingMargins, alignmentHeight);
}
this.mTempViews.clear();
}
private int getViewListMeasuredWidth(List<View> views, int[] collapsingMargins) {
int collapseLeft = collapsingMargins[0];
int collapseRight = collapsingMargins[1];
int width = 0;
int count = views.size();
for (int i = 0; i < count; i++) {
View v = (View) views.get(i);
LayoutParams lp = (LayoutParams) v.getLayoutParams();
int l = lp.leftMargin - collapseLeft;
int r = lp.rightMargin - collapseRight;
int leftMargin = Math.max(0, l);
int rightMargin = Math.max(0, r);
collapseLeft = Math.max(0, -l);
collapseRight = Math.max(0, -r);
width += (v.getMeasuredWidth() + leftMargin) + rightMargin;
}
return width;
}
private int layoutChildLeft(View child, int left, int[] collapsingMargins, int alignmentHeight) {
LayoutParams lp = (LayoutParams) child.getLayoutParams();
int l = lp.leftMargin - collapsingMargins[0];
left += Math.max(0, l);
collapsingMargins[0] = Math.max(0, -l);
int top = getChildTop(child, alignmentHeight);
int childWidth = child.getMeasuredWidth();
child.layout(left, top, left + childWidth, child.getMeasuredHeight() + top);
return left + (lp.rightMargin + childWidth);
}
private int layoutChildRight(View child, int right, int[] collapsingMargins, int alignmentHeight) {
LayoutParams lp = (LayoutParams) child.getLayoutParams();
int r = lp.rightMargin - collapsingMargins[1];
right -= Math.max(0, r);
collapsingMargins[1] = Math.max(0, -r);
int top = getChildTop(child, alignmentHeight);
int childWidth = child.getMeasuredWidth();
child.layout(right - childWidth, top, right, child.getMeasuredHeight() + top);
return right - (lp.leftMargin + childWidth);
}
private int getChildTop(View child, int alignmentHeight) {
int alignmentOffset;
LayoutParams lp = (LayoutParams) child.getLayoutParams();
int childHeight = child.getMeasuredHeight();
if (alignmentHeight > 0) {
alignmentOffset = (childHeight - alignmentHeight) / 2;
} else {
alignmentOffset = 0;
}
switch (getChildVerticalGravity(lp.gravity)) {
case 48:
return getPaddingTop() - alignmentOffset;
case 80:
return (((getHeight() - getPaddingBottom()) - childHeight) - lp.bottomMargin) - alignmentOffset;
default:
int paddingTop = getPaddingTop();
int paddingBottom = getPaddingBottom();
int height = getHeight();
int spaceAbove = (((height - paddingTop) - paddingBottom) - childHeight) / 2;
if (spaceAbove < lp.topMargin) {
spaceAbove = lp.topMargin;
} else {
int spaceBelow = (((height - paddingBottom) - childHeight) - spaceAbove) - paddingTop;
if (spaceBelow < lp.bottomMargin) {
spaceAbove = Math.max(0, spaceAbove - (lp.bottomMargin - spaceBelow));
}
}
return paddingTop + spaceAbove;
}
}
private int getChildVerticalGravity(int gravity) {
int vgrav = gravity & 112;
switch (vgrav) {
case 16:
case 48:
case 80:
return vgrav;
default:
return this.mGravity & 112;
}
}
private void addCustomViewsWithGravity(List<View> views, int gravity) {
boolean isRtl = true;
if (ViewCompat.getLayoutDirection(this) != 1) {
isRtl = false;
}
int childCount = getChildCount();
int absGrav = GravityCompat.getAbsoluteGravity(gravity, ViewCompat.getLayoutDirection(this));
views.clear();
int i;
View child;
LayoutParams lp;
if (isRtl) {
for (i = childCount - 1; i >= 0; i--) {
child = getChildAt(i);
lp = (LayoutParams) child.getLayoutParams();
if (lp.mViewType == 0 && shouldLayout(child) && getChildHorizontalGravity(lp.gravity) == absGrav) {
views.add(child);
}
}
return;
}
for (i = 0; i < childCount; i++) {
child = getChildAt(i);
lp = (LayoutParams) child.getLayoutParams();
if (lp.mViewType == 0 && shouldLayout(child) && getChildHorizontalGravity(lp.gravity) == absGrav) {
views.add(child);
}
}
}
private int getChildHorizontalGravity(int gravity) {
int ld = ViewCompat.getLayoutDirection(this);
int hGrav = GravityCompat.getAbsoluteGravity(gravity, ld) & 7;
switch (hGrav) {
case 1:
case 3:
case 5:
return hGrav;
default:
return ld == 1 ? 5 : 3;
}
}
private boolean shouldLayout(View view) {
return (view == null || view.getParent() != this || view.getVisibility() == 8) ? false : true;
}
private int getHorizontalMargins(View v) {
MarginLayoutParams mlp = (MarginLayoutParams) v.getLayoutParams();
return MarginLayoutParamsCompat.getMarginStart(mlp) + MarginLayoutParamsCompat.getMarginEnd(mlp);
}
private int getVerticalMargins(View v) {
MarginLayoutParams mlp = (MarginLayoutParams) v.getLayoutParams();
return mlp.topMargin + mlp.bottomMargin;
}
public LayoutParams generateLayoutParams(AttributeSet attrs) {
return new LayoutParams(getContext(), attrs);
}
protected LayoutParams generateLayoutParams(android.view.ViewGroup.LayoutParams p) {
if (p instanceof LayoutParams) {
return new LayoutParams((LayoutParams) p);
}
if (p instanceof android.support.v7.app.ActionBar.LayoutParams) {
return new LayoutParams((android.support.v7.app.ActionBar.LayoutParams) p);
}
if (p instanceof MarginLayoutParams) {
return new LayoutParams((MarginLayoutParams) p);
}
return new LayoutParams(p);
}
protected LayoutParams generateDefaultLayoutParams() {
return new LayoutParams(-2, -2);
}
protected boolean checkLayoutParams(android.view.ViewGroup.LayoutParams p) {
return super.checkLayoutParams(p) && (p instanceof LayoutParams);
}
private static boolean isCustomView(View child) {
return ((LayoutParams) child.getLayoutParams()).mViewType == 0;
}
public DecorToolbar getWrapper() {
if (this.mWrapper == null) {
this.mWrapper = new ToolbarWidgetWrapper(this, true);
}
return this.mWrapper;
}
void removeChildrenForExpandedActionView() {
for (int i = getChildCount() - 1; i >= 0; i--) {
View child = getChildAt(i);
if (!(((LayoutParams) child.getLayoutParams()).mViewType == 2 || child == this.mMenuView)) {
removeViewAt(i);
this.mHiddenViews.add(child);
}
}
}
void addChildrenForExpandedActionView() {
for (int i = this.mHiddenViews.size() - 1; i >= 0; i--) {
addView((View) this.mHiddenViews.get(i));
}
this.mHiddenViews.clear();
}
private boolean isChildOrHidden(View child) {
return child.getParent() == this || this.mHiddenViews.contains(child);
}
public void setCollapsible(boolean collapsible) {
this.mCollapsible = collapsible;
requestLayout();
}
public void setMenuCallbacks(Callback pcb, MenuBuilder.Callback mcb) {
this.mActionMenuPresenterCallback = pcb;
this.mMenuBuilderCallback = mcb;
}
}