xref: /frameworks/support/v7/appcompat/src/android/support/v7/view/menu/MenuPopupHelper.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 android.support.appcompat.view.menu;

import android.support.appcompat.view.MenuItem;

import android.content.Context;
import android.content.res.Resources;
import android.database.DataSetObserver;
import android.os.Parcelable;
import android.support.appcompat.R;
import android.view.KeyEvent;
import android.view.LayoutInflater;
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.ListPopupWindow;
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,
    View.OnAttachStateChangeListener, MenuPresenter {
  private static final String TAG = "MenuPopupHelper";

  static final int ITEM_LAYOUT = R.layout.popup_menu_item_layout;

  private Context mContext;
  private LayoutInflater mInflater;
  private ListPopupWindow mPopup;
  private MenuBuilder mMenu;
  private int mPopupMaxWidth;
  private View mAnchorView;
  private boolean mOverflowOnly;
  private ViewTreeObserver mTreeObserver;

  private MenuAdapter mAdapter;

  private Callback mPresenterCallback;

  boolean mForceShowIcon;

  private ViewGroup mMeasureParent;

  public MenuPopupHelper(Context context, MenuBuilder menu) {
    this(context, menu, null, false);
  }

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

  public MenuPopupHelper(Context context, MenuBuilder menu,
                         View anchorView, boolean overflowOnly) {
    mContext = context;
    mInflater = LayoutInflater.from(context);
    mMenu = menu;
    mOverflowOnly = overflowOnly;

    final Resources res = context.getResources();
    mPopupMaxWidth = Math.max(res.getDisplayMetrics().widthPixels / 2,
        res.getDimensionPixelSize(R.dimen.config_prefDialogWidth));

    mAnchorView = anchorView;

    menu.addMenuPresenter(this);
  }

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

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

  public void show() {
    if (!tryShow()) {
      throw new IllegalStateException("MenuPopupHelper cannot be used without an anchor");
    }
  }

  public boolean tryShow() {
    mPopup = new ListPopupWindow(mContext, null, R.attr.popupMenuStyle);
    mPopup.setOnDismissListener(this);
    mPopup.setOnItemClickListener(this);

    mAdapter = new MenuAdapter(mMenu);
    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);
      anchor.addOnAttachStateChangeListener(this);
      mPopup.setAnchorView(anchor);
    } else {
      return false;
    }

    mPopup.setContentWidth(Math.min(measureContentWidth(mAdapter), mPopupMaxWidth));
    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;
    }
    mAnchorView.removeOnAttachStateChangeListener(this);
  }

  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(ListAdapter adapter) {
    // Menus don't tend to be long, so this is more sane than it looks.
    int width = 0;
    View itemView = null;
    int itemType = 0;
    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);
      width = Math.max(width, itemView.getMeasuredWidth());
    }
    return width;
  }

  @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 onViewAttachedToWindow(View v) {
  }

  @Override
  public void onViewDetachedFromWindow(View v) {
    if (mTreeObserver != null) {
      if (!mTreeObserver.isAlive()) mTreeObserver = v.getViewTreeObserver();
      mTreeObserver.removeGlobalOnLayoutListener(this);
    }
    v.removeOnAttachStateChangeListener(this);
  }

  @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) {
    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, false);
      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();
    }
  }
}