/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.widget;
import android.animation.LayoutTransition;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.ActionBar;
import android.content.Context;
import android.content.res.Configuration;
import android.content.res.TypedArray;
import android.graphics.drawable.Drawable;
import android.os.Parcel;
import android.os.Parcelable;
import android.text.Layout;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.CollapsibleActionView;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.view.Window;
import android.view.accessibility.AccessibilityEvent;
import android.widget.ActionMenuPresenter;
import android.widget.ActionMenuView;
import android.widget.AdapterView;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.Spinner;
import android.widget.SpinnerAdapter;
import android.widget.TextView;
import com.android.internal.R;
import com.android.internal.view.menu.ActionMenuItem;
import com.android.internal.view.menu.MenuBuilder;
import com.android.internal.view.menu.MenuItemImpl;
import com.android.internal.view.menu.MenuPresenter;
import com.android.internal.view.menu.MenuView;
import com.android.internal.view.menu.SubMenuBuilder;
/**
* @hide
*/
public class ActionBarView extends AbsActionBarView implements DecorToolbar {
private static final String TAG = "ActionBarView";
/**
* Display options applied by default
*/
public static final int DISPLAY_DEFAULT = 0;
/**
* Display options that require re-layout as opposed to a simple invalidate
*/
private static final int DISPLAY_RELAYOUT_MASK =
ActionBar.DISPLAY_SHOW_HOME |
ActionBar.DISPLAY_USE_LOGO |
ActionBar.DISPLAY_HOME_AS_UP |
ActionBar.DISPLAY_SHOW_CUSTOM |
ActionBar.DISPLAY_SHOW_TITLE |
ActionBar.DISPLAY_TITLE_MULTIPLE_LINES;
private static final int DEFAULT_CUSTOM_GRAVITY = Gravity.START | Gravity.CENTER_VERTICAL;
private int mNavigationMode;
private int mDisplayOptions = -1;
private CharSequence mTitle;
private CharSequence mSubtitle;
private Drawable mIcon;
private Drawable mLogo;
private CharSequence mHomeDescription;
private int mHomeDescriptionRes;
private HomeView mHomeLayout;
private HomeView mExpandedHomeLayout;
private LinearLayout mTitleLayout;
private TextView mTitleView;
private TextView mSubtitleView;
private ViewGroup mUpGoerFive;
private Spinner mSpinner;
private LinearLayout mListNavLayout;
private ScrollingTabContainerView mTabScrollView;
private View mCustomNavView;
private ProgressBar mProgressView;
private ProgressBar mIndeterminateProgressView;
private int mProgressBarPadding;
private int mItemPadding;
private final int mTitleStyleRes;
private final int mSubtitleStyleRes;
private final int mProgressStyle;
private final int mIndeterminateProgressStyle;
private boolean mUserTitle;
private boolean mIncludeTabs;
private boolean mIsCollapsible;
private boolean mWasHomeEnabled; // Was it enabled before action view expansion?
private MenuBuilder mOptionsMenu;
private boolean mMenuPrepared;
private ActionBarContextView mContextView;
private ActionMenuItem mLogoNavItem;
private SpinnerAdapter mSpinnerAdapter;
private AdapterView.OnItemSelectedListener mNavItemSelectedListener;
private Runnable mTabSelector;
private ExpandedActionViewMenuPresenter mExpandedMenuPresenter;
View mExpandedActionView;
private int mDefaultUpDescription = R.string.action_bar_up_description;
Window.Callback mWindowCallback;
private final OnClickListener mExpandedActionViewUpListener = new OnClickListener() {
@Override
public void onClick(View v) {
final MenuItemImpl item = mExpandedMenuPresenter.mCurrentExpandedItem;
if (item != null) {
item.collapseActionView();
}
}
};
private final OnClickListener mUpClickListener = new OnClickListener() {
public void onClick(View v) {
if (mMenuPrepared) {
// Only invoke the window callback if the options menu has been initialized.
mWindowCallback.onMenuItemSelected(Window.FEATURE_OPTIONS_PANEL, mLogoNavItem);
}
}
};
public ActionBarView(Context context, AttributeSet attrs) {
super(context, attrs);
// Background is always provided by the container.
setBackgroundResource(0);
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.ActionBar,
com.android.internal.R.attr.actionBarStyle, 0);
mNavigationMode = a.getInt(R.styleable.ActionBar_navigationMode,
ActionBar.NAVIGATION_MODE_STANDARD);
mTitle = a.getText(R.styleable.ActionBar_title);
mSubtitle = a.getText(R.styleable.ActionBar_subtitle);
mLogo = a.getDrawable(R.styleable.ActionBar_logo);
mIcon = a.getDrawable(R.styleable.ActionBar_icon);
final LayoutInflater inflater = LayoutInflater.from(context);
final int homeResId = a.getResourceId(
com.android.internal.R.styleable.ActionBar_homeLayout,
com.android.internal.R.layout.action_bar_home);
mUpGoerFive = (ViewGroup) inflater.inflate(
com.android.internal.R.layout.action_bar_up_container, this, false);
mHomeLayout = (HomeView) inflater.inflate(homeResId, mUpGoerFive, false);
mExpandedHomeLayout = (HomeView) inflater.inflate(homeResId, mUpGoerFive, false);
mExpandedHomeLayout.setShowUp(true);
mExpandedHomeLayout.setOnClickListener(mExpandedActionViewUpListener);
mExpandedHomeLayout.setContentDescription(getResources().getText(
mDefaultUpDescription));
// This needs to highlight/be focusable on its own.
// TODO: Clean up the handoff between expanded/normal.
final Drawable upBackground = mUpGoerFive.getBackground();
if (upBackground != null) {
mExpandedHomeLayout.setBackground(upBackground.getConstantState().newDrawable());
}
mExpandedHomeLayout.setEnabled(true);
mExpandedHomeLayout.setFocusable(true);
mTitleStyleRes = a.getResourceId(R.styleable.ActionBar_titleTextStyle, 0);
mSubtitleStyleRes = a.getResourceId(R.styleable.ActionBar_subtitleTextStyle, 0);
mProgressStyle = a.getResourceId(R.styleable.ActionBar_progressBarStyle, 0);
mIndeterminateProgressStyle = a.getResourceId(
R.styleable.ActionBar_indeterminateProgressStyle, 0);
mProgressBarPadding = a.getDimensionPixelOffset(R.styleable.ActionBar_progressBarPadding, 0);
mItemPadding = a.getDimensionPixelOffset(R.styleable.ActionBar_itemPadding, 0);
setDisplayOptions(a.getInt(R.styleable.ActionBar_displayOptions, DISPLAY_DEFAULT));
final int customNavId = a.getResourceId(R.styleable.ActionBar_customNavigationLayout, 0);
if (customNavId != 0) {
mCustomNavView = (View) inflater.inflate(customNavId, this, false);
mNavigationMode = ActionBar.NAVIGATION_MODE_STANDARD;
setDisplayOptions(mDisplayOptions | ActionBar.DISPLAY_SHOW_CUSTOM);
}
mContentHeight = a.getLayoutDimension(R.styleable.ActionBar_height, 0);
a.recycle();
mLogoNavItem = new ActionMenuItem(context, 0, android.R.id.home, 0, 0, mTitle);
mUpGoerFive.setOnClickListener(mUpClickListener);
mUpGoerFive.setClickable(true);
mUpGoerFive.setFocusable(true);
if (getImportantForAccessibility() == View.IMPORTANT_FOR_ACCESSIBILITY_AUTO) {
setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_YES);
}
}
@Override
protected void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
mTitleView = null;
mSubtitleView = null;
if (mTitleLayout != null && mTitleLayout.getParent() == mUpGoerFive) {
mUpGoerFive.removeView(mTitleLayout);
}
mTitleLayout = null;
if ((mDisplayOptions & ActionBar.DISPLAY_SHOW_TITLE) != 0) {
initTitle();
}
if (mHomeDescriptionRes != 0) {
setNavigationContentDescription(mHomeDescriptionRes);
}
if (mTabScrollView != null && mIncludeTabs) {
ViewGroup.LayoutParams lp = mTabScrollView.getLayoutParams();
if (lp != null) {
lp.width = LayoutParams.WRAP_CONTENT;
lp.height = LayoutParams.MATCH_PARENT;
}
mTabScrollView.setAllowCollapse(true);
}
}
/**
* Set the window callback used to invoke menu items; used for dispatching home button presses.
* @param cb Window callback to dispatch to
*/
public void setWindowCallback(Window.Callback cb) {
mWindowCallback = cb;
}
@Override
public void onDetachedFromWindow() {
super.onDetachedFromWindow();
removeCallbacks(mTabSelector);
if (mActionMenuPresenter != null) {
mActionMenuPresenter.hideOverflowMenu();
mActionMenuPresenter.hideSubMenus();
}
}
@Override
public boolean shouldDelayChildPressedState() {
return false;
}
public void initProgress() {
mProgressView = new ProgressBar(mContext, null, 0, mProgressStyle);
mProgressView.setId(R.id.progress_horizontal);
mProgressView.setMax(10000);
mProgressView.setVisibility(GONE);
addView(mProgressView);
}
public void initIndeterminateProgress() {
mIndeterminateProgressView = new ProgressBar(mContext, null, 0,
mIndeterminateProgressStyle);
mIndeterminateProgressView.setId(R.id.progress_circular);
mIndeterminateProgressView.setVisibility(GONE);
addView(mIndeterminateProgressView);
}
@Override
public void setSplitToolbar(boolean splitActionBar) {
if (mSplitActionBar != splitActionBar) {
if (mMenuView != null) {
final ViewGroup oldParent = (ViewGroup) mMenuView.getParent();
if (oldParent != null) {
oldParent.removeView(mMenuView);
}
if (splitActionBar) {
if (mSplitView != null) {
mSplitView.addView(mMenuView);
}
mMenuView.getLayoutParams().width = LayoutParams.MATCH_PARENT;
} else {
addView(mMenuView);
mMenuView.getLayoutParams().width = LayoutParams.WRAP_CONTENT;
}
mMenuView.requestLayout();
}
if (mSplitView != null) {
mSplitView.setVisibility(splitActionBar ? VISIBLE : GONE);
}
if (mActionMenuPresenter != null) {
if (!splitActionBar) {
mActionMenuPresenter.setExpandedActionViewsExclusive(
getResources().getBoolean(
com.android.internal.R.bool.action_bar_expanded_action_views_exclusive));
} else {
mActionMenuPresenter.setExpandedActionViewsExclusive(false);
// Allow full screen width in split mode.
mActionMenuPresenter.setWidthLimit(
getContext().getResources().getDisplayMetrics().widthPixels, true);
// No limit to the item count; use whatever will fit.
mActionMenuPresenter.setItemLimit(Integer.MAX_VALUE);
}
}
super.setSplitToolbar(splitActionBar);
}
}
public boolean isSplit() {
return mSplitActionBar;
}
public boolean canSplit() {
return true;
}
public boolean hasEmbeddedTabs() {
return mIncludeTabs;
}
@Override
public void setEmbeddedTabView(ScrollingTabContainerView tabs) {
if (mTabScrollView != null) {
removeView(mTabScrollView);
}
mTabScrollView = tabs;
mIncludeTabs = tabs != null;
if (mIncludeTabs && mNavigationMode == ActionBar.NAVIGATION_MODE_TABS) {
addView(mTabScrollView);
ViewGroup.LayoutParams lp = mTabScrollView.getLayoutParams();
lp.width = LayoutParams.WRAP_CONTENT;
lp.height = LayoutParams.MATCH_PARENT;
tabs.setAllowCollapse(true);
}
}
public void setMenuPrepared() {
mMenuPrepared = true;
}
public void setMenu(Menu menu, MenuPresenter.Callback cb) {
if (menu == mOptionsMenu) return;
if (mOptionsMenu != null) {
mOptionsMenu.removeMenuPresenter(mActionMenuPresenter);
mOptionsMenu.removeMenuPresenter(mExpandedMenuPresenter);
}
MenuBuilder builder = (MenuBuilder) menu;
mOptionsMenu = builder;
if (mMenuView != null) {
final ViewGroup oldParent = (ViewGroup) mMenuView.getParent();
if (oldParent != null) {
oldParent.removeView(mMenuView);
}
}
if (mActionMenuPresenter == null) {
mActionMenuPresenter = new ActionMenuPresenter(mContext);
mActionMenuPresenter.setCallback(cb);
mActionMenuPresenter.setId(com.android.internal.R.id.action_menu_presenter);
mExpandedMenuPresenter = new ExpandedActionViewMenuPresenter();
}
ActionMenuView menuView;
final LayoutParams layoutParams = new LayoutParams(LayoutParams.WRAP_CONTENT,
LayoutParams.MATCH_PARENT);
if (!mSplitActionBar) {
mActionMenuPresenter.setExpandedActionViewsExclusive(
getResources().getBoolean(
com.android.internal.R.bool.action_bar_expanded_action_views_exclusive));
configPresenters(builder);
menuView = (ActionMenuView) mActionMenuPresenter.getMenuView(this);
final ViewGroup oldParent = (ViewGroup) menuView.getParent();
if (oldParent != null && oldParent != this) {
oldParent.removeView(menuView);
}
addView(menuView, layoutParams);
} else {
mActionMenuPresenter.setExpandedActionViewsExclusive(false);
// Allow full screen width in split mode.
mActionMenuPresenter.setWidthLimit(
getContext().getResources().getDisplayMetrics().widthPixels, true);
// No limit to the item count; use whatever will fit.
mActionMenuPresenter.setItemLimit(Integer.MAX_VALUE);
// Span the whole width
layoutParams.width = LayoutParams.MATCH_PARENT;
layoutParams.height = LayoutParams.WRAP_CONTENT;
configPresenters(builder);
menuView = (ActionMenuView) mActionMenuPresenter.getMenuView(this);
if (mSplitView != null) {
final ViewGroup oldParent = (ViewGroup) menuView.getParent();
if (oldParent != null && oldParent != mSplitView) {
oldParent.removeView(menuView);
}
menuView.setVisibility(getAnimatedVisibility());
mSplitView.addView(menuView, layoutParams);
} else {
// We'll add this later if we missed it this time.
menuView.setLayoutParams(layoutParams);
}
}
mMenuView = menuView;
}
private void configPresenters(MenuBuilder builder) {
if (builder != null) {
builder.addMenuPresenter(mActionMenuPresenter, mPopupContext);
builder.addMenuPresenter(mExpandedMenuPresenter, mPopupContext);
} else {
mActionMenuPresenter.initForMenu(mPopupContext, null);
mExpandedMenuPresenter.initForMenu(mPopupContext, null);
mActionMenuPresenter.updateMenuView(true);
mExpandedMenuPresenter.updateMenuView(true);
}
}
public boolean hasExpandedActionView() {
return mExpandedMenuPresenter != null &&
mExpandedMenuPresenter.mCurrentExpandedItem != null;
}
public void collapseActionView() {
final MenuItemImpl item = mExpandedMenuPresenter == null ? null :
mExpandedMenuPresenter.mCurrentExpandedItem;
if (item != null) {
item.collapseActionView();
}
}
public void setCustomView(View view) {
final boolean showCustom = (mDisplayOptions & ActionBar.DISPLAY_SHOW_CUSTOM) != 0;
if (mCustomNavView != null && showCustom) {
removeView(mCustomNavView);
}
mCustomNavView = view;
if (mCustomNavView != null && showCustom) {
addView(mCustomNavView);
}
}
public CharSequence getTitle() {
return mTitle;
}
/**
* Set the action bar title. This will always replace or override window titles.
* @param title Title to set
*
* @see #setWindowTitle(CharSequence)
*/
public void setTitle(CharSequence title) {
mUserTitle = true;
setTitleImpl(title);
}
/**
* Set the window title. A window title will always be replaced or overridden by a user title.
* @param title Title to set
*
* @see #setTitle(CharSequence)
*/
public void setWindowTitle(CharSequence title) {
if (!mUserTitle) {
setTitleImpl(title);
}
}
private void setTitleImpl(CharSequence title) {
mTitle = title;
if (mTitleView != null) {
mTitleView.setText(title);
final boolean visible = mExpandedActionView == null &&
(mDisplayOptions & ActionBar.DISPLAY_SHOW_TITLE) != 0 &&
(!TextUtils.isEmpty(mTitle) || !TextUtils.isEmpty(mSubtitle));
mTitleLayout.setVisibility(visible ? VISIBLE : GONE);
}
if (mLogoNavItem != null) {
mLogoNavItem.setTitle(title);
}
updateHomeAccessibility(mUpGoerFive.isEnabled());
}
public CharSequence getSubtitle() {
return mSubtitle;
}
public void setSubtitle(CharSequence subtitle) {
mSubtitle = subtitle;
if (mSubtitleView != null) {
mSubtitleView.setText(subtitle);
mSubtitleView.setVisibility(subtitle != null ? VISIBLE : GONE);
final boolean visible = mExpandedActionView == null &&
(mDisplayOptions & ActionBar.DISPLAY_SHOW_TITLE) != 0 &&
(!TextUtils.isEmpty(mTitle) || !TextUtils.isEmpty(mSubtitle));
mTitleLayout.setVisibility(visible ? VISIBLE : GONE);
}
updateHomeAccessibility(mUpGoerFive.isEnabled());
}
public void setHomeButtonEnabled(boolean enable) {
setHomeButtonEnabled(enable, true);
}
private void setHomeButtonEnabled(boolean enable, boolean recordState) {
if (recordState) {
mWasHomeEnabled = enable;
}
if (mExpandedActionView != null) {
// There's an action view currently showing and we want to keep the state
// configured for the action view at the moment. If we needed to record the
// new state for later we will have done so above.
return;
}
mUpGoerFive.setEnabled(enable);
mUpGoerFive.setFocusable(enable);
// Make sure the home button has an accurate content description for accessibility.
updateHomeAccessibility(enable);
}
private void updateHomeAccessibility(boolean homeEnabled) {
if (!homeEnabled) {
mUpGoerFive.setContentDescription(null);
mUpGoerFive.setImportantForAccessibility(IMPORTANT_FOR_ACCESSIBILITY_NO);
} else {
mUpGoerFive.setImportantForAccessibility(IMPORTANT_FOR_ACCESSIBILITY_AUTO);
mUpGoerFive.setContentDescription(buildHomeContentDescription());
}
}
/**
* Compose a content description for the Home/Up affordance.
*
* As this encompasses the icon/logo, title and subtitle all in one, we need
* a description for the whole wad of stuff that can be localized properly.
*/
private CharSequence buildHomeContentDescription() {
final CharSequence homeDesc;
if (mHomeDescription != null) {
homeDesc = mHomeDescription;
} else {
if ((mDisplayOptions & ActionBar.DISPLAY_HOME_AS_UP) != 0) {
homeDesc = mContext.getResources().getText(mDefaultUpDescription);
} else {
homeDesc = mContext.getResources().getText(R.string.action_bar_home_description);
}
}
final CharSequence title = getTitle();
final CharSequence subtitle = getSubtitle();
if (!TextUtils.isEmpty(title)) {
final String result;
if (!TextUtils.isEmpty(subtitle)) {
result = getResources().getString(
R.string.action_bar_home_subtitle_description_format,
title, subtitle, homeDesc);
} else {
result = getResources().getString(R.string.action_bar_home_description_format,
title, homeDesc);
}
return result;
}
return homeDesc;
}
public void setDisplayOptions(int options) {
final int flagsChanged = mDisplayOptions == -1 ? -1 : options ^ mDisplayOptions;
mDisplayOptions = options;
if ((flagsChanged & DISPLAY_RELAYOUT_MASK) != 0) {
if ((flagsChanged & ActionBar.DISPLAY_HOME_AS_UP) != 0) {
final boolean setUp = (options & ActionBar.DISPLAY_HOME_AS_UP) != 0;
mHomeLayout.setShowUp(setUp);
// Showing home as up implicitly enables interaction with it.
// In honeycomb it was always enabled, so make this transition
// a bit easier for developers in the common case.
// (It would be silly to show it as up without responding to it.)
if (setUp) {
setHomeButtonEnabled(true);
}
}
if ((flagsChanged & ActionBar.DISPLAY_USE_LOGO) != 0) {
final boolean logoVis = mLogo != null && (options & ActionBar.DISPLAY_USE_LOGO) != 0;
mHomeLayout.setIcon(logoVis ? mLogo : mIcon);
}
if ((flagsChanged & ActionBar.DISPLAY_SHOW_TITLE) != 0) {
if ((options & ActionBar.DISPLAY_SHOW_TITLE) != 0) {
initTitle();
} else {
mUpGoerFive.removeView(mTitleLayout);
}
}
final boolean showHome = (options & ActionBar.DISPLAY_SHOW_HOME) != 0;
final boolean homeAsUp = (mDisplayOptions & ActionBar.DISPLAY_HOME_AS_UP) != 0;
final boolean titleUp = !showHome && homeAsUp;
mHomeLayout.setShowIcon(showHome);
final int homeVis = (showHome || titleUp) && mExpandedActionView == null ?
VISIBLE : GONE;
mHomeLayout.setVisibility(homeVis);
if ((flagsChanged & ActionBar.DISPLAY_SHOW_CUSTOM) != 0 && mCustomNavView != null) {
if ((options & ActionBar.DISPLAY_SHOW_CUSTOM) != 0) {
addView(mCustomNavView);
} else {
removeView(mCustomNavView);
}
}
if (mTitleLayout != null &&
(flagsChanged & ActionBar.DISPLAY_TITLE_MULTIPLE_LINES) != 0) {
if ((options & ActionBar.DISPLAY_TITLE_MULTIPLE_LINES) != 0) {
mTitleView.setSingleLine(false);
mTitleView.setMaxLines(2);
} else {
mTitleView.setMaxLines(1);
mTitleView.setSingleLine(true);
}
}
requestLayout();
} else {
invalidate();
}
// Make sure the home button has an accurate content description for accessibility.
updateHomeAccessibility(mUpGoerFive.isEnabled());
}
public void setIcon(Drawable icon) {
mIcon = icon;
if (icon != null &&
((mDisplayOptions & ActionBar.DISPLAY_USE_LOGO) == 0 || mLogo == null)) {
mHomeLayout.setIcon(icon);
}
if (mExpandedActionView != null) {
mExpandedHomeLayout.setIcon(mIcon.getConstantState().newDrawable(getResources()));
}
}
public void setIcon(int resId) {
setIcon(resId != 0 ? mContext.getDrawable(resId) : null);
}
public boolean hasIcon() {
return mIcon != null;
}
public void setLogo(Drawable logo) {
mLogo = logo;
if (logo != null && (mDisplayOptions & ActionBar.DISPLAY_USE_LOGO) != 0) {
mHomeLayout.setIcon(logo);
}
}
public void setLogo(int resId) {
setLogo(resId != 0 ? mContext.getDrawable(resId) : null);
}
public boolean hasLogo() {
return mLogo != null;
}
public void setNavigationMode(int mode) {
final int oldMode = mNavigationMode;
if (mode != oldMode) {
switch (oldMode) {
case ActionBar.NAVIGATION_MODE_LIST:
if (mListNavLayout != null) {
removeView(mListNavLayout);
}
break;
case ActionBar.NAVIGATION_MODE_TABS:
if (mTabScrollView != null && mIncludeTabs) {
removeView(mTabScrollView);
}
}
switch (mode) {
case ActionBar.NAVIGATION_MODE_LIST:
if (mSpinner == null) {
mSpinner = new Spinner(mContext, null,
com.android.internal.R.attr.actionDropDownStyle);
mSpinner.setId(com.android.internal.R.id.action_bar_spinner);
mListNavLayout = new LinearLayout(mContext, null,
com.android.internal.R.attr.actionBarTabBarStyle);
LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
params.gravity = Gravity.CENTER;
mListNavLayout.addView(mSpinner, params);
}
if (mSpinner.getAdapter() != mSpinnerAdapter) {
mSpinner.setAdapter(mSpinnerAdapter);
}
mSpinner.setOnItemSelectedListener(mNavItemSelectedListener);
addView(mListNavLayout);
break;
case ActionBar.NAVIGATION_MODE_TABS:
if (mTabScrollView != null && mIncludeTabs) {
addView(mTabScrollView);
}
break;
}
mNavigationMode = mode;
requestLayout();
}
}
public void setDropdownParams(SpinnerAdapter adapter, AdapterView.OnItemSelectedListener l) {
mSpinnerAdapter = adapter;
mNavItemSelectedListener = l;
if (mSpinner != null) {
mSpinner.setAdapter(adapter);
mSpinner.setOnItemSelectedListener(l);
}
}
public int getDropdownItemCount() {
return mSpinnerAdapter != null ? mSpinnerAdapter.getCount() : 0;
}
public void setDropdownSelectedPosition(int position) {
mSpinner.setSelection(position);
}
public int getDropdownSelectedPosition() {
return mSpinner.getSelectedItemPosition();
}
public View getCustomView() {
return mCustomNavView;
}
public int getNavigationMode() {
return mNavigationMode;
}
public int getDisplayOptions() {
return mDisplayOptions;
}
@Override
public ViewGroup getViewGroup() {
return this;
}
@Override
protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
// Used by custom nav views if they don't supply layout params. Everything else
// added to an ActionBarView should have them already.
return new ActionBar.LayoutParams(DEFAULT_CUSTOM_GRAVITY);
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
mUpGoerFive.addView(mHomeLayout, 0);
addView(mUpGoerFive);
if (mCustomNavView != null && (mDisplayOptions & ActionBar.DISPLAY_SHOW_CUSTOM) != 0) {
final ViewParent parent = mCustomNavView.getParent();
if (parent != this) {
if (parent instanceof ViewGroup) {
((ViewGroup) parent).removeView(mCustomNavView);
}
addView(mCustomNavView);
}
}
}
private void initTitle() {
if (mTitleLayout == null) {
LayoutInflater inflater = LayoutInflater.from(getContext());
mTitleLayout = (LinearLayout) inflater.inflate(R.layout.action_bar_title_item,
this, false);
mTitleView = (TextView) mTitleLayout.findViewById(R.id.action_bar_title);
mSubtitleView = (TextView) mTitleLayout.findViewById(R.id.action_bar_subtitle);
if (mTitleStyleRes != 0) {
mTitleView.setTextAppearance(mTitleStyleRes);
}
if (mTitle != null) {
mTitleView.setText(mTitle);
}
if (mSubtitleStyleRes != 0) {
mSubtitleView.setTextAppearance(mSubtitleStyleRes);
}
if (mSubtitle != null) {
mSubtitleView.setText(mSubtitle);
mSubtitleView.setVisibility(VISIBLE);
}
}
mUpGoerFive.addView(mTitleLayout);
if (mExpandedActionView != null ||
(TextUtils.isEmpty(mTitle) && TextUtils.isEmpty(mSubtitle))) {
// Don't show while in expanded mode or with empty text
mTitleLayout.setVisibility(GONE);
} else {
mTitleLayout.setVisibility(VISIBLE);
}
}
public void setContextView(ActionBarContextView view) {
mContextView = view;
}
public void setCollapsible(boolean collapsible) {
mIsCollapsible = collapsible;
}
/**
* @return True if any characters in the title were truncated
*/
public boolean isTitleTruncated() {
if (mTitleView == null) {
return false;
}
final Layout titleLayout = mTitleView.getLayout();
if (titleLayout == null) {
return false;
}
final int lineCount = titleLayout.getLineCount();
for (int i = 0; i < lineCount; i++) {
if (titleLayout.getEllipsisCount(i) > 0) {
return true;
}
}
return false;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
final int childCount = getChildCount();
if (mIsCollapsible) {
int visibleChildren = 0;
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE &&
!(child == mMenuView && mMenuView.getChildCount() == 0) &&
child != mUpGoerFive) {
visibleChildren++;
}
}
final int upChildCount = mUpGoerFive.getChildCount();
for (int i = 0; i < upChildCount; i++) {
final View child = mUpGoerFive.getChildAt(i);
if (child.getVisibility() != GONE) {
visibleChildren++;
}
}
if (visibleChildren == 0) {
// No size for an empty action bar when collapsable.
setMeasuredDimension(0, 0);
return;
}
}
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
if (widthMode != MeasureSpec.EXACTLY) {
throw new IllegalStateException(getClass().getSimpleName() + " can only be used " +
"with android:layout_width=\"match_parent\" (or fill_parent)");
}
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
if (heightMode != MeasureSpec.AT_MOST) {
throw new IllegalStateException(getClass().getSimpleName() + " can only be used " +
"with android:layout_height=\"wrap_content\"");
}
int contentWidth = MeasureSpec.getSize(widthMeasureSpec);
int maxHeight = mContentHeight >= 0 ?
mContentHeight : MeasureSpec.getSize(heightMeasureSpec);
final int verticalPadding = getPaddingTop() + getPaddingBottom();
final int paddingLeft = getPaddingLeft();
final int paddingRight = getPaddingRight();
final int height = maxHeight - verticalPadding;
final int childSpecHeight = MeasureSpec.makeMeasureSpec(height, MeasureSpec.AT_MOST);
final int exactHeightSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
int availableWidth = contentWidth - paddingLeft - paddingRight;
int leftOfCenter = availableWidth / 2;
int rightOfCenter = leftOfCenter;
final boolean showTitle = mTitleLayout != null && mTitleLayout.getVisibility() != GONE &&
(mDisplayOptions & ActionBar.DISPLAY_SHOW_TITLE) != 0;
HomeView homeLayout = mExpandedActionView != null ? mExpandedHomeLayout : mHomeLayout;
final ViewGroup.LayoutParams homeLp = homeLayout.getLayoutParams();
int homeWidthSpec;
if (homeLp.width < 0) {
homeWidthSpec = MeasureSpec.makeMeasureSpec(availableWidth, MeasureSpec.AT_MOST);
} else {
homeWidthSpec = MeasureSpec.makeMeasureSpec(homeLp.width, MeasureSpec.EXACTLY);
}
/*
* This is a little weird.
* We're only measuring the *home* affordance within the Up container here
* on purpose, because we want to give the available space to all other views before
* the title text. We'll remeasure the whole up container again later.
* We need to measure this container so we know the right offset for the up affordance
* no matter what.
*/
homeLayout.measure(homeWidthSpec, exactHeightSpec);
int homeWidth = 0;
if ((homeLayout.getVisibility() != GONE && homeLayout.getParent() == mUpGoerFive)
|| showTitle) {
homeWidth = homeLayout.getMeasuredWidth();
final int homeOffsetWidth = homeWidth + homeLayout.getStartOffset();
availableWidth = Math.max(0, availableWidth - homeOffsetWidth);
leftOfCenter = Math.max(0, availableWidth - homeOffsetWidth);
}
if (mMenuView != null && mMenuView.getParent() == this) {
availableWidth = measureChildView(mMenuView, availableWidth, exactHeightSpec, 0);
rightOfCenter = Math.max(0, rightOfCenter - mMenuView.getMeasuredWidth());
}
if (mIndeterminateProgressView != null &&
mIndeterminateProgressView.getVisibility() != GONE) {
availableWidth = measureChildView(mIndeterminateProgressView, availableWidth,
childSpecHeight, 0);
rightOfCenter = Math.max(0,
rightOfCenter - mIndeterminateProgressView.getMeasuredWidth());
}
if (mExpandedActionView == null) {
switch (mNavigationMode) {
case ActionBar.NAVIGATION_MODE_LIST:
if (mListNavLayout != null) {
final int itemPaddingSize = showTitle ? mItemPadding * 2 : mItemPadding;
availableWidth = Math.max(0, availableWidth - itemPaddingSize);
leftOfCenter = Math.max(0, leftOfCenter - itemPaddingSize);
mListNavLayout.measure(
MeasureSpec.makeMeasureSpec(availableWidth, MeasureSpec.AT_MOST),
MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));
final int listNavWidth = mListNavLayout.getMeasuredWidth();
availableWidth = Math.max(0, availableWidth - listNavWidth);
leftOfCenter = Math.max(0, leftOfCenter - listNavWidth);
}
break;
case ActionBar.NAVIGATION_MODE_TABS:
if (mTabScrollView != null) {
final int itemPaddingSize = showTitle ? mItemPadding * 2 : mItemPadding;
availableWidth = Math.max(0, availableWidth - itemPaddingSize);
leftOfCenter = Math.max(0, leftOfCenter - itemPaddingSize);
mTabScrollView.measure(
MeasureSpec.makeMeasureSpec(availableWidth, MeasureSpec.AT_MOST),
MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));
final int tabWidth = mTabScrollView.getMeasuredWidth();
availableWidth = Math.max(0, availableWidth - tabWidth);
leftOfCenter = Math.max(0, leftOfCenter - tabWidth);
}
break;
}
}
View customView = null;
if (mExpandedActionView != null) {
customView = mExpandedActionView;
} else if ((mDisplayOptions & ActionBar.DISPLAY_SHOW_CUSTOM) != 0 &&
mCustomNavView != null) {
customView = mCustomNavView;
}
if (customView != null) {
final ViewGroup.LayoutParams lp = generateLayoutParams(customView.getLayoutParams());
final ActionBar.LayoutParams ablp = lp instanceof ActionBar.LayoutParams ?
(ActionBar.LayoutParams) lp : null;
int horizontalMargin = 0;
int verticalMargin = 0;
if (ablp != null) {
horizontalMargin = ablp.leftMargin + ablp.rightMargin;
verticalMargin = ablp.topMargin + ablp.bottomMargin;
}
// If the action bar is wrapping to its content height, don't allow a custom
// view to MATCH_PARENT.
int customNavHeightMode;
if (mContentHeight <= 0) {
customNavHeightMode = MeasureSpec.AT_MOST;
} else {
customNavHeightMode = lp.height != LayoutParams.WRAP_CONTENT ?
MeasureSpec.EXACTLY : MeasureSpec.AT_MOST;
}
final int customNavHeight = Math.max(0,
(lp.height >= 0 ? Math.min(lp.height, height) : height) - verticalMargin);
final int customNavWidthMode = lp.width != LayoutParams.WRAP_CONTENT ?
MeasureSpec.EXACTLY : MeasureSpec.AT_MOST;
int customNavWidth = Math.max(0,
(lp.width >= 0 ? Math.min(lp.width, availableWidth) : availableWidth)
- horizontalMargin);
final int hgrav = (ablp != null ? ablp.gravity : DEFAULT_CUSTOM_GRAVITY) &
Gravity.HORIZONTAL_GRAVITY_MASK;
// Centering a custom view is treated specially; we try to center within the whole
// action bar rather than in the available space.
if (hgrav == Gravity.CENTER_HORIZONTAL && lp.width == LayoutParams.MATCH_PARENT) {
customNavWidth = Math.min(leftOfCenter, rightOfCenter) * 2;
}
customView.measure(
MeasureSpec.makeMeasureSpec(customNavWidth, customNavWidthMode),
MeasureSpec.makeMeasureSpec(customNavHeight, customNavHeightMode));
availableWidth -= horizontalMargin + customView.getMeasuredWidth();
}
/*
* Measure the whole up container now, allowing for the full home+title sections.
* (This will re-measure the home view.)
*/
availableWidth = measureChildView(mUpGoerFive, availableWidth + homeWidth,
MeasureSpec.makeMeasureSpec(mContentHeight, MeasureSpec.EXACTLY), 0);
if (mTitleLayout != null) {
leftOfCenter = Math.max(0, leftOfCenter - mTitleLayout.getMeasuredWidth());
}
if (mContentHeight <= 0) {
int measuredHeight = 0;
for (int i = 0; i < childCount; i++) {
View v = getChildAt(i);
int paddedViewHeight = v.getMeasuredHeight() + verticalPadding;
if (paddedViewHeight > measuredHeight) {
measuredHeight = paddedViewHeight;
}
}
setMeasuredDimension(contentWidth, measuredHeight);
} else {
setMeasuredDimension(contentWidth, maxHeight);
}
if (mContextView != null) {
mContextView.setContentHeight(getMeasuredHeight());
}
if (mProgressView != null && mProgressView.getVisibility() != GONE) {
mProgressView.measure(MeasureSpec.makeMeasureSpec(
contentWidth - mProgressBarPadding * 2, MeasureSpec.EXACTLY),
MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.AT_MOST));
}
}
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
final int contentHeight = b - t - getPaddingTop() - getPaddingBottom();
if (contentHeight <= 0) {
// Nothing to do if we can't see anything.
return;
}
final boolean isLayoutRtl = isLayoutRtl();
final int direction = isLayoutRtl ? 1 : -1;
int menuStart = isLayoutRtl ? getPaddingLeft() : r - l - getPaddingRight();
// In LTR mode, we start from left padding and go to the right; in RTL mode, we start
// from the padding right and go to the left (in reverse way)
int x = isLayoutRtl ? r - l - getPaddingRight() : getPaddingLeft();
final int y = getPaddingTop();
HomeView homeLayout = mExpandedActionView != null ? mExpandedHomeLayout : mHomeLayout;
final boolean showTitle = mTitleLayout != null && mTitleLayout.getVisibility() != GONE &&
(mDisplayOptions & ActionBar.DISPLAY_SHOW_TITLE) != 0;
int startOffset = 0;
if (homeLayout.getParent() == mUpGoerFive) {
if (homeLayout.getVisibility() != GONE) {
startOffset = homeLayout.getStartOffset();
} else if (showTitle) {
startOffset = homeLayout.getUpWidth();
}
}
// Position the up container based on where the edge of the home layout should go.
x += positionChild(mUpGoerFive,
next(x, startOffset, isLayoutRtl), y, contentHeight, isLayoutRtl);
x = next(x, startOffset, isLayoutRtl);
if (mExpandedActionView == null) {
switch (mNavigationMode) {
case ActionBar.NAVIGATION_MODE_STANDARD:
break;
case ActionBar.NAVIGATION_MODE_LIST:
if (mListNavLayout != null) {
if (showTitle) {
x = next(x, mItemPadding, isLayoutRtl);
}
x += positionChild(mListNavLayout, x, y, contentHeight, isLayoutRtl);
x = next(x, mItemPadding, isLayoutRtl);
}
break;
case ActionBar.NAVIGATION_MODE_TABS:
if (mTabScrollView != null) {
if (showTitle) x = next(x, mItemPadding, isLayoutRtl);
x += positionChild(mTabScrollView, x, y, contentHeight, isLayoutRtl);
x = next(x, mItemPadding, isLayoutRtl);
}
break;
}
}
if (mMenuView != null && mMenuView.getParent() == this) {
positionChild(mMenuView, menuStart, y, contentHeight, !isLayoutRtl);
menuStart += direction * mMenuView.getMeasuredWidth();
}
if (mIndeterminateProgressView != null &&
mIndeterminateProgressView.getVisibility() != GONE) {
positionChild(mIndeterminateProgressView, menuStart, y, contentHeight, !isLayoutRtl);
menuStart += direction * mIndeterminateProgressView.getMeasuredWidth();
}
View customView = null;
if (mExpandedActionView != null) {
customView = mExpandedActionView;
} else if ((mDisplayOptions & ActionBar.DISPLAY_SHOW_CUSTOM) != 0 &&
mCustomNavView != null) {
customView = mCustomNavView;
}
if (customView != null) {
final int layoutDirection = getLayoutDirection();
ViewGroup.LayoutParams lp = customView.getLayoutParams();
final ActionBar.LayoutParams ablp = lp instanceof ActionBar.LayoutParams ?
(ActionBar.LayoutParams) lp : null;
final int gravity = ablp != null ? ablp.gravity : DEFAULT_CUSTOM_GRAVITY;
final int navWidth = customView.getMeasuredWidth();
int topMargin = 0;
int bottomMargin = 0;
if (ablp != null) {
x = next(x, ablp.getMarginStart(), isLayoutRtl);
menuStart += direction * ablp.getMarginEnd();
topMargin = ablp.topMargin;
bottomMargin = ablp.bottomMargin;
}
int hgravity = gravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;
// See if we actually have room to truly center; if not push against left or right.
if (hgravity == Gravity.CENTER_HORIZONTAL) {
final int centeredLeft = ((mRight - mLeft) - navWidth) / 2;
if (isLayoutRtl) {
final int centeredStart = centeredLeft + navWidth;
final int centeredEnd = centeredLeft;
if (centeredStart > x) {
hgravity = Gravity.RIGHT;
} else if (centeredEnd < menuStart) {
hgravity = Gravity.LEFT;
}
} else {
final int centeredStart = centeredLeft;
final int centeredEnd = centeredLeft + navWidth;
if (centeredStart < x) {
hgravity = Gravity.LEFT;
} else if (centeredEnd > menuStart) {
hgravity = Gravity.RIGHT;
}
}
} else if (gravity == Gravity.NO_GRAVITY) {
hgravity = Gravity.START;
}
int xpos = 0;
switch (Gravity.getAbsoluteGravity(hgravity, layoutDirection)) {
case Gravity.CENTER_HORIZONTAL:
xpos = ((mRight - mLeft) - navWidth) / 2;
break;
case Gravity.LEFT:
xpos = isLayoutRtl ? menuStart : x;
break;
case Gravity.RIGHT:
xpos = isLayoutRtl ? x - navWidth : menuStart - navWidth;
break;
}
int vgravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;
if (gravity == Gravity.NO_GRAVITY) {
vgravity = Gravity.CENTER_VERTICAL;
}
int ypos = 0;
switch (vgravity) {
case Gravity.CENTER_VERTICAL:
final int paddedTop = getPaddingTop();
final int paddedBottom = mBottom - mTop - getPaddingBottom();
ypos = ((paddedBottom - paddedTop) - customView.getMeasuredHeight()) / 2;
break;
case Gravity.TOP:
ypos = getPaddingTop() + topMargin;
break;
case Gravity.BOTTOM:
ypos = getHeight() - getPaddingBottom() - customView.getMeasuredHeight()
- bottomMargin;
break;
}
final int customWidth = customView.getMeasuredWidth();
customView.layout(xpos, ypos, xpos + customWidth,
ypos + customView.getMeasuredHeight());
x = next(x, customWidth, isLayoutRtl);
}
if (mProgressView != null) {
mProgressView.bringToFront();
final int halfProgressHeight = mProgressView.getMeasuredHeight() / 2;
mProgressView.layout(mProgressBarPadding, -halfProgressHeight,
mProgressBarPadding + mProgressView.getMeasuredWidth(), halfProgressHeight);
}
}
@Override
public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
return new ActionBar.LayoutParams(getContext(), attrs);
}
@Override
public ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams lp) {
if (lp == null) {
lp = generateDefaultLayoutParams();
}
return lp;
}
@Override
public Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
SavedState state = new SavedState(superState);
if (mExpandedMenuPresenter != null && mExpandedMenuPresenter.mCurrentExpandedItem != null) {
state.expandedMenuItemId = mExpandedMenuPresenter.mCurrentExpandedItem.getItemId();
}
state.isOverflowOpen = isOverflowMenuShowing();
return state;
}
@Override
public void onRestoreInstanceState(Parcelable p) {
SavedState state = (SavedState) p;
super.onRestoreInstanceState(state.getSuperState());
if (state.expandedMenuItemId != 0 &&
mExpandedMenuPresenter != null && mOptionsMenu != null) {
final MenuItem item = mOptionsMenu.findItem(state.expandedMenuItemId);
if (item != null) {
item.expandActionView();
}
}
if (state.isOverflowOpen) {
postShowOverflowMenu();
}
}
public void setNavigationIcon(Drawable indicator) {
mHomeLayout.setUpIndicator(indicator);
}
@Override
public void setDefaultNavigationIcon(Drawable icon) {
mHomeLayout.setDefaultUpIndicator(icon);
}
public void setNavigationIcon(int resId) {
mHomeLayout.setUpIndicator(resId);
}
public void setNavigationContentDescription(CharSequence description) {
mHomeDescription = description;
updateHomeAccessibility(mUpGoerFive.isEnabled());
}
public void setNavigationContentDescription(int resId) {
mHomeDescriptionRes = resId;
mHomeDescription = resId != 0 ? getResources().getText(resId) : null;
updateHomeAccessibility(mUpGoerFive.isEnabled());
}
@Override
public void setDefaultNavigationContentDescription(int defaultNavigationContentDescription) {
if (mDefaultUpDescription == defaultNavigationContentDescription) {
return;
}
mDefaultUpDescription = defaultNavigationContentDescription;
updateHomeAccessibility(mUpGoerFive.isEnabled());
}
@Override
public void setMenuCallbacks(MenuPresenter.Callback presenterCallback,
MenuBuilder.Callback menuBuilderCallback) {
if (mActionMenuPresenter != null) {
mActionMenuPresenter.setCallback(presenterCallback);
}
if (mOptionsMenu != null) {
mOptionsMenu.setCallback(menuBuilderCallback);
}
}
@Override
public Menu getMenu() {
return mOptionsMenu;
}
static class SavedState extends BaseSavedState {
int expandedMenuItemId;
boolean isOverflowOpen;
SavedState(Parcelable superState) {
super(superState);
}
private SavedState(Parcel in) {
super(in);
expandedMenuItemId = in.readInt();
isOverflowOpen = in.readInt() != 0;
}
@Override
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeInt(expandedMenuItemId);
out.writeInt(isOverflowOpen ? 1 : 0);
}
public static final Parcelable.Creator CREATOR =
new Parcelable.Creator() {
public SavedState createFromParcel(Parcel in) {
return new SavedState(in);
}
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
}
private static class HomeView extends FrameLayout {
private ImageView mUpView;
private ImageView mIconView;
private int mUpWidth;
private int mStartOffset;
private int mUpIndicatorRes;
private Drawable mDefaultUpIndicator;
private Drawable mUpIndicator;
private static final long DEFAULT_TRANSITION_DURATION = 150;
public HomeView(Context context) {
this(context, null);
}
public HomeView(Context context, AttributeSet attrs) {
super(context, attrs);
LayoutTransition t = getLayoutTransition();
if (t != null) {
// Set a lower duration than the default
t.setDuration(DEFAULT_TRANSITION_DURATION);
}
}
public void setShowUp(boolean isUp) {
mUpView.setVisibility(isUp ? VISIBLE : GONE);
}
public void setShowIcon(boolean showIcon) {
mIconView.setVisibility(showIcon ? VISIBLE : GONE);
}
public void setIcon(Drawable icon) {
mIconView.setImageDrawable(icon);
}
public void setUpIndicator(Drawable d) {
mUpIndicator = d;
mUpIndicatorRes = 0;
updateUpIndicator();
}
public void setDefaultUpIndicator(Drawable d) {
mDefaultUpIndicator = d;
updateUpIndicator();
}
public void setUpIndicator(int resId) {
mUpIndicatorRes = resId;
mUpIndicator = null;
updateUpIndicator();
}
private void updateUpIndicator() {
if (mUpIndicator != null) {
mUpView.setImageDrawable(mUpIndicator);
} else if (mUpIndicatorRes != 0) {
mUpView.setImageDrawable(getContext().getDrawable(mUpIndicatorRes));
} else {
mUpView.setImageDrawable(mDefaultUpIndicator);
}
}
@Override
protected void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
if (mUpIndicatorRes != 0) {
// Reload for config change
updateUpIndicator();
}
}
@Override
public boolean dispatchPopulateAccessibilityEventInternal(AccessibilityEvent event) {
onPopulateAccessibilityEvent(event);
return true;
}
@Override
public void onPopulateAccessibilityEventInternal(AccessibilityEvent event) {
super.onPopulateAccessibilityEventInternal(event);
final CharSequence cdesc = getContentDescription();
if (!TextUtils.isEmpty(cdesc)) {
event.getText().add(cdesc);
}
}
@Override
public boolean dispatchHoverEvent(MotionEvent event) {
// Don't allow children to hover; we want this to be treated as a single component.
return onHoverEvent(event);
}
@Override
protected void onFinishInflate() {
mUpView = (ImageView) findViewById(com.android.internal.R.id.up);
mIconView = (ImageView) findViewById(com.android.internal.R.id.home);
mDefaultUpIndicator = mUpView.getDrawable();
}
public int getStartOffset() {
return mUpView.getVisibility() == GONE ? mStartOffset : 0;
}
public int getUpWidth() {
return mUpWidth;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
measureChildWithMargins(mUpView, widthMeasureSpec, 0, heightMeasureSpec, 0);
final LayoutParams upLp = (LayoutParams) mUpView.getLayoutParams();
final int upMargins = upLp.leftMargin + upLp.rightMargin;
mUpWidth = mUpView.getMeasuredWidth();
mStartOffset = mUpWidth + upMargins;
int width = mUpView.getVisibility() == GONE ? 0 : mStartOffset;
int height = upLp.topMargin + mUpView.getMeasuredHeight() + upLp.bottomMargin;
if (mIconView.getVisibility() != GONE) {
measureChildWithMargins(mIconView, widthMeasureSpec, width, heightMeasureSpec, 0);
final LayoutParams iconLp = (LayoutParams) mIconView.getLayoutParams();
width += iconLp.leftMargin + mIconView.getMeasuredWidth() + iconLp.rightMargin;
height = Math.max(height,
iconLp.topMargin + mIconView.getMeasuredHeight() + iconLp.bottomMargin);
} else if (upMargins < 0) {
// Remove the measurement effects of negative margins used for offsets
width -= upMargins;
}
final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
final int widthSize = MeasureSpec.getSize(widthMeasureSpec);
final int heightSize = MeasureSpec.getSize(heightMeasureSpec);
switch (widthMode) {
case MeasureSpec.AT_MOST:
width = Math.min(width, widthSize);
break;
case MeasureSpec.EXACTLY:
width = widthSize;
break;
case MeasureSpec.UNSPECIFIED:
default:
break;
}
switch (heightMode) {
case MeasureSpec.AT_MOST:
height = Math.min(height, heightSize);
break;
case MeasureSpec.EXACTLY:
height = heightSize;
break;
case MeasureSpec.UNSPECIFIED:
default:
break;
}
setMeasuredDimension(width, height);
}
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
final int vCenter = (b - t) / 2;
final boolean isLayoutRtl = isLayoutRtl();
final int width = getWidth();
int upOffset = 0;
if (mUpView.getVisibility() != GONE) {
final LayoutParams upLp = (LayoutParams) mUpView.getLayoutParams();
final int upHeight = mUpView.getMeasuredHeight();
final int upWidth = mUpView.getMeasuredWidth();
upOffset = upLp.leftMargin + upWidth + upLp.rightMargin;
final int upTop = vCenter - upHeight / 2;
final int upBottom = upTop + upHeight;
final int upRight;
final int upLeft;
if (isLayoutRtl) {
upRight = width;
upLeft = upRight - upWidth;
r -= upOffset;
} else {
upRight = upWidth;
upLeft = 0;
l += upOffset;
}
mUpView.layout(upLeft, upTop, upRight, upBottom);
}
final LayoutParams iconLp = (LayoutParams) mIconView.getLayoutParams();
final int iconHeight = mIconView.getMeasuredHeight();
final int iconWidth = mIconView.getMeasuredWidth();
final int hCenter = (r - l) / 2;
final int iconTop = Math.max(iconLp.topMargin, vCenter - iconHeight / 2);
final int iconBottom = iconTop + iconHeight;
final int iconLeft;
final int iconRight;
int marginStart = iconLp.getMarginStart();
final int delta = Math.max(marginStart, hCenter - iconWidth / 2);
if (isLayoutRtl) {
iconRight = width - upOffset - delta;
iconLeft = iconRight - iconWidth;
} else {
iconLeft = upOffset + delta;
iconRight = iconLeft + iconWidth;
}
mIconView.layout(iconLeft, iconTop, iconRight, iconBottom);
}
}
private class ExpandedActionViewMenuPresenter implements MenuPresenter {
MenuBuilder mMenu;
MenuItemImpl mCurrentExpandedItem;
@Override
public void initForMenu(@NonNull Context context, @Nullable MenuBuilder menu) {
// Clear the expanded action view when menus change.
if (mMenu != null && mCurrentExpandedItem != null) {
mMenu.collapseItemActionView(mCurrentExpandedItem);
}
mMenu = menu;
}
@Override
public MenuView getMenuView(ViewGroup root) {
return null;
}
@Override
public void updateMenuView(boolean cleared) {
// Make sure the expanded item we have is still there.
if (mCurrentExpandedItem != null) {
boolean found = false;
if (mMenu != null) {
final int count = mMenu.size();
for (int i = 0; i < count; i++) {
final MenuItem item = mMenu.getItem(i);
if (item == mCurrentExpandedItem) {
found = true;
break;
}
}
}
if (!found) {
// The item we had expanded disappeared. Collapse.
collapseItemActionView(mMenu, mCurrentExpandedItem);
}
}
}
@Override
public void setCallback(Callback cb) {
}
@Override
public boolean onSubMenuSelected(SubMenuBuilder subMenu) {
return false;
}
@Override
public void onCloseMenu(MenuBuilder menu, boolean allMenusAreClosing) {
}
@Override
public boolean flagActionItems() {
return false;
}
@Override
public boolean expandItemActionView(MenuBuilder menu, MenuItemImpl item) {
mExpandedActionView = item.getActionView();
mExpandedHomeLayout.setIcon(mIcon.getConstantState().newDrawable(getResources()));
mCurrentExpandedItem = item;
if (mExpandedActionView.getParent() != ActionBarView.this) {
addView(mExpandedActionView);
}
if (mExpandedHomeLayout.getParent() != mUpGoerFive) {
mUpGoerFive.addView(mExpandedHomeLayout);
}
mHomeLayout.setVisibility(GONE);
if (mTitleLayout != null) mTitleLayout.setVisibility(GONE);
if (mTabScrollView != null) mTabScrollView.setVisibility(GONE);
if (mSpinner != null) mSpinner.setVisibility(GONE);
if (mCustomNavView != null) mCustomNavView.setVisibility(GONE);
setHomeButtonEnabled(false, false);
requestLayout();
item.setActionViewExpanded(true);
if (mExpandedActionView instanceof CollapsibleActionView) {
((CollapsibleActionView) mExpandedActionView).onActionViewExpanded();
}
return true;
}
@Override
public boolean collapseItemActionView(MenuBuilder menu, MenuItemImpl item) {
// Do this before detaching the actionview from the hierarchy, in case
// it needs to dismiss the soft keyboard, etc.
if (mExpandedActionView instanceof CollapsibleActionView) {
((CollapsibleActionView) mExpandedActionView).onActionViewCollapsed();
}
removeView(mExpandedActionView);
mUpGoerFive.removeView(mExpandedHomeLayout);
mExpandedActionView = null;
if ((mDisplayOptions & ActionBar.DISPLAY_SHOW_HOME) != 0) {
mHomeLayout.setVisibility(VISIBLE);
}
if ((mDisplayOptions & ActionBar.DISPLAY_SHOW_TITLE) != 0) {
if (mTitleLayout == null) {
initTitle();
} else {
mTitleLayout.setVisibility(VISIBLE);
}
}
if (mTabScrollView != null) mTabScrollView.setVisibility(VISIBLE);
if (mSpinner != null) mSpinner.setVisibility(VISIBLE);
if (mCustomNavView != null) mCustomNavView.setVisibility(VISIBLE);
mExpandedHomeLayout.setIcon(null);
mCurrentExpandedItem = null;
setHomeButtonEnabled(mWasHomeEnabled); // Set by expandItemActionView above
requestLayout();
item.setActionViewExpanded(false);
return true;
}
@Override
public int getId() {
return 0;
}
@Override
public Parcelable onSaveInstanceState() {
return null;
}
@Override
public void onRestoreInstanceState(Parcelable state) {
}
}
}