Java tutorial
/* * 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 org.solovyev.android.widget.menu; import android.annotation.SuppressLint; import android.content.Context; import android.content.res.ColorStateList; import android.content.res.Resources; import android.content.res.TypedArray; import android.graphics.drawable.Drawable; import android.os.Parcelable; import android.support.v4.graphics.drawable.DrawableCompat; import android.support.v4.view.ActionProvider; import android.support.v4.view.MenuItemCompat; import android.support.v7.appcompat.R; import android.support.v7.view.menu.*; import android.support.v7.widget.ListPopupWindow; import android.view.*; import android.view.View.MeasureSpec; import android.widget.*; import org.solovyev.android.Check; import javax.annotation.Nonnull; import javax.annotation.Nullable; import java.util.ArrayList; import java.util.List; /** * Presents a menu as a small, simple popup anchored to another view. */ @SuppressWarnings("unused") @SuppressLint("PrivateResource") public class CustomPopupMenuHelper implements AdapterView.OnItemClickListener, View.OnKeyListener, ViewTreeObserver.OnGlobalLayoutListener, PopupWindow.OnDismissListener, MenuPresenter { private static final int DEFAULT_VIEW_TAG_KEY = org.solovyev.android.calculator.R.id.cpm_default_view_tag_key; private static final int[] COLOR_ATTRS = new int[] { R.attr.colorControlNormal }; private static final Object DEFAULT_VIEW_TAG = new Object(); private final Context mContext; private final LayoutInflater mInflater; private final MenuBuilder mMenu; private final MenuAdapter mAdapter; private final boolean mOverflowOnly; private final int mPopupMaxWidth; private final int mPopupStyleAttr; private final int mPopupStyleRes; boolean mForceShowIcon; private View mAnchorView; private ListPopupWindow mPopup; private ViewTreeObserver mTreeObserver; private Callback mPresenterCallback; private ViewGroup mMeasureParent; private boolean mKeepOnSubMenu; /** * Whether the cached content width value is valid. */ private boolean mHasContentWidth; /** * Cached content width from {@link #measureContentWidth}. */ private int mContentWidth; private int mGravity = Gravity.NO_GRAVITY; public CustomPopupMenuHelper(Context context, MenuBuilder menu) { this(context, menu, null, false, R.attr.popupMenuStyle); } public CustomPopupMenuHelper(Context context, MenuBuilder menu, View anchorView) { this(context, menu, anchorView, false, R.attr.popupMenuStyle); } public CustomPopupMenuHelper(Context context, MenuBuilder menu, View anchorView, boolean overflowOnly, int popupStyleAttr) { this(context, menu, anchorView, overflowOnly, popupStyleAttr, 0); } public CustomPopupMenuHelper(Context context, MenuBuilder menu, View anchorView, boolean overflowOnly, int popupStyleAttr, int popupStyleRes) { mContext = context; mInflater = LayoutInflater.from(context); mMenu = menu; mAdapter = new MenuAdapter(mMenu); mOverflowOnly = overflowOnly; mPopupStyleAttr = popupStyleAttr; mPopupStyleRes = popupStyleRes; final Resources res = context.getResources(); mPopupMaxWidth = Math.max(res.getDisplayMetrics().widthPixels / 2, res.getDimensionPixelSize(R.dimen.abc_config_prefDialogWidth)); mAnchorView = anchorView; // Present the menu using our context, not the menu builder's context. menu.addMenuPresenter(this, context); } static void tintMenuItem(@Nonnull MenuItemImpl item, @Nonnull ColorStateList tintColorStateList) { Drawable icon = item.getIcon(); if (icon != null) { icon = DrawableCompat.wrap(icon); DrawableCompat.setTintList(icon, tintColorStateList); item.setIcon(icon); } if (item.hasSubMenu()) { final SubMenu subMenu = item.getSubMenu(); for (int i = 0; i < subMenu.size(); i++) { final MenuItem subItem = subMenu.getItem(i); if (subItem instanceof MenuItemImpl) { tintMenuItem((MenuItemImpl) subItem, tintColorStateList); } } } } @Nullable static ColorStateList getTintColorStateList(Context context) { final TypedArray a = context.obtainStyledAttributes(null, COLOR_ATTRS); try { return a.getColorStateList(0); } finally { a.recycle(); } } static void tintMenuItems(Context context, Menu menu, int from, int to) { final ColorStateList tintColorStateList = getTintColorStateList(context); if (tintColorStateList == null) { return; } for (int i = from; i < to; i++) { final MenuItem item = menu.getItem(i); if (item instanceof MenuItemImpl) { tintMenuItem((MenuItemImpl) item, tintColorStateList); } } } public void setAnchorView(View anchor) { mAnchorView = anchor; } public void setForceShowIcon(boolean forceShow) { mForceShowIcon = forceShow; } public int getGravity() { return mGravity; } public void setGravity(int gravity) { mGravity = gravity; } public boolean isKeepOnSubMenu() { return mKeepOnSubMenu; } public void setKeepOnSubMenu(boolean keepOnSubMenu) { mKeepOnSubMenu = keepOnSubMenu; } public void show() { if (!tryShow()) { throw new IllegalStateException("MenuPopupHelper cannot be used without an anchor"); } } public ListPopupWindow getPopup() { return mPopup; } public boolean tryShow() { mPopup = new ListPopupWindow(mContext, null, mPopupStyleAttr, mPopupStyleRes); mPopup.setOnDismissListener(this); mPopup.setOnItemClickListener(this); mPopup.setAdapter(mAdapter); mPopup.setModal(true); View anchor = mAnchorView; if (anchor != null) { final boolean addGlobalListener = mTreeObserver == null; mTreeObserver = anchor.getViewTreeObserver(); // Refresh to latest if (addGlobalListener) mTreeObserver.addOnGlobalLayoutListener(this); mPopup.setAnchorView(anchor); mPopup.setDropDownGravity(mGravity); } else { return false; } if (!mHasContentWidth) { mContentWidth = measureContentWidth(); mHasContentWidth = true; } mPopup.setContentWidth(mContentWidth); mPopup.setInputMethodMode(PopupWindow.INPUT_METHOD_NOT_NEEDED); mPopup.show(); mPopup.getListView().setOnKeyListener(this); return true; } public void dismiss() { if (isShowing()) { mPopup.dismiss(); } } public void onDismiss() { mPopup = null; mMenu.close(); if (mTreeObserver != null) { if (!mTreeObserver.isAlive()) mTreeObserver = mAnchorView.getViewTreeObserver(); //noinspection deprecation mTreeObserver.removeGlobalOnLayoutListener(this); mTreeObserver = null; } } public boolean isShowing() { return mPopup != null && mPopup.isShowing(); } @Override public void onItemClick(AdapterView<?> parent, View view, int position, long id) { MenuAdapter adapter = mAdapter; adapter.mAdapterMenu.performItemAction(adapter.getItem(position), 0); } public boolean onKey(View v, int keyCode, KeyEvent event) { if (event.getAction() == KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_MENU) { dismiss(); return true; } return false; } private int measureContentWidth() { // Menus don't tend to be long, so this is more sane than it looks. int maxWidth = 0; View itemView = null; int itemType = 0; final ListAdapter adapter = mAdapter; final int widthMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED); final int heightMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED); final int count = adapter.getCount(); for (int i = 0; i < count; i++) { final int positionType = adapter.getItemViewType(i); if (positionType != itemType) { itemType = positionType; itemView = null; } if (mMeasureParent == null) { mMeasureParent = new FrameLayout(mContext); } itemView = adapter.getView(i, itemView, mMeasureParent); itemView.measure(widthMeasureSpec, heightMeasureSpec); final int itemWidth = itemView.getMeasuredWidth(); if (itemWidth >= mPopupMaxWidth) { return mPopupMaxWidth; } else if (itemWidth > maxWidth) { maxWidth = itemWidth; } } return maxWidth; } @Override public void onGlobalLayout() { if (!isShowing()) { return; } final View anchor = mAnchorView; if (anchor == null || !anchor.isShown()) { dismiss(); } else { // Recompute window size and position mPopup.show(); } } @Override public void initForMenu(Context context, MenuBuilder menu) { // Don't need to do anything; we added as a presenter in the constructor. } @Override public MenuView getMenuView(ViewGroup root) { throw new UnsupportedOperationException("MenuPopupHelpers manage their own views"); } @Override public void updateMenuView(boolean cleared) { mHasContentWidth = false; if (mAdapter != null) { mAdapter.notifyDataSetChanged(); } } @Override public void setCallback(Callback cb) { mPresenterCallback = cb; } @Override public boolean onSubMenuSelected(SubMenuBuilder subMenu) { if (subMenu.hasVisibleItems()) { CustomPopupMenuHelper subPopup = new CustomPopupMenuHelper(mContext, subMenu, mAnchorView, false, mPopupStyleAttr, mPopupStyleRes); subPopup.setGravity(mGravity); subPopup.setCallback(mPresenterCallback); subPopup.setKeepOnSubMenu(mKeepOnSubMenu); boolean preserveIconSpacing = false; final int count = subMenu.size(); for (int i = 0; i < count; i++) { MenuItem childItem = subMenu.getItem(i); if (childItem.isVisible() && childItem.getIcon() != null) { preserveIconSpacing = true; break; } } subPopup.setForceShowIcon(preserveIconSpacing); if (subPopup.tryShow()) { if (mPresenterCallback != null) { mPresenterCallback.onOpenSubMenu(subMenu); } return true; } } return false; } @Override public void onCloseMenu(MenuBuilder menu, boolean allMenusAreClosing) { // Only care about the (sub)menu we're presenting. if (menu != mMenu) return; if (isKeepOnSubMenu() && !allMenusAreClosing) { return; } dismiss(); if (mPresenterCallback != null) { mPresenterCallback.onCloseMenu(menu, allMenusAreClosing); } } @Override public boolean flagActionItems() { return false; } public boolean expandItemActionView(MenuBuilder menu, MenuItemImpl item) { return false; } public boolean collapseItemActionView(MenuBuilder menu, MenuItemImpl item) { return false; } @Override public int getId() { return 0; } @Override public Parcelable onSaveInstanceState() { return null; } @Override public void onRestoreInstanceState(Parcelable state) { } private class MenuAdapter extends BaseAdapter { private MenuBuilder mAdapterMenu; private int mExpandedIndex = -1; public MenuAdapter(MenuBuilder menu) { mAdapterMenu = menu; findExpandedIndex(); } public int getCount() { ArrayList<MenuItemImpl> items = mOverflowOnly ? mAdapterMenu.getNonActionItems() : mAdapterMenu.getVisibleItems(); if (mExpandedIndex < 0) { return items.size(); } return items.size() - 1; } public MenuItemImpl getItem(int position) { ArrayList<MenuItemImpl> items = mOverflowOnly ? mAdapterMenu.getNonActionItems() : mAdapterMenu.getVisibleItems(); if (mExpandedIndex >= 0 && position >= mExpandedIndex) { position++; } return items.get(position); } public long getItemId(int position) { // Since a menu item's ID is optional, we'll use the position as an // ID for the item in the AdapterView return position; } public View getView(int position, View convertView, ViewGroup parent) { final MenuItemImpl item = getItem(position); final ActionProvider actionProvider = MenuItemCompat.getActionProvider(item); if (actionProvider != null) { final View actionView = actionProvider.onCreateActionView(item); fixLayoutParams(actionView, parent); return actionView; } final View actionView = MenuItemCompat.getActionView(item); if (actionView != null) { ((MenuView.ItemView) actionView).initialize(item, 0); fixLayoutParams(actionView, parent); return actionView; } return getDefaultView(item, convertView, parent); } private void fixLayoutParams(View actionView, ViewGroup parent) { if (parent instanceof FrameLayout) { // width measure pass, nothing to be done return; } Check.isTrue(parent instanceof AbsListView); final ViewGroup.LayoutParams lp = actionView.getLayoutParams(); if (lp != null && !(lp instanceof AbsListView.LayoutParams)) { // see android.widget.AbsListView.generateDefaultLayoutParams() actionView.setLayoutParams(new AbsListView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)); } } @Nonnull private View getDefaultView(MenuItemImpl item, View convertView, ViewGroup parent) { if (convertView == null || convertView.getTag(DEFAULT_VIEW_TAG_KEY) != DEFAULT_VIEW_TAG) { convertView = mInflater.inflate(R.layout.abc_popup_menu_item_layout, parent, false); convertView.setTag(DEFAULT_VIEW_TAG_KEY, DEFAULT_VIEW_TAG); } final MenuView.ItemView itemView = (MenuView.ItemView) convertView; if (mForceShowIcon) { final ListMenuItemView listItemView = (ListMenuItemView) convertView; final boolean preserveIconSpacing = ListMenuItemViewCompat.getPreserveIconSpacing(listItemView); listItemView.setForceShowIcon(true); ListMenuItemViewCompat.setPreserveIconSpacing(listItemView, preserveIconSpacing); } itemView.initialize(item, 0); return convertView; } void findExpandedIndex() { final MenuItemImpl expandedItem = mMenu.getExpandedItem(); if (expandedItem != null) { final ArrayList<MenuItemImpl> items = mMenu.getNonActionItems(); final int count = items.size(); for (int i = 0; i < count; i++) { final MenuItemImpl item = items.get(i); if (item == expandedItem) { mExpandedIndex = i; return; } } } mExpandedIndex = -1; } @Override public void notifyDataSetChanged() { findExpandedIndex(); super.notifyDataSetChanged(); } public int indexOf(MenuItem item) { final List<MenuItemImpl> visibleItems = mMenu.getVisibleItems(); for (int i = 0; i < visibleItems.size(); i++) { MenuItemImpl candidate = visibleItems.get(i); if (candidate == item) { return i; } } return -1; } } }