743 lines
21 KiB
Java
743 lines
21 KiB
Java
/*
|
|
* Copyright (C) 2006 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 android.support.v7.internal.view.menu;
|
|
|
|
import android.content.ActivityNotFoundException;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.os.Build;
|
|
import android.support.v4.content.ContextCompat;
|
|
import android.support.v4.view.ActionProvider;
|
|
import android.support.v4.internal.view.SupportMenuItem;
|
|
import android.support.v4.view.MenuItemCompat;
|
|
import android.support.v7.internal.widget.TintManager;
|
|
import android.util.Log;
|
|
import android.view.ContextMenu.ContextMenuInfo;
|
|
import android.view.LayoutInflater;
|
|
import android.view.MenuItem;
|
|
import android.view.SubMenu;
|
|
import android.view.View;
|
|
import android.view.ViewDebug;
|
|
import android.widget.LinearLayout;
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public final class MenuItemImpl implements SupportMenuItem {
|
|
|
|
private static final String TAG = "MenuItemImpl";
|
|
|
|
private static final int SHOW_AS_ACTION_MASK = SHOW_AS_ACTION_NEVER |
|
|
SHOW_AS_ACTION_IF_ROOM |
|
|
SHOW_AS_ACTION_ALWAYS;
|
|
|
|
private final int mId;
|
|
private final int mGroup;
|
|
private final int mCategoryOrder;
|
|
private final int mOrdering;
|
|
private CharSequence mTitle;
|
|
private CharSequence mTitleCondensed;
|
|
private Intent mIntent;
|
|
private char mShortcutNumericChar;
|
|
private char mShortcutAlphabeticChar;
|
|
|
|
/** The icon's drawable which is only created as needed */
|
|
private Drawable mIconDrawable;
|
|
|
|
/**
|
|
* The icon's resource ID which is used to get the Drawable when it is
|
|
* needed (if the Drawable isn't already obtained--only one of the two is
|
|
* needed).
|
|
*/
|
|
private int mIconResId = NO_ICON;
|
|
|
|
/** The menu to which this item belongs */
|
|
private MenuBuilder mMenu;
|
|
/** If this item should launch a sub menu, this is the sub menu to launch */
|
|
private SubMenuBuilder mSubMenu;
|
|
|
|
private Runnable mItemCallback;
|
|
private SupportMenuItem.OnMenuItemClickListener mClickListener;
|
|
|
|
private int mFlags = ENABLED;
|
|
private static final int CHECKABLE = 0x00000001;
|
|
private static final int CHECKED = 0x00000002;
|
|
private static final int EXCLUSIVE = 0x00000004;
|
|
private static final int HIDDEN = 0x00000008;
|
|
private static final int ENABLED = 0x00000010;
|
|
private static final int IS_ACTION = 0x00000020;
|
|
|
|
private int mShowAsAction = SHOW_AS_ACTION_NEVER;
|
|
|
|
private View mActionView;
|
|
private ActionProvider mActionProvider;
|
|
private MenuItemCompat.OnActionExpandListener mOnActionExpandListener;
|
|
private boolean mIsActionViewExpanded = false;
|
|
|
|
/** Used for the icon resource ID if this item does not have an icon */
|
|
static final int NO_ICON = 0;
|
|
|
|
/**
|
|
* Current use case is for context menu: Extra information linked to the
|
|
* View that added this item to the context menu.
|
|
*/
|
|
private ContextMenuInfo mMenuInfo;
|
|
|
|
private static String sPrependShortcutLabel;
|
|
private static String sEnterShortcutLabel;
|
|
private static String sDeleteShortcutLabel;
|
|
private static String sSpaceShortcutLabel;
|
|
|
|
|
|
/**
|
|
* Instantiates this menu item.
|
|
*
|
|
* @param menu
|
|
* @param group Item ordering grouping control. The item will be added after
|
|
* all other items whose order is <= this number, and before any
|
|
* that are larger than it. This can also be used to define
|
|
* groups of items for batch state changes. Normally use 0.
|
|
* @param id Unique item ID. Use 0 if you do not need a unique ID.
|
|
* @param categoryOrder The ordering for this item.
|
|
* @param title The text to display for the item.
|
|
*/
|
|
MenuItemImpl(MenuBuilder menu, int group, int id, int categoryOrder, int ordering,
|
|
CharSequence title, int showAsAction) {
|
|
|
|
/*if (sPrependShortcutLabel == null) {
|
|
// This is instantiated from the UI thread, so no chance of sync issues
|
|
sPrependShortcutLabel = menu.getContext().getResources().getString(
|
|
com.android.internal.R.string.prepend_shortcut_label);
|
|
sEnterShortcutLabel = menu.getContext().getResources().getString(
|
|
com.android.internal.R.string.menu_enter_shortcut_label);
|
|
sDeleteShortcutLabel = menu.getContext().getResources().getString(
|
|
com.android.internal.R.string.menu_delete_shortcut_label);
|
|
sSpaceShortcutLabel = menu.getContext().getResources().getString(
|
|
com.android.internal.R.string.menu_space_shortcut_label);
|
|
}*/
|
|
|
|
mMenu = menu;
|
|
mId = id;
|
|
mGroup = group;
|
|
mCategoryOrder = categoryOrder;
|
|
mOrdering = ordering;
|
|
mTitle = title;
|
|
mShowAsAction = showAsAction;
|
|
}
|
|
|
|
/**
|
|
* Invokes the item by calling various listeners or callbacks.
|
|
*
|
|
* @return true if the invocation was handled, false otherwise
|
|
*/
|
|
public boolean invoke() {
|
|
if (mClickListener != null && mClickListener.onMenuItemClick(this)) {
|
|
return true;
|
|
}
|
|
|
|
if (mMenu.dispatchMenuItemSelected(mMenu.getRootMenu(), this)) {
|
|
return true;
|
|
}
|
|
|
|
if (mItemCallback != null) {
|
|
mItemCallback.run();
|
|
return true;
|
|
}
|
|
|
|
if (mIntent != null) {
|
|
try {
|
|
mMenu.getContext().startActivity(mIntent);
|
|
return true;
|
|
} catch (ActivityNotFoundException e) {
|
|
Log.e(TAG, "Can't find activity to handle intent; ignoring", e);
|
|
}
|
|
}
|
|
|
|
if (mActionProvider != null && mActionProvider.onPerformDefaultAction()) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean isEnabled() {
|
|
return (mFlags & ENABLED) != 0;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setEnabled(boolean enabled) {
|
|
if (enabled) {
|
|
mFlags |= ENABLED;
|
|
} else {
|
|
mFlags &= ~ENABLED;
|
|
}
|
|
|
|
mMenu.onItemsChanged(false);
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public int getGroupId() {
|
|
return mGroup;
|
|
}
|
|
|
|
@Override
|
|
@ViewDebug.CapturedViewProperty
|
|
public int getItemId() {
|
|
return mId;
|
|
}
|
|
|
|
@Override
|
|
public int getOrder() {
|
|
return mCategoryOrder;
|
|
}
|
|
|
|
public int getOrdering() {
|
|
return mOrdering;
|
|
}
|
|
|
|
@Override
|
|
public Intent getIntent() {
|
|
return mIntent;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setIntent(Intent intent) {
|
|
mIntent = intent;
|
|
return this;
|
|
}
|
|
|
|
Runnable getCallback() {
|
|
return mItemCallback;
|
|
}
|
|
|
|
public MenuItem setCallback(Runnable callback) {
|
|
mItemCallback = callback;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public char getAlphabeticShortcut() {
|
|
return mShortcutAlphabeticChar;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setAlphabeticShortcut(char alphaChar) {
|
|
if (mShortcutAlphabeticChar == alphaChar) {
|
|
return this;
|
|
}
|
|
|
|
mShortcutAlphabeticChar = Character.toLowerCase(alphaChar);
|
|
|
|
mMenu.onItemsChanged(false);
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public char getNumericShortcut() {
|
|
return mShortcutNumericChar;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setNumericShortcut(char numericChar) {
|
|
if (mShortcutNumericChar == numericChar) {
|
|
return this;
|
|
}
|
|
|
|
mShortcutNumericChar = numericChar;
|
|
|
|
mMenu.onItemsChanged(false);
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setShortcut(char numericChar, char alphaChar) {
|
|
mShortcutNumericChar = numericChar;
|
|
mShortcutAlphabeticChar = Character.toLowerCase(alphaChar);
|
|
|
|
mMenu.onItemsChanged(false);
|
|
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* @return The active shortcut (based on QWERTY-mode of the menu).
|
|
*/
|
|
char getShortcut() {
|
|
return (mMenu.isQwertyMode() ? mShortcutAlphabeticChar : mShortcutNumericChar);
|
|
}
|
|
|
|
/**
|
|
* @return The label to show for the shortcut. This includes the chording key (for example
|
|
* 'Menu+a'). Also, any non-human readable characters should be human readable (for
|
|
* example 'Menu+enter').
|
|
*/
|
|
String getShortcutLabel() {
|
|
|
|
char shortcut = getShortcut();
|
|
if (shortcut == 0) {
|
|
return "";
|
|
}
|
|
|
|
StringBuilder sb = new StringBuilder(sPrependShortcutLabel);
|
|
switch (shortcut) {
|
|
|
|
case '\n':
|
|
sb.append(sEnterShortcutLabel);
|
|
break;
|
|
|
|
case '\b':
|
|
sb.append(sDeleteShortcutLabel);
|
|
break;
|
|
|
|
case ' ':
|
|
sb.append(sSpaceShortcutLabel);
|
|
break;
|
|
|
|
default:
|
|
sb.append(shortcut);
|
|
break;
|
|
}
|
|
|
|
return sb.toString();
|
|
}
|
|
|
|
/**
|
|
* @return Whether this menu item should be showing shortcuts (depends on
|
|
* whether the menu should show shortcuts and whether this item has
|
|
* a shortcut defined)
|
|
*/
|
|
boolean shouldShowShortcut() {
|
|
// Show shortcuts if the menu is supposed to show shortcuts AND this item has a shortcut
|
|
return mMenu.isShortcutsVisible() && (getShortcut() != 0);
|
|
}
|
|
|
|
@Override
|
|
public SubMenu getSubMenu() {
|
|
return mSubMenu;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasSubMenu() {
|
|
return mSubMenu != null;
|
|
}
|
|
|
|
void setSubMenu(SubMenuBuilder subMenu) {
|
|
mSubMenu = subMenu;
|
|
|
|
subMenu.setHeaderTitle(getTitle());
|
|
}
|
|
|
|
@Override
|
|
@ViewDebug.CapturedViewProperty
|
|
public CharSequence getTitle() {
|
|
return mTitle;
|
|
}
|
|
|
|
/**
|
|
* Gets the title for a particular {@link MenuView.ItemView}
|
|
*
|
|
* @param itemView The ItemView that is receiving the title
|
|
* @return Either the title or condensed title based on what the ItemView prefers
|
|
*/
|
|
CharSequence getTitleForItemView(MenuView.ItemView itemView) {
|
|
return ((itemView != null) && itemView.prefersCondensedTitle())
|
|
? getTitleCondensed()
|
|
: getTitle();
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setTitle(CharSequence title) {
|
|
mTitle = title;
|
|
|
|
mMenu.onItemsChanged(false);
|
|
|
|
if (mSubMenu != null) {
|
|
mSubMenu.setHeaderTitle(title);
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setTitle(int title) {
|
|
return setTitle(mMenu.getContext().getString(title));
|
|
}
|
|
|
|
@Override
|
|
public CharSequence getTitleCondensed() {
|
|
final CharSequence ctitle = mTitleCondensed != null ? mTitleCondensed : mTitle;
|
|
|
|
if (Build.VERSION.SDK_INT < 18 && ctitle != null && !(ctitle instanceof String)) {
|
|
// For devices pre-JB-MR2, where we have a non-String CharSequence, we need to
|
|
// convert this to a String so that EventLog.writeEvent() does not throw an exception
|
|
// in Activity.onMenuItemSelected()
|
|
return ctitle.toString();
|
|
} else {
|
|
// Else, we just return the condensed title
|
|
return ctitle;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setTitleCondensed(CharSequence title) {
|
|
mTitleCondensed = title;
|
|
|
|
// Could use getTitle() in the loop below, but just cache what it would do here
|
|
if (title == null) {
|
|
title = mTitle;
|
|
}
|
|
|
|
mMenu.onItemsChanged(false);
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public Drawable getIcon() {
|
|
if (mIconDrawable != null) {
|
|
return mIconDrawable;
|
|
}
|
|
|
|
if (mIconResId != NO_ICON) {
|
|
Drawable icon = TintManager.getDrawable(mMenu.getContext(), mIconResId);
|
|
mIconResId = NO_ICON;
|
|
mIconDrawable = icon;
|
|
return icon;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setIcon(Drawable icon) {
|
|
mIconResId = NO_ICON;
|
|
mIconDrawable = icon;
|
|
mMenu.onItemsChanged(false);
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setIcon(int iconResId) {
|
|
mIconDrawable = null;
|
|
mIconResId = iconResId;
|
|
|
|
// If we have a view, we need to push the Drawable to them
|
|
mMenu.onItemsChanged(false);
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public boolean isCheckable() {
|
|
return (mFlags & CHECKABLE) == CHECKABLE;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setCheckable(boolean checkable) {
|
|
final int oldFlags = mFlags;
|
|
mFlags = (mFlags & ~CHECKABLE) | (checkable ? CHECKABLE : 0);
|
|
if (oldFlags != mFlags) {
|
|
mMenu.onItemsChanged(false);
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
public void setExclusiveCheckable(boolean exclusive) {
|
|
mFlags = (mFlags & ~EXCLUSIVE) | (exclusive ? EXCLUSIVE : 0);
|
|
}
|
|
|
|
public boolean isExclusiveCheckable() {
|
|
return (mFlags & EXCLUSIVE) != 0;
|
|
}
|
|
|
|
@Override
|
|
public boolean isChecked() {
|
|
return (mFlags & CHECKED) == CHECKED;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setChecked(boolean checked) {
|
|
if ((mFlags & EXCLUSIVE) != 0) {
|
|
// Call the method on the Menu since it knows about the others in this
|
|
// exclusive checkable group
|
|
mMenu.setExclusiveItemChecked(this);
|
|
} else {
|
|
setCheckedInt(checked);
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
void setCheckedInt(boolean checked) {
|
|
final int oldFlags = mFlags;
|
|
mFlags = (mFlags & ~CHECKED) | (checked ? CHECKED : 0);
|
|
if (oldFlags != mFlags) {
|
|
mMenu.onItemsChanged(false);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isVisible() {
|
|
if (mActionProvider != null && mActionProvider.overridesItemVisibility()) {
|
|
return (mFlags & HIDDEN) == 0 && mActionProvider.isVisible();
|
|
}
|
|
return (mFlags & HIDDEN) == 0;
|
|
}
|
|
|
|
/**
|
|
* Changes the visibility of the item. This method DOES NOT notify the parent menu of a change
|
|
* in this item, so this should only be called from methods that will eventually trigger this
|
|
* change. If unsure, use {@link #setVisible(boolean)} instead.
|
|
*
|
|
* @param shown Whether to show (true) or hide (false).
|
|
* @return Whether the item's shown state was changed
|
|
*/
|
|
boolean setVisibleInt(boolean shown) {
|
|
final int oldFlags = mFlags;
|
|
mFlags = (mFlags & ~HIDDEN) | (shown ? 0 : HIDDEN);
|
|
return oldFlags != mFlags;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setVisible(boolean shown) {
|
|
// Try to set the shown state to the given state. If the shown state was changed
|
|
// (i.e. the previous state isn't the same as given state), notify the parent menu that
|
|
// the shown state has changed for this item
|
|
if (setVisibleInt(shown)) mMenu.onItemVisibleChanged(this);
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setOnMenuItemClickListener(MenuItem.OnMenuItemClickListener clickListener) {
|
|
mClickListener = clickListener;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return mTitle.toString();
|
|
}
|
|
|
|
void setMenuInfo(ContextMenuInfo menuInfo) {
|
|
mMenuInfo = menuInfo;
|
|
}
|
|
|
|
@Override
|
|
public ContextMenuInfo getMenuInfo() {
|
|
return mMenuInfo;
|
|
}
|
|
|
|
public void actionFormatChanged() {
|
|
mMenu.onItemActionRequestChanged(this);
|
|
}
|
|
|
|
/**
|
|
* @return Whether the menu should show icons for menu items.
|
|
*/
|
|
public boolean shouldShowIcon() {
|
|
return mMenu.getOptionalIconsVisible();
|
|
}
|
|
|
|
public boolean isActionButton() {
|
|
return (mFlags & IS_ACTION) == IS_ACTION;
|
|
}
|
|
|
|
public boolean requestsActionButton() {
|
|
return (mShowAsAction & SHOW_AS_ACTION_IF_ROOM) == SHOW_AS_ACTION_IF_ROOM;
|
|
}
|
|
|
|
public boolean requiresActionButton() {
|
|
return (mShowAsAction & SHOW_AS_ACTION_ALWAYS) == SHOW_AS_ACTION_ALWAYS;
|
|
}
|
|
|
|
public void setIsActionButton(boolean isActionButton) {
|
|
if (isActionButton) {
|
|
mFlags |= IS_ACTION;
|
|
} else {
|
|
mFlags &= ~IS_ACTION;
|
|
}
|
|
}
|
|
|
|
public boolean showsTextAsAction() {
|
|
return (mShowAsAction & SHOW_AS_ACTION_WITH_TEXT) == SHOW_AS_ACTION_WITH_TEXT;
|
|
}
|
|
|
|
@Override
|
|
public void setShowAsAction(int actionEnum) {
|
|
switch (actionEnum & SHOW_AS_ACTION_MASK) {
|
|
case SHOW_AS_ACTION_ALWAYS:
|
|
case SHOW_AS_ACTION_IF_ROOM:
|
|
case SHOW_AS_ACTION_NEVER:
|
|
// Looks good!
|
|
break;
|
|
|
|
default:
|
|
// Mutually exclusive options selected!
|
|
throw new IllegalArgumentException("SHOW_AS_ACTION_ALWAYS, SHOW_AS_ACTION_IF_ROOM,"
|
|
+ " and SHOW_AS_ACTION_NEVER are mutually exclusive.");
|
|
}
|
|
mShowAsAction = actionEnum;
|
|
mMenu.onItemActionRequestChanged(this);
|
|
}
|
|
|
|
@Override
|
|
public SupportMenuItem setActionView(View view) {
|
|
mActionView = view;
|
|
mActionProvider = null;
|
|
if (view != null && view.getId() == View.NO_ID && mId > 0) {
|
|
view.setId(mId);
|
|
}
|
|
mMenu.onItemActionRequestChanged(this);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public SupportMenuItem setActionView(int resId) {
|
|
final Context context = mMenu.getContext();
|
|
final LayoutInflater inflater = LayoutInflater.from(context);
|
|
setActionView(inflater.inflate(resId, new LinearLayout(context), false));
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public View getActionView() {
|
|
if (mActionView != null) {
|
|
return mActionView;
|
|
} else if (mActionProvider != null) {
|
|
mActionView = mActionProvider.onCreateActionView(this);
|
|
return mActionView;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setActionProvider(android.view.ActionProvider actionProvider) {
|
|
throw new UnsupportedOperationException(
|
|
"This is not supported, use MenuItemCompat.setActionProvider()");
|
|
}
|
|
|
|
@Override
|
|
public android.view.ActionProvider getActionProvider() {
|
|
throw new UnsupportedOperationException(
|
|
"This is not supported, use MenuItemCompat.getActionProvider()");
|
|
}
|
|
|
|
@Override
|
|
public ActionProvider getSupportActionProvider() {
|
|
return mActionProvider;
|
|
}
|
|
|
|
@Override
|
|
public SupportMenuItem setSupportActionProvider(ActionProvider actionProvider) {
|
|
if (mActionProvider != null) {
|
|
mActionProvider.setVisibilityListener(null);
|
|
}
|
|
mActionView = null;
|
|
mActionProvider = actionProvider;
|
|
mMenu.onItemsChanged(true); // Measurement can be changed
|
|
if (mActionProvider != null) {
|
|
mActionProvider.setVisibilityListener(new ActionProvider.VisibilityListener() {
|
|
@Override
|
|
public void onActionProviderVisibilityChanged(boolean isVisible) {
|
|
mMenu.onItemVisibleChanged(MenuItemImpl.this);
|
|
}
|
|
});
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public SupportMenuItem setShowAsActionFlags(int actionEnum) {
|
|
setShowAsAction(actionEnum);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public boolean expandActionView() {
|
|
if (!hasCollapsibleActionView()) {
|
|
return false;
|
|
}
|
|
|
|
if (mOnActionExpandListener == null ||
|
|
mOnActionExpandListener.onMenuItemActionExpand(this)) {
|
|
return mMenu.expandItemActionView(this);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean collapseActionView() {
|
|
if ((mShowAsAction & SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW) == 0) {
|
|
return false;
|
|
}
|
|
if (mActionView == null) {
|
|
// We're already collapsed if we have no action view.
|
|
return true;
|
|
}
|
|
|
|
if (mOnActionExpandListener == null ||
|
|
mOnActionExpandListener.onMenuItemActionCollapse(this)) {
|
|
return mMenu.collapseItemActionView(this);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public SupportMenuItem setSupportOnActionExpandListener(
|
|
MenuItemCompat.OnActionExpandListener listener) {
|
|
mOnActionExpandListener = listener;
|
|
return this;
|
|
}
|
|
|
|
public boolean hasCollapsibleActionView() {
|
|
if ((mShowAsAction & SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW) != 0) {
|
|
if (mActionView == null && mActionProvider != null) {
|
|
mActionView = mActionProvider.onCreateActionView(this);
|
|
}
|
|
return mActionView != null;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void setActionViewExpanded(boolean isExpanded) {
|
|
mIsActionViewExpanded = isExpanded;
|
|
mMenu.onItemsChanged(false);
|
|
}
|
|
|
|
@Override
|
|
public boolean isActionViewExpanded() {
|
|
return mIsActionViewExpanded;
|
|
}
|
|
|
|
@Override
|
|
public MenuItem setOnActionExpandListener(MenuItem.OnActionExpandListener listener) {
|
|
throw new UnsupportedOperationException(
|
|
"This is not supported, use MenuItemCompat.setOnActionExpandListener()");
|
|
}
|
|
}
|