1731 lines
65 KiB
Java
1731 lines
65 KiB
Java
/*
|
|
* 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.
|
|
*
|
|
* <p>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.</p>
|
|
*/
|
|
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<SavedState> CREATOR =
|
|
new Parcelable.Creator<SavedState>() {
|
|
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) {
|
|
}
|
|
}
|
|
}
|