FileDocCategorySizeDatePackage
MenuItemImpl.javaAPI DocAndroid 5.1 API21785Thu Mar 12 22:22:56 GMT 2015android.support.v7.internal.view.menu

MenuItemImpl

public final class MenuItemImpl extends Object implements android.support.v4.internal.view.SupportMenuItem
hide

Fields Summary
private static final String
TAG
private static final int
SHOW_AS_ACTION_MASK
private final int
mId
private final int
mGroup
private final int
mCategoryOrder
private final int
mOrdering
private CharSequence
mTitle
private CharSequence
mTitleCondensed
private android.content.Intent
mIntent
private char
mShortcutNumericChar
private char
mShortcutAlphabeticChar
private android.graphics.drawable.Drawable
mIconDrawable
The icon's drawable which is only created as needed
private int
mIconResId
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 MenuBuilder
mMenu
The menu to which this item belongs
private SubMenuBuilder
mSubMenu
If this item should launch a sub menu, this is the sub menu to launch
private Runnable
mItemCallback
private SupportMenuItem.OnMenuItemClickListener
mClickListener
private int
mFlags
private static final int
CHECKABLE
private static final int
CHECKED
private static final int
EXCLUSIVE
private static final int
HIDDEN
private static final int
ENABLED
private static final int
IS_ACTION
private int
mShowAsAction
private android.view.View
mActionView
private android.support.v4.view.ActionProvider
mActionProvider
private MenuItemCompat.OnActionExpandListener
mOnActionExpandListener
private boolean
mIsActionViewExpanded
static final int
NO_ICON
Used for the icon resource ID if this item does not have an icon
private android.view.ContextMenu.ContextMenuInfo
mMenuInfo
Current use case is for context menu: Extra information linked to the View that added this item to the context menu.
private static String
sPrependShortcutLabel
private static String
sEnterShortcutLabel
private static String
sDeleteShortcutLabel
private static String
sSpaceShortcutLabel
Constructors Summary
MenuItemImpl(MenuBuilder menu, int group, int id, int categoryOrder, int ordering, CharSequence title, int showAsAction)
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.



                                                                                                                             
             
                

        /*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;
Methods Summary
public voidactionFormatChanged()

        mMenu.onItemActionRequestChanged(this);
public booleancollapseActionView()

        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;
public booleanexpandActionView()

        if (!hasCollapsibleActionView()) {
            return false;
        }

        if (mOnActionExpandListener == null ||
                mOnActionExpandListener.onMenuItemActionExpand(this)) {
            return mMenu.expandItemActionView(this);
        }

        return false;
public android.view.ActionProvidergetActionProvider()

        throw new UnsupportedOperationException(
                "This is not supported, use MenuItemCompat.getActionProvider()");
public android.view.ViewgetActionView()

        if (mActionView != null) {
            return mActionView;
        } else if (mActionProvider != null) {
            mActionView = mActionProvider.onCreateActionView(this);
            return mActionView;
        } else {
            return null;
        }
public chargetAlphabeticShortcut()

        return mShortcutAlphabeticChar;
java.lang.RunnablegetCallback()

        return mItemCallback;
public intgetGroupId()

        return mGroup;
public android.graphics.drawable.DrawablegetIcon()

        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;
public android.content.IntentgetIntent()

        return mIntent;
public intgetItemId()

        return mId;
public android.view.ContextMenu.ContextMenuInfogetMenuInfo()

        return mMenuInfo;
public chargetNumericShortcut()

        return mShortcutNumericChar;
public intgetOrder()

        return mCategoryOrder;
public intgetOrdering()

        return mOrdering;
chargetShortcut()

return
The active shortcut (based on QWERTY-mode of the menu).

        return (mMenu.isQwertyMode() ? mShortcutAlphabeticChar : mShortcutNumericChar);
java.lang.StringgetShortcutLabel()

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').


        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();
public android.view.SubMenugetSubMenu()

        return mSubMenu;
public android.support.v4.view.ActionProvidergetSupportActionProvider()

        return mActionProvider;
public java.lang.CharSequencegetTitle()

        return mTitle;
public java.lang.CharSequencegetTitleCondensed()

        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;
        }
java.lang.CharSequencegetTitleForItemView(MenuView.ItemView itemView)
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

        return ((itemView != null) && itemView.prefersCondensedTitle())
                ? getTitleCondensed()
                : getTitle();
public booleanhasCollapsibleActionView()

        if ((mShowAsAction & SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW) != 0) {
            if (mActionView == null && mActionProvider != null) {
                mActionView = mActionProvider.onCreateActionView(this);
            }
            return mActionView != null;
        }
        return false;
public booleanhasSubMenu()

        return mSubMenu != null;
public booleaninvoke()
Invokes the item by calling various listeners or callbacks.

return
true if the invocation was handled, false otherwise

        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;
public booleanisActionButton()

        return (mFlags & IS_ACTION) == IS_ACTION;
public booleanisActionViewExpanded()

        return mIsActionViewExpanded;
public booleanisCheckable()

        return (mFlags & CHECKABLE) == CHECKABLE;
public booleanisChecked()

        return (mFlags & CHECKED) == CHECKED;
public booleanisEnabled()

        return (mFlags & ENABLED) != 0;
public booleanisExclusiveCheckable()

        return (mFlags & EXCLUSIVE) != 0;
public booleanisVisible()

        if (mActionProvider != null && mActionProvider.overridesItemVisibility()) {
            return (mFlags & HIDDEN) == 0 && mActionProvider.isVisible();
        }
        return (mFlags & HIDDEN) == 0;
public booleanrequestsActionButton()

        return (mShowAsAction & SHOW_AS_ACTION_IF_ROOM) == SHOW_AS_ACTION_IF_ROOM;
public booleanrequiresActionButton()

        return (mShowAsAction & SHOW_AS_ACTION_ALWAYS) == SHOW_AS_ACTION_ALWAYS;
public android.view.MenuItemsetActionProvider(android.view.ActionProvider actionProvider)

        throw new UnsupportedOperationException(
                "This is not supported, use MenuItemCompat.setActionProvider()");
public android.support.v4.internal.view.SupportMenuItemsetActionView(android.view.View view)

        mActionView = view;
        mActionProvider = null;
        if (view != null && view.getId() == View.NO_ID && mId > 0) {
            view.setId(mId);
        }
        mMenu.onItemActionRequestChanged(this);
        return this;
public android.support.v4.internal.view.SupportMenuItemsetActionView(int resId)

        final Context context = mMenu.getContext();
        final LayoutInflater inflater = LayoutInflater.from(context);
        setActionView(inflater.inflate(resId, new LinearLayout(context), false));
        return this;
public voidsetActionViewExpanded(boolean isExpanded)

        mIsActionViewExpanded = isExpanded;
        mMenu.onItemsChanged(false);
public android.view.MenuItemsetAlphabeticShortcut(char alphaChar)

        if (mShortcutAlphabeticChar == alphaChar) {
            return this;
        }

        mShortcutAlphabeticChar = Character.toLowerCase(alphaChar);

        mMenu.onItemsChanged(false);

        return this;
public android.view.MenuItemsetCallback(java.lang.Runnable callback)

        mItemCallback = callback;
        return this;
public android.view.MenuItemsetCheckable(boolean checkable)

        final int oldFlags = mFlags;
        mFlags = (mFlags & ~CHECKABLE) | (checkable ? CHECKABLE : 0);
        if (oldFlags != mFlags) {
            mMenu.onItemsChanged(false);
        }

        return this;
public android.view.MenuItemsetChecked(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;
voidsetCheckedInt(boolean checked)

        final int oldFlags = mFlags;
        mFlags = (mFlags & ~CHECKED) | (checked ? CHECKED : 0);
        if (oldFlags != mFlags) {
            mMenu.onItemsChanged(false);
        }
public android.view.MenuItemsetEnabled(boolean enabled)

        if (enabled) {
            mFlags |= ENABLED;
        } else {
            mFlags &= ~ENABLED;
        }

        mMenu.onItemsChanged(false);

        return this;
public voidsetExclusiveCheckable(boolean exclusive)

        mFlags = (mFlags & ~EXCLUSIVE) | (exclusive ? EXCLUSIVE : 0);
public android.view.MenuItemsetIcon(android.graphics.drawable.Drawable icon)

        mIconResId = NO_ICON;
        mIconDrawable = icon;
        mMenu.onItemsChanged(false);

        return this;
public android.view.MenuItemsetIcon(int iconResId)

        mIconDrawable = null;
        mIconResId = iconResId;

        // If we have a view, we need to push the Drawable to them
        mMenu.onItemsChanged(false);

        return this;
public android.view.MenuItemsetIntent(android.content.Intent intent)

        mIntent = intent;
        return this;
public voidsetIsActionButton(boolean isActionButton)

        if (isActionButton) {
            mFlags |= IS_ACTION;
        } else {
            mFlags &= ~IS_ACTION;
        }
voidsetMenuInfo(android.view.ContextMenu.ContextMenuInfo menuInfo)

        mMenuInfo = menuInfo;
public android.view.MenuItemsetNumericShortcut(char numericChar)

        if (mShortcutNumericChar == numericChar) {
            return this;
        }

        mShortcutNumericChar = numericChar;

        mMenu.onItemsChanged(false);

        return this;
public android.view.MenuItemsetOnActionExpandListener(MenuItem.OnActionExpandListener listener)

        throw new UnsupportedOperationException(
                "This is not supported, use MenuItemCompat.setOnActionExpandListener()");
public android.view.MenuItemsetOnMenuItemClickListener(MenuItem.OnMenuItemClickListener clickListener)

        mClickListener = clickListener;
        return this;
public android.view.MenuItemsetShortcut(char numericChar, char alphaChar)

        mShortcutNumericChar = numericChar;
        mShortcutAlphabeticChar = Character.toLowerCase(alphaChar);

        mMenu.onItemsChanged(false);

        return this;
public voidsetShowAsAction(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);
public android.support.v4.internal.view.SupportMenuItemsetShowAsActionFlags(int actionEnum)

        setShowAsAction(actionEnum);
        return this;
voidsetSubMenu(SubMenuBuilder subMenu)

        mSubMenu = subMenu;

        subMenu.setHeaderTitle(getTitle());
public android.support.v4.internal.view.SupportMenuItemsetSupportActionProvider(android.support.v4.view.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;
public android.support.v4.internal.view.SupportMenuItemsetSupportOnActionExpandListener(MenuItemCompat.OnActionExpandListener listener)

        mOnActionExpandListener = listener;
        return this;
public android.view.MenuItemsetTitle(java.lang.CharSequence title)

        mTitle = title;

        mMenu.onItemsChanged(false);

        if (mSubMenu != null) {
            mSubMenu.setHeaderTitle(title);
        }

        return this;
public android.view.MenuItemsetTitle(int title)

        return setTitle(mMenu.getContext().getString(title));
public android.view.MenuItemsetTitleCondensed(java.lang.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;
public android.view.MenuItemsetVisible(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;
booleansetVisibleInt(boolean shown)
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

        final int oldFlags = mFlags;
        mFlags = (mFlags & ~HIDDEN) | (shown ? 0 : HIDDEN);
        return oldFlags != mFlags;
public booleanshouldShowIcon()

return
Whether the menu should show icons for menu items.

        return mMenu.getOptionalIconsVisible();
booleanshouldShowShortcut()

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)

        // Show shortcuts if the menu is supposed to show shortcuts AND this item has a shortcut
        return mMenu.isShortcutsVisible() && (getShortcut() != 0);
public booleanshowsTextAsAction()

        return (mShowAsAction & SHOW_AS_ACTION_WITH_TEXT) == SHOW_AS_ACTION_WITH_TEXT;
public java.lang.StringtoString()

        return mTitle.toString();