Java tutorial
/* 50AH-code ========= 50 Android Hacks (http://manning.com/sessa/) book source code Copyright (c) 2012 Manning Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* * Copyright (C) 2011 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 com.actionbarsherlock.internal.view.menu; import java.util.ArrayList; import android.content.Context; import android.os.Build; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; /** * Base class for MenuPresenters that have a consistent container view and item * views. Behaves similarly to an AdapterView in that existing item views will * be reused if possible when items change. */ public abstract class BaseMenuPresenter implements MenuPresenter { private static final boolean IS_HONEYCOMB = Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB; protected Context mSystemContext; protected Context mContext; protected MenuBuilder mMenu; protected LayoutInflater mSystemInflater; protected LayoutInflater mInflater; private Callback mCallback; private int mMenuLayoutRes; private int mItemLayoutRes; protected MenuView mMenuView; private int mId; /** * Construct a new BaseMenuPresenter. * * @param context Context for generating system-supplied views * @param menuLayoutRes Layout resource ID for the menu container view * @param itemLayoutRes Layout resource ID for a single item view */ public BaseMenuPresenter(Context context, int menuLayoutRes, int itemLayoutRes) { mSystemContext = context; mSystemInflater = LayoutInflater.from(context); mMenuLayoutRes = menuLayoutRes; mItemLayoutRes = itemLayoutRes; } @Override public void initForMenu(Context context, MenuBuilder menu) { mContext = context; mInflater = LayoutInflater.from(mContext); mMenu = menu; } @Override public MenuView getMenuView(ViewGroup root) { if (mMenuView == null) { mMenuView = (MenuView) mSystemInflater.inflate(mMenuLayoutRes, root, false); mMenuView.initialize(mMenu); updateMenuView(true); } return mMenuView; } /** * Reuses item views when it can */ public void updateMenuView(boolean cleared) { final ViewGroup parent = (ViewGroup) mMenuView; if (parent == null) return; int childIndex = 0; if (mMenu != null) { mMenu.flagActionItems(); ArrayList<MenuItemImpl> visibleItems = mMenu.getVisibleItems(); final int itemCount = visibleItems.size(); for (int i = 0; i < itemCount; i++) { MenuItemImpl item = visibleItems.get(i); if (shouldIncludeItem(childIndex, item)) { final View convertView = parent.getChildAt(childIndex); final MenuItemImpl oldItem = convertView instanceof MenuView.ItemView ? ((MenuView.ItemView) convertView).getItemData() : null; final View itemView = getItemView(item, convertView, parent); if (item != oldItem) { // Don't let old states linger with new data. itemView.setPressed(false); if (IS_HONEYCOMB) itemView.jumpDrawablesToCurrentState(); } if (itemView != convertView) { addItemView(itemView, childIndex); } childIndex++; } } } // Remove leftover views. while (childIndex < parent.getChildCount()) { if (!filterLeftoverView(parent, childIndex)) { childIndex++; } } } /** * Add an item view at the given index. * * @param itemView View to add * @param childIndex Index within the parent to insert at */ protected void addItemView(View itemView, int childIndex) { final ViewGroup currentParent = (ViewGroup) itemView.getParent(); if (currentParent != null) { currentParent.removeView(itemView); } ((ViewGroup) mMenuView).addView(itemView, childIndex); } /** * Filter the child view at index and remove it if appropriate. * @param parent Parent to filter from * @param childIndex Index to filter * @return true if the child view at index was removed */ protected boolean filterLeftoverView(ViewGroup parent, int childIndex) { parent.removeViewAt(childIndex); return true; } public void setCallback(Callback cb) { mCallback = cb; } /** * Create a new item view that can be re-bound to other item data later. * * @return The new item view */ public MenuView.ItemView createItemView(ViewGroup parent) { return (MenuView.ItemView) mSystemInflater.inflate(mItemLayoutRes, parent, false); } /** * Prepare an item view for use. See AdapterView for the basic idea at work here. * This may require creating a new item view, but well-behaved implementations will * re-use the view passed as convertView if present. The returned view will be populated * with data from the item parameter. * * @param item Item to present * @param convertView Existing view to reuse * @param parent Intended parent view - use for inflation. * @return View that presents the requested menu item */ public View getItemView(MenuItemImpl item, View convertView, ViewGroup parent) { MenuView.ItemView itemView; if (convertView instanceof MenuView.ItemView) { itemView = (MenuView.ItemView) convertView; } else { itemView = createItemView(parent); } bindItemView(item, itemView); return (View) itemView; } /** * Bind item data to an existing item view. * * @param item Item to bind * @param itemView View to populate with item data */ public abstract void bindItemView(MenuItemImpl item, MenuView.ItemView itemView); /** * Filter item by child index and item data. * * @param childIndex Indended presentation index of this item * @param item Item to present * @return true if this item should be included in this menu presentation; false otherwise */ public boolean shouldIncludeItem(int childIndex, MenuItemImpl item) { return true; } public void onCloseMenu(MenuBuilder menu, boolean allMenusAreClosing) { if (mCallback != null) { mCallback.onCloseMenu(menu, allMenusAreClosing); } } public boolean onSubMenuSelected(SubMenuBuilder menu) { if (mCallback != null) { return mCallback.onOpenSubMenu(menu); } return false; } public boolean flagActionItems() { return false; } public boolean expandItemActionView(MenuBuilder menu, MenuItemImpl item) { return false; } public boolean collapseItemActionView(MenuBuilder menu, MenuItemImpl item) { return false; } public int getId() { return mId; } public void setId(int id) { mId = id; } }