v7/appcompat/src/android/support/v7/internal/view/menu/MenuPopupHelper.java - platform/frameworks/support.git - Git at Google

 /*
  * 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 android.support.v7.internal.view.menu;

 import android.content.Context;
 import android.content.res.Resources;
 import android.os.Parcelable;
 import android.support.v7.appcompat.R;
 import android.support.v7.widget.ListPopupWindow;
 import android.view.Gravity;
 import android.view.KeyEvent;
 import android.view.LayoutInflater;
 import android.view.MenuItem;
 import android.view.View;
 import android.view.View.MeasureSpec;
 import android.view.ViewGroup;
 import android.view.ViewTreeObserver;
 import android.widget.AdapterView;
 import android.widget.BaseAdapter;
 import android.widget.FrameLayout;
 import android.widget.ListAdapter;
 import android.widget.PopupWindow;

 import java.util.ArrayList;

 /**
  * Presents a menu as a small, simple popup anchored to another view.
  *
  * @hide
  */
 public class MenuPopupHelper implements AdapterView.OnItemClickListener, View.OnKeyListener,
         ViewTreeObserver.OnGlobalLayoutListener, PopupWindow.OnDismissListener,
         MenuPresenter {

     private static final String TAG = "MenuPopupHelper";

     static final int ITEM_LAYOUT = R.layout.abc_popup_menu_item_layout;

     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;

     private View mAnchorView;
     private ListPopupWindow mPopup;
     private ViewTreeObserver mTreeObserver;
     private Callback mPresenterCallback;

     boolean mForceShowIcon;

     private ViewGroup mMeasureParent;

     /** Whether the cached content width value is valid. */
     private boolean mHasContentWidth;

     /** Cached content width from {@link #measureContentWidth}. */
     private int mContentWidth;

     private int mDropDownGravity = Gravity.NO_GRAVITY;

     public MenuPopupHelper(Context context, MenuBuilder menu) {
         this(context, menu, null, false, R.attr.popupMenuStyle);
     }

     public MenuPopupHelper(Context context, MenuBuilder menu, View anchorView) {
         this(context, menu, anchorView, false, R.attr.popupMenuStyle);
     }

     public MenuPopupHelper(Context context, MenuBuilder menu, View anchorView,
             boolean overflowOnly, int popupStyleAttr) {
         this(context, menu, anchorView, overflowOnly, popupStyleAttr, 0);
     }

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

     public void setAnchorView(View anchor) {
         mAnchorView = anchor;
     }

     public void setForceShowIcon(boolean forceShow) {
         mForceShowIcon = forceShow;
     }

     public void setGravity(int gravity) {
         mDropDownGravity = gravity;
     }

     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(mDropDownGravity);
         } 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();
             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()) {
             final View anchor = mAnchorView;
             if (anchor == null || !anchor.isShown()) {
                 dismiss();
             } else if (isShowing()) {
                 // 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()) {
             MenuPopupHelper subPopup = new MenuPopupHelper(mContext, subMenu, mAnchorView);
             subPopup.setCallback(mPresenterCallback);

             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;

         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) {
             if (convertView == null) {
                 convertView = mInflater.inflate(ITEM_LAYOUT, parent, false);
             }

             MenuView.ItemView itemView = (MenuView.ItemView) convertView;
             if (mForceShowIcon) {
                 ((ListMenuItemView) convertView).setForceShowIcon(true);
             }
             itemView.initialize(getItem(position), 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();
         }
     }
 }
	/*
	* 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 android.support.v7.internal.view.menu;

	import android.content.Context;
	import android.content.res.Resources;
	import android.os.Parcelable;
	import android.support.v7.appcompat.R;
	import android.support.v7.widget.ListPopupWindow;
	import android.view.Gravity;
	import android.view.KeyEvent;
	import android.view.LayoutInflater;
	import android.view.MenuItem;
	import android.view.View;
	import android.view.View.MeasureSpec;
	import android.view.ViewGroup;
	import android.view.ViewTreeObserver;
	import android.widget.AdapterView;
	import android.widget.BaseAdapter;
	import android.widget.FrameLayout;
	import android.widget.ListAdapter;
	import android.widget.PopupWindow;

	import java.util.ArrayList;

	/**
	* Presents a menu as a small, simple popup anchored to another view.
	*
	* @hide
	*/
	public class MenuPopupHelper implements AdapterView.OnItemClickListener, View.OnKeyListener,
	ViewTreeObserver.OnGlobalLayoutListener, PopupWindow.OnDismissListener,
	MenuPresenter {

	private static final String TAG = "MenuPopupHelper";

	static final int ITEM_LAYOUT = R.layout.abc_popup_menu_item_layout;

	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;

	private View mAnchorView;
	private ListPopupWindow mPopup;
	private ViewTreeObserver mTreeObserver;
	private Callback mPresenterCallback;

	boolean mForceShowIcon;

	private ViewGroup mMeasureParent;

	/** Whether the cached content width value is valid. */
	private boolean mHasContentWidth;

	/** Cached content width from {@link #measureContentWidth}. */
	private int mContentWidth;

	private int mDropDownGravity = Gravity.NO_GRAVITY;

	public MenuPopupHelper(Context context, MenuBuilder menu) {
	this(context, menu, null, false, R.attr.popupMenuStyle);
	}

	public MenuPopupHelper(Context context, MenuBuilder menu, View anchorView) {
	this(context, menu, anchorView, false, R.attr.popupMenuStyle);
	}

	public MenuPopupHelper(Context context, MenuBuilder menu, View anchorView,
	boolean overflowOnly, int popupStyleAttr) {
	this(context, menu, anchorView, overflowOnly, popupStyleAttr, 0);
	}

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

	public void setAnchorView(View anchor) {
	mAnchorView = anchor;
	}

	public void setForceShowIcon(boolean forceShow) {
	mForceShowIcon = forceShow;
	}

	public void setGravity(int gravity) {
	mDropDownGravity = gravity;
	}

	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(mDropDownGravity);
	} 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();
	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()) {
	final View anchor = mAnchorView;
	if (anchor == null \|\| !anchor.isShown()) {
	dismiss();
	} else if (isShowing()) {
	// 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()) {
	MenuPopupHelper subPopup = new MenuPopupHelper(mContext, subMenu, mAnchorView);
	subPopup.setCallback(mPresenterCallback);

	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;

	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) {
	if (convertView == null) {
	convertView = mInflater.inflate(ITEM_LAYOUT, parent, false);
	}

	MenuView.ItemView itemView = (MenuView.ItemView) convertView;
	if (mForceShowIcon) {
	((ListMenuItemView) convertView).setForceShowIcon(true);
	}
	itemView.initialize(getItem(position), 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();
	}
	}
	}