org.openintents.shopping.ui.ShoppingActivity.java Source code

Java tutorial

Introduction

Here is the source code for org.openintents.shopping.ui.ShoppingActivity.java

Source

/* 
 * Copyright (C) 2007-2010 OpenIntents.org
 *
 * 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.openintents.shopping.ui;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProviderInfo;
import android.content.ActivityNotFoundException;
import android.content.ComponentName;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.res.Configuration;
import android.database.ContentObserver;
import android.database.Cursor;
import android.database.DataSetObserver;
import android.hardware.SensorListener;
import android.hardware.SensorManager;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v4.app.ActionBarDrawerToggle;
import android.support.v4.view.ActionProvider;
import android.support.v4.view.MenuItemCompat;
import android.support.v4.widget.DrawerLayout;
import android.text.Editable;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.GestureDetector;
import android.view.GestureDetector.SimpleOnGestureListener;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MenuItem.OnMenuItemClickListener;
import android.view.MotionEvent;
import android.view.SubMenu;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnKeyListener;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.AdapterView;
import android.widget.AdapterView.AdapterContextMenuInfo;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.ArrayAdapter;
import android.widget.AutoCompleteTextView;
import android.widget.Button;
import android.widget.CursorAdapter;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListAdapter;
import android.widget.ListView;
import android.widget.SimpleCursorAdapter;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;
import android.widget.WrapperListAdapter;

import com.pollfish.constants.Position;
import com.pollfish.main.PollFish;

import org.openintents.OpenIntents;
import org.openintents.distribution.DistributionLibraryFragmentActivity;
import org.openintents.distribution.DownloadOIAppDialog;
import org.openintents.intents.GeneralIntents;
import org.openintents.intents.ShoppingListIntents;
import org.openintents.provider.Alert;
import org.openintents.shopping.BuildConfig;
import org.openintents.shopping.LogConstants;
import org.openintents.shopping.R;
import org.openintents.shopping.library.provider.ShoppingContract;
import org.openintents.shopping.library.provider.ShoppingContract.Contains;
import org.openintents.shopping.library.provider.ShoppingContract.ContainsFull;
import org.openintents.shopping.library.provider.ShoppingContract.Items;
import org.openintents.shopping.library.provider.ShoppingContract.Lists;
import org.openintents.shopping.library.provider.ShoppingContract.Status;
import org.openintents.shopping.library.provider.ShoppingContract.Stores;
import org.openintents.shopping.library.util.PriceConverter;
import org.openintents.shopping.library.util.ShoppingUtils;
import org.openintents.shopping.ui.dialog.DialogActionListener;
import org.openintents.shopping.ui.dialog.EditItemDialog;
import org.openintents.shopping.ui.dialog.EditItemDialog.FieldType;
import org.openintents.shopping.ui.dialog.EditItemDialog.OnItemChangedListener;
import org.openintents.shopping.ui.dialog.NewListDialog;
import org.openintents.shopping.ui.dialog.RenameListDialog;
import org.openintents.shopping.ui.dialog.ThemeDialog;
import org.openintents.shopping.ui.dialog.ThemeDialog.ThemeDialogListener;
import org.openintents.shopping.ui.widget.ActionableToastBar;
import org.openintents.shopping.ui.widget.QuickSelectMenu;
import org.openintents.shopping.ui.widget.ShoppingItemsView;
import org.openintents.shopping.ui.widget.ShoppingItemsView.ActionBarListener;
import org.openintents.shopping.ui.widget.ShoppingItemsView.DragListener;
import org.openintents.shopping.ui.widget.ShoppingItemsView.DropListener;
import org.openintents.shopping.ui.widget.ShoppingItemsView.OnCustomClickListener;
import org.openintents.shopping.widgets.CheckItemsWidget;
import org.openintents.util.MenuIntentOptionsWithIcons;
import org.openintents.util.ShakeSensorListener;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;

/**
 * Displays a shopping list.
 */
public class ShoppingActivity extends DistributionLibraryFragmentActivity implements ThemeDialogListener,
        OnCustomClickListener, ActionBarListener, OnItemChangedListener, UndoListener { // implements
    // AdapterView.OnItemClickListener
    // {

    /**
     * TAG for logging.
     */
    private static final String TAG = "ShoppingActivity";
    private static final boolean debug = false || LogConstants.debug;
    private ToggleBoughtInputMethod toggleBoughtInputMethod;

    public class MyGestureDetector extends SimpleOnGestureListener {
        private static final float DISTANCE_DIP = 16.0f;
        private static final float PATH_DIP = 40.0f;
        // convert dip measurements to pixels
        final float scale = getResources().getDisplayMetrics().density;
        int scaledDistance = (int) (DISTANCE_DIP * scale + 0.5f);
        int scaledPath = (int) (PATH_DIP * scale + 0.5f);

        // For more information about touch gestures and screens support, see:
        // http://developer.android.com/resources/articles/gestures.html
        // http://developer.android.com/reference/android/gesture/package-summary.html
        // http://developer.android.com/guide/practices/screens_support.html try
        // {

        @Override
        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
            if (e1 == null || e2 == null) {
                return false;
            }

            try {
                DisplayMetrics dm = getResources().getDisplayMetrics();

                int REL_SWIPE_MIN_DISTANCE = (int) (SWIPE_MIN_DISTANCE * dm.densityDpi / 160.0f);
                int REL_SWIPE_MAX_OFF_PATH = (int) (SWIPE_MAX_OFF_PATH * dm.densityDpi / 160.0f);
                int REL_SWIPE_THRESHOLD_VELOCITY = (int) (SWIPE_THRESHOLD_VELOCITY * dm.densityDpi / 160.0f);

                if (Math.abs(e1.getY() - e2.getY()) > REL_SWIPE_MAX_OFF_PATH) {
                    return false;
                }
                // right to left swipe
                if (e1.getX() - e2.getX() > REL_SWIPE_MIN_DISTANCE
                        && Math.abs(velocityX) > REL_SWIPE_THRESHOLD_VELOCITY) {
                    Toast.makeText(ShoppingActivity.this, "Left Swipe", Toast.LENGTH_SHORT).show();
                    changeList(-1);
                } else if (e2.getX() - e1.getX() > REL_SWIPE_MIN_DISTANCE
                        && Math.abs(velocityX) > REL_SWIPE_THRESHOLD_VELOCITY) {
                    Toast.makeText(ShoppingActivity.this, "Right Swipe", Toast.LENGTH_SHORT).show();
                    changeList(1);
                }
            } catch (Exception e) {
                // nothing
            }
            return false;
        }

    }

    private static final int SWIPE_MIN_DISTANCE = 120;
    private static final int SWIPE_MAX_OFF_PATH = 250;
    private static final int SWIPE_THRESHOLD_VELOCITY = 200;

    private static final int MENU_NEW_LIST = Menu.FIRST;
    private static final int MENU_CLEAN_UP_LIST = Menu.FIRST + 1;
    private static final int MENU_DELETE_LIST = Menu.FIRST + 2;

    private static final int MENU_SHARE = Menu.FIRST + 3;
    private static final int MENU_THEME = Menu.FIRST + 4;

    private static final int MENU_ADD_LOCATION_ALERT = Menu.FIRST + 5;

    private static final int MENU_RENAME_LIST = Menu.FIRST + 6;

    private static final int MENU_MARK_ITEM = Menu.FIRST + 7;
    private static final int MENU_EDIT_ITEM = Menu.FIRST + 8; // includes rename
    private static final int MENU_DELETE_ITEM = Menu.FIRST + 9;

    private static final int MENU_INSERT_FROM_EXTRAS = Menu.FIRST + 10;
    private static final int MENU_COPY_ITEM = Menu.FIRST + 11;
    private static final int MENU_SORT_LIST = Menu.FIRST + 12;
    private static final int MENU_SEARCH_ADD = Menu.FIRST + 13;

    // TODO: obsolete pick items button, now in drawer
    private static final int MENU_PICK_ITEMS = Menu.FIRST + 14;

    // TODO: Implement "select list" action
    // that can be called by other programs.
    // private static final int MENU_SELECT_LIST = Menu.FIRST + 15; // select a
    // shopping list
    private static final int MENU_PREFERENCES = Menu.FIRST + 17;
    private static final int MENU_SEND = Menu.FIRST + 18;
    private static final int MENU_REMOVE_ITEM_FROM_LIST = Menu.FIRST + 19;
    private static final int MENU_MOVE_ITEM = Menu.FIRST + 20;
    private static final int MENU_MARK_ALL_ITEMS = Menu.FIRST + 21;
    private static final int MENU_ITEM_STORES = Menu.FIRST + 22;
    private static final int MENU_UNMARK_ALL_ITEMS = Menu.FIRST + 23;
    private static final int MENU_SYNC_WEAR = Menu.FIRST + 25;

    private static final int MENU_DISTRIBUTION_START = Menu.FIRST + 100; // MUST BE LAST

    private static final int DIALOG_ABOUT = 1;
    // private static final int DIALOG_TEXT_ENTRY = 2;
    private static final int DIALOG_NEW_LIST = 2;
    private static final int DIALOG_RENAME_LIST = 3;
    private static final int DIALOG_EDIT_ITEM = 4;
    private static final int DIALOG_DELETE_ITEM = 5;
    private static final int DIALOG_THEME = 6;
    public static final int DIALOG_GET_FROM_MARKET = 7;

    private static final int DIALOG_DISTRIBUTION_START = 100; // MUST BE LAST

    private static final int REQUEST_CODE_CATEGORY_ALTERNATIVE = 1;
    private static final int REQUEST_PICK_LIST = 2;

    public static final int LOADER_TOTALS = 0;
    public static final int LOADER_ITEMS = 1;

    /**
     * The main activity.
     * <p/>
     * Displays the shopping list that was used last time.
     */
    private static final int STATE_MAIN = 0;

    /**
     * VIEW action on a item/list URI.
     */
    private static final int STATE_VIEW_LIST = 1;

    /**
     * PICK action on an dir/item URI.
     */
    private static final int STATE_PICK_ITEM = 2;

    /**
     * GET_CONTENT action on an item/item URI.
     */
    private static final int STATE_GET_CONTENT_ITEM = 3;

    /**
     * Current state
     */
    private int mState;

    /*
     * Value of PreferenceActivity.updateCount last time we called fillItems().
     */
    private int lastAppliedPrefChange = -1;

    /**
     * mode: separate dialog to add items from existing list
     */
    public static final int MODE_PICK_ITEMS_DLG = 3;

    /**
     * mode: add items from existing list
     */
    public static final int MODE_ADD_ITEMS = 2;

    /**
     * mode: I am in the shop
     */
    public static final int MODE_IN_SHOP = 1;

    private boolean mEditingFilter = false;

    /**
     * URI of current list
     */
    private Uri mListUri;

    /**
     * URI of selected item
     */
    private Uri mItemUri;

    /**
     * URI of current list and item
     */
    private Uri mListItemUri;

    /**
     * Definition of the requestCode for the subactivity.
     */
    static final private int SUBACTIVITY_LIST_SHARE_SETTINGS = 0;

    /**
     * Definition for message handler:
     */
    static final private int MESSAGE_UPDATE_CURSORS = 1;

    /**
     * Update interval for automatic requires.
     * <p/>
     * (Workaround since ContentObserver does not work.)
     */
    private int mUpdateInterval;

    private boolean mUpdating;

    /**
     * The items to add to the shopping list.
     * <p/>
     * Received as a string array list in the intent extras.
     */
    private List<String> mExtraItems;

    /**
     * The quantities for items to add to the shopping list.
     * <p/>
     * Received as a string array list in the intent extras.
     */
    private List<String> mExtraQuantities;

    /**
     * The prices for items to add to the shopping list.
     * <p/>
     * Received as a string array list in the intent extras.
     */
    private List<String> mExtraPrices;

    /**
     * The barcodes for items to add to the shopping list.
     * <p/>
     * Received as a string array list in the intent extras.
     */
    private List<String> mExtraBarcodes;

    /**
     * The list URI received together with intent extras.
     */
    private Uri mExtraListUri;

    /**
     * Private members connected to list of shopping lists
     */
    // Temp - making it generic for tablet compatibility
    private AdapterView mShoppingListsView;
    private Cursor mCursorShoppingLists;
    private static final String[] mStringListFilter = new String[] { Lists._ID, Lists.NAME, Lists.IMAGE,
            Lists.SHARE_NAME, Lists.SHARE_CONTACTS, Lists.SKIN_BACKGROUND };
    private static final int mStringListFilterID = 0;
    private static final int mStringListFilterNAME = 1;
    private static final int mStringListFilterIMAGE = 2;
    private static final int mStringListFilterSHARENAME = 3;
    private static final int mStringListFilterSHARECONTACTS = 4;
    private static final int mStringListFilterSKINBACKGROUND = 5;

    private ShoppingItemsView mItemsView;
    private DrawerLayout mDrawerLayout;
    private ListView mDrawerListsView;
    private ActionBarDrawerToggle mDrawerToggle;
    private CharSequence mTitle, mDrawerTitle, mSubTitle;
    protected ActionableToastBar mToastBar;

    // private Cursor mCursorItems;

    public static final String[] PROJECTION_ITEMS = new String[] { ContainsFull._ID, ContainsFull.ITEM_NAME,
            ContainsFull.ITEM_IMAGE, ContainsFull.ITEM_TAGS, ContainsFull.ITEM_PRICE, ContainsFull.QUANTITY,
            ContainsFull.STATUS, ContainsFull.ITEM_ID, ContainsFull.SHARE_CREATED_BY,
            ContainsFull.SHARE_MODIFIED_BY, ContainsFull.PRIORITY, ContainsFull.ITEM_HAS_NOTE,
            ContainsFull.ITEM_UNITS };
    static final int mStringItemsCONTAINSID = 0;
    public static final int mStringItemsITEMNAME = 1;
    static final int mStringItemsITEMIMAGE = 2;
    public static final int mStringItemsITEMTAGS = 3;
    public static final int mStringItemsITEMPRICE = 4;
    public static final int mStringItemsQUANTITY = 5;
    public static final int mStringItemsSTATUS = 6;
    public static final int mStringItemsITEMID = 7;
    private static final int mStringItemsSHARECREATEDBY = 8;
    private static final int mStringItemsSHAREMODIFIEDBY = 9;
    public static final int mStringItemsPRIORITY = 10;
    public static final int mStringItemsITEMHASNOTE = 11;
    public static final int mStringItemsITEMUNITS = 12;

    private LinearLayout.LayoutParams mLayoutParamsItems;
    private int mAllowedListHeight; // Height for the list allowed in this view.

    private AutoCompleteTextView mEditText;
    private Button mButton;
    private View mAddPanel = null;
    private Button mStoresFilterButton = null;
    private Button mTagsFilterButton = null;
    private Button mShoppingListsFilterButton = null;

    protected Context mDialogContext;

    // TODO: Set up state information for onFreeze(), ...
    // State data to be stored when freezing:
    private final String ORIGINAL_ITEM = "original item";

    // private static final String BUNDLE_TEXT_ENTRY_MENU = "text entry menu";
    // private static final String BUNDLE_CURSOR_ITEMS_POSITION =
    // "cursor items position";
    private static final String BUNDLE_ITEM_URI = "item uri";
    private static final String BUNDLE_RELATION_URI = "relation_uri";
    private static final String BUNDLE_MODE = "mode";
    private static final String BUNDLE_MODE_BEFORE_SEARCH = "mode_before_search";

    private String mSortOrder;

    private ListSortActionProvider mListSortActionProvider;

    // Skins --------------------------

    private boolean usingListSpinner() {

        // not sure if the version should still be checked...
        // what should happen on a Froyo tablet? Still, seems
        // likely that the condition below will do something safe.
        //
        // if (Build.VERSION.SDK_INT<Build.VERSION_CODES.HONEYCOMB)
        // return true;

        // The most foolproof thing we can check here seems to be the
        // existence of the resource used in tablet mode. If the list
        // fragment exists, then Android thinks we are running on
        // something tablet-like.
        return (findViewById(android.R.id.list) == null);

    }

    /**
     * Remember position for screen orientation change.
     */
    // int mEditItemPosition = -1;

    // public int mPriceVisibility;
    // private int mTagsVisibility;
    private SensorManager mSensorManager;
    private SensorListener mMySensorListener = new ShakeSensorListener() {

        @Override
        public void onShake() {
            // Provide some visual feedback.
            Animation shake = AnimationUtils.loadAnimation(ShoppingActivity.this, R.anim.shake);
            findViewById(R.id.background).startAnimation(shake);

            cleanupList();
        }

    };

    /**
     * isActive is true only after onResume() and before onPause().
     */
    private boolean mIsActive = false;

    /**
     * Whether to use the sensor for shake.
     */
    private boolean mUseSensor = false;
    private Uri mRelationUri;
    private int mMoveItemPosition;

    private EditItemDialog.FieldType mEditItemFocusField = EditItemDialog.FieldType.ITEMNAME;
    private GestureDetector mGestureDetector;
    private View.OnTouchListener mGestureListener;

    /**
     * Called when the activity is first created.
     */
    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        if (debug) {
            Log.d(TAG, "Shopping list onCreate()");
        }

        mSortOrder = PreferenceActivity.getShoppingListSortOrderFromPrefs(this);

        mDistribution.setFirst(MENU_DISTRIBUTION_START, DIALOG_DISTRIBUTION_START);

        // Check whether EULA has been accepted
        // or information about new version can be presented.
        if (false && mDistribution.showEulaOrNewVersion()) {
            return;
        }

        setContentView(R.layout.activity_shopping);

        // mEditItemPosition = -1;

        // Automatic requeries (once a second)
        mUpdateInterval = 2000;
        mUpdating = false;

        // General Uris:
        mListUri = ShoppingContract.Lists.CONTENT_URI;
        mItemUri = ShoppingContract.Items.CONTENT_URI;
        mListItemUri = ShoppingContract.Items.CONTENT_URI;

        int defaultShoppingList = getLastUsedListFromPrefs();

        // Handle the calling intent
        final Intent intent = getIntent();
        final String type = intent.resolveType(this);
        final String action = intent.getAction();

        if (action == null) {
            // Main action
            mState = STATE_MAIN;

            mListUri = Uri.withAppendedPath(ShoppingContract.Lists.CONTENT_URI, "" + defaultShoppingList);

            intent.setData(mListUri);
        } else if (Intent.ACTION_MAIN.equals(action)) {
            // Main action
            mState = STATE_MAIN;

            mListUri = Uri.withAppendedPath(ShoppingContract.Lists.CONTENT_URI, "" + defaultShoppingList);

            intent.setData(mListUri);

        } else if (Intent.ACTION_VIEW.equals(action)) {
            mState = STATE_VIEW_LIST;

            setListUriFromIntent(intent.getData(), type);
        } else if (Intent.ACTION_INSERT.equals(action)) {

            mState = STATE_VIEW_LIST;

            setListUriFromIntent(intent.getData(), type);

        } else if (Intent.ACTION_PICK.equals(action)) {
            mState = STATE_PICK_ITEM;

            mListUri = Uri.withAppendedPath(ShoppingContract.Lists.CONTENT_URI, "" + defaultShoppingList);
        } else if (Intent.ACTION_GET_CONTENT.equals(action)) {
            mState = STATE_GET_CONTENT_ITEM;

            mListUri = Uri.withAppendedPath(ShoppingContract.Lists.CONTENT_URI, "" + defaultShoppingList);
        } else if (GeneralIntents.ACTION_INSERT_FROM_EXTRAS.equals(action)) {
            if (ShoppingListIntents.TYPE_STRING_ARRAYLIST_SHOPPING.equals(type)) {
                /*
                 * Need to insert new items from a string array in the intent
                * extras Use main action but add an item to the options menu
                * for adding extra items
                */
                getShoppingExtras(intent);
                mState = STATE_MAIN;
                mListUri = Uri.withAppendedPath(ShoppingContract.Lists.CONTENT_URI, "" + defaultShoppingList);
                intent.setData(mListUri);
            } else if (intent.getDataString().startsWith(ShoppingContract.Lists.CONTENT_URI.toString())) {
                // Somewhat quick fix to pass data from ShoppingListsActivity to
                // this activity.

                // We received a valid shopping list URI:
                mListUri = intent.getData();

                getShoppingExtras(intent);
                mState = STATE_MAIN;
                intent.setData(mListUri);
            }
        } else {
            // Unknown action.
            Log.e(TAG, "Shopping: Unknown action, exiting");
            finish();
            return;
        }

        // hook up all buttons, lists, edit text:
        createView();

        // populate the lists
        fillListFilter();

        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
        getSupportActionBar().setHomeButtonEnabled(true);

        // Get last part of URI:
        int selectList;
        try {
            selectList = Integer.parseInt(mListUri.getLastPathSegment());
        } catch (NumberFormatException e) {
            selectList = defaultShoppingList;
        }

        // select the default shopping list at the beginning:
        setSelectedListId(selectList);

        if (icicle != null) {
            String prevText = icicle.getString(ORIGINAL_ITEM);
            if (prevText != null) {
                mEditText.setTextKeepState(prevText);
            }
            // mTextEntryMenu = icicle.getInt(BUNDLE_TEXT_ENTRY_MENU);
            // mEditItemPosition = icicle.getInt(BUNDLE_CURSOR_ITEMS_POSITION);
            mItemUri = Uri.parse(icicle.getString(BUNDLE_ITEM_URI));
            List<String> pathSegs = mItemUri.getPathSegments();
            int num = pathSegs.size();
            mListItemUri = Uri.withAppendedPath(mListUri, pathSegs.get(num - 1));
            if (icicle.containsKey(BUNDLE_RELATION_URI)) {
                mRelationUri = Uri.parse(icicle.getString(BUNDLE_RELATION_URI));
            }
            mItemsView.mMode = icicle.getInt(BUNDLE_MODE);
            mItemsView.mModeBeforeSearch = icicle.getInt(BUNDLE_MODE_BEFORE_SEARCH);
        }

        // set focus to the edit line:
        mEditText.requestFocus();

        // TODO remove initFromPreferences from onCreate
        // we need it in resume to update after settings have changed
        initFromPreferences();
        // now update title and fill all items
        onModeChanged();

        mItemsView.setActionBarListener(this);
        mItemsView.setUndoListener(this);

        if ("myo".equals(BuildConfig.FLAVOR)) {
            try {
                Class myoToggleBoughtInputMethod = Class
                        .forName("org.openintents.shopping.ui.MyoToggleBoughtInputMethod");
                Constructor constructor = myoToggleBoughtInputMethod
                        .getConstructor(new Class[] { ShoppingActivity.class, mItemsView.getClass() });
                toggleBoughtInputMethod = (ToggleBoughtInputMethod) constructor
                        .newInstance(new Object[] { this, mItemsView });
            } catch (ClassNotFoundException e) {
            } catch (NoSuchMethodException e) {
            } catch (InvocationTargetException e) {
            } catch (InstantiationException e) {
            } catch (IllegalAccessException e) {
            }
        }
    }

    private void setListUriFromIntent(Uri data, String type) {
        if (ShoppingContract.ITEM_TYPE.equals(type)) {
            mListUri = ShoppingUtils.getListForItem(this, data.getLastPathSegment());
        } else if (data != null) {
            mListUri = data;
        }
    }

    @Override
    protected void onPostCreate(Bundle savedInstanceState) {
        super.onPostCreate(savedInstanceState);
        if (mDrawerToggle != null) {
            // Sync the toggle state after onRestoreInstanceState has occurred.
            mDrawerToggle.syncState();
        }
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        if (mDrawerToggle != null) {
            mDrawerToggle.onConfigurationChanged(newConfig);
        }
    }

    @Override
    public void onStop() {
        super.onStop();
        updateWidgets();
    }

    private void updateWidgets() {
        AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(this);
        int[] a = appWidgetManager
                .getAppWidgetIds(new ComponentName(this.getPackageName(), CheckItemsWidget.class.getName()));
        List<AppWidgetProviderInfo> b = appWidgetManager.getInstalledProviders();
        for (AppWidgetProviderInfo i : b) {
            if (i.provider.getPackageName().equals(this.getPackageName())) {
                a = appWidgetManager.getAppWidgetIds(i.provider);
                new CheckItemsWidget().onUpdate(this, appWidgetManager, a);
            }
        }
    }

    // used at startup, otherwise use getSelectedListId
    private int getLastUsedListFromPrefs() {

        SharedPreferences sp = getSharedPreferences("org.openintents.shopping_preferences", MODE_PRIVATE);

        return sp.getInt(PreferenceActivity.PREFS_LASTUSED, 1);
    }

    private void initFromPreferences() {

        SharedPreferences sp = getSharedPreferences("org.openintents.shopping_preferences", MODE_PRIVATE);

        if (mItemsView != null) {
            // UGLY WORKAROUND:
            // On screen orientation changes, fillItems() is called twice.
            // That is why we have to set the list position twice.
            // Nov14: Seems to not be required anymore, so change to 1 to
            // avoid unwanted scrolling when marking items.
            mItemsView.mUpdateLastListPosition = 1;

            mItemsView.mLastListPosition = sp.getInt(PreferenceActivity.PREFS_LASTLIST_POSITION, 0);
            mItemsView.mLastListTop = sp.getInt(PreferenceActivity.PREFS_LASTLIST_TOP, 0);

            if (debug) {
                Log.d(TAG, "Load list position: pos: " + mItemsView.mLastListPosition + ", top: "
                        + mItemsView.mLastListTop);
            }

            // selected list must be set after changing ordering
            String sortOrder = PreferenceActivity.getShoppingListSortOrderFromPrefs(this);
            if (!mSortOrder.equals(sortOrder)) {
                mSortOrder = sortOrder;
                fillListFilter();
                setSelectedListId(getLastUsedListFromPrefs());
            } else if (getSelectedListId() == -1) {
                setSelectedListId(getLastUsedListFromPrefs());
            }
        }

        if (sp.getBoolean(PreferenceActivity.PREFS_SCREENLOCK, PreferenceActivity.PREFS_SCREENLOCK_DEFAULT)) {
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        }

        if (mItemsView != null) {
            if (sp.getBoolean(PreferenceActivity.PREFS_SHOW_PRICE, PreferenceActivity.PREFS_SHOW_PRICE_DEFAULT)) {
                mItemsView.mPriceVisibility = View.VISIBLE;
            } else {
                mItemsView.mPriceVisibility = View.GONE;
            }

            if (sp.getBoolean(PreferenceActivity.PREFS_SHOW_TAGS, PreferenceActivity.PREFS_SHOW_TAGS_DEFAULT)) {
                mItemsView.mTagsVisibility = View.VISIBLE;
            } else {
                mItemsView.mTagsVisibility = View.GONE;
            }
            if (sp.getBoolean(PreferenceActivity.PREFS_SHOW_QUANTITY,
                    PreferenceActivity.PREFS_SHOW_QUANTITY_DEFAULT)) {
                mItemsView.mQuantityVisibility = View.VISIBLE;
            } else {
                mItemsView.mQuantityVisibility = View.GONE;
            }
            if (sp.getBoolean(PreferenceActivity.PREFS_SHOW_UNITS, PreferenceActivity.PREFS_SHOW_UNITS_DEFAULT)) {
                mItemsView.mUnitsVisibility = View.VISIBLE;
            } else {
                mItemsView.mUnitsVisibility = View.GONE;
            }
            if (sp.getBoolean(PreferenceActivity.PREFS_SHOW_PRIORITY,
                    PreferenceActivity.PREFS_SHOW_PRIORITY_DEFAULT)) {
                mItemsView.mPriorityVisibility = View.VISIBLE;
            } else {
                mItemsView.mPriorityVisibility = View.GONE;
            }
        }

        mUseSensor = sp.getBoolean(PreferenceActivity.PREFS_SHAKE, PreferenceActivity.PREFS_SHAKE_DEFAULT);

        boolean nowEditingFilter = sp.getBoolean(PreferenceActivity.PREFS_USE_FILTERS,
                PreferenceActivity.PREFS_USE_FILTERS_DEFAULT);
        if (mStoresFilterButton != null && mEditingFilter != nowEditingFilter) {
            updateFilterWidgets();
            fillItems(false);
        }

        if (PreferenceActivity.getCompletionSettingChanged(this)) {
            fillAutoCompleteTextViewAdapter(mEditText);
        }
    }

    private void registerSensor() {
        if (!mUseSensor) {
            // Don't use sensors
            return;
        }

        if (mItemsView.mMode == MODE_IN_SHOP) {
            if (mSensorManager == null) {
                mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
            }
            mSensorManager.registerListener(mMySensorListener, SensorManager.SENSOR_ACCELEROMETER,
                    SensorManager.SENSOR_DELAY_UI);
        }

    }

    private void unregisterSensor() {
        if (mSensorManager != null) {
            mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
            mSensorManager.unregisterListener(mMySensorListener);
        }
    }

    @Override
    protected void onResume() {
        if (debug) {
            Log.i(TAG, "Shopping list onResume() 1");
        }
        super.onResume();
        if (debug) {
            Log.i(TAG, "Shopping list onResume() 2");
        }

        // Reload preferences, in case something changed
        initFromPreferences();

        mIsActive = true;

        this.setRequestedOrientation(PreferenceActivity.getOrientationFromPrefs(this));

        if (getSelectedListId() != -1) {
            setListTheme(loadListTheme());
            applyListTheme();
            updateTitle();
        }
        mItemsView.onResume();

        // TODO fling disabled for release 1.3.0
        // mGestureDetector = new GestureDetector(new MyGestureDetector());
        // mGestureListener = new OnTouchListener() {
        // public boolean onTouch(View view, MotionEvent e) {
        // if (mGestureDetector.onTouchEvent(e)) {
        // return true;
        // }
        // return false;
        // }
        // };
        // mListItemsView.setOnTouchListener(mGestureListener);

        mEditText.setKeyListener(PreferenceActivity.getCapitalizationKeyListenerFromPrefs(getApplicationContext()));

        if (!mUpdating) {
            mUpdating = true;
            // mHandler.sendMessageDelayed(mHandler.obtainMessage(
            // MESSAGE_UPDATE_CURSORS), mUpdateInterval);
        }

        // OnResume can be called when exiting PreferenceActivity, in
        // which case we might need to refresh the list depending on
        // which settings were changed. We could be smarter about this,
        // but for now refresh if /any/ pref has changed.
        //
        // In phone mode list id is generally not set by now, and there will
        // soon be a fillItems call triggered by updating the list selector.
        // However when the embedded list selector is not being used, now might
        // be a good time to update for pending
        // preference changes.
        if (!usingListSpinner()) {
            fillItems(true);
        } else {
            Log.d(TAG, "Skipping fillItems()");

            // at least add items from extras
            if (mExtraItems != null) {
                insertItemsFromExtras();
            }
        }

        // TODO ???
        /*
         * // Register intent receiver for refresh intents: IntentFilter
        * intentfilter = new IntentFilter(OpenIntents.REFRESH_ACTION);
        * registerReceiver(mIntentReceiver, intentfilter);
        */

        // Items received through intents are added in
        // fillItems().

        registerSensor();

        if (debug) {
            Log.i(TAG, "Shopping list onResume() finished");
        }
    }

    private void updateTitle() {
        // Modify our overall title depending on the mode we are running in.
        // In most cases, "title" is the name of the current list, and subtitle
        // depends on the mode -- shopping vs pick items, for example.

        mTitle = getCurrentListName();
        mSubTitle = getText(R.string.app_name);

        if (mState == STATE_MAIN || mState == STATE_VIEW_LIST) {
            if (PreferenceActivity.getPickItemsInListFromPrefs(getApplicationContext())) {
                // 2 different modes
                if (mItemsView.mMode == MODE_IN_SHOP) {
                    registerSensor();
                } else {
                    mSubTitle = getString(R.string.menu_pick_items);
                    unregisterSensor();
                }
            }
        } else if ((mState == STATE_PICK_ITEM) || (mState == STATE_GET_CONTENT_ITEM)) {
            mSubTitle = (getText(R.string.pick_item));
            setTitleColor(0xFFAAAAFF);
        }

        getSupportActionBar().setTitle(mTitle);
        getSupportActionBar().setSubtitle(mSubTitle);

        // also update the button label
        updateButton();
    }

    private void updateButton() {
        if (mItemsView.mMode == MODE_ADD_ITEMS) {
            String newItem = mEditText.getText().toString();
            if (TextUtils.isEmpty(newItem)) {
                // If in "add items" mode and the text field is empty,
                // set the button text to "Shopping"
                mButton.setText(R.string.menu_start_shopping);
            } else {
                mButton.setText(R.string.add);
            }
        } else {
            mButton.setText(R.string.add);
        }
    }

    private void saveActiveList(boolean savePos) {
        SharedPreferences sp = getSharedPreferences("org.openintents.shopping_preferences", MODE_PRIVATE);
        SharedPreferences.Editor editor = sp.edit();
        // need to do something about the fact that the spinner is driving this
        // even though it isn't always used. also the long vs int is fishy.
        // but for now, just don't overwrite previous setting with -1.
        int list_id = new Long(getSelectedListId()).intValue();
        if (list_id != -1) {
            editor.putInt(PreferenceActivity.PREFS_LASTUSED, list_id);
        }
        // Save position and pixel position of first visible item
        // of current shopping list
        int listposition = mItemsView.getFirstVisiblePosition();
        if (savePos) {
            View v = mItemsView.getChildAt(0);
            int listtop = (v == null) ? 0 : v.getTop();
            if (debug) {
                Log.d(TAG, "Save list position: pos: " + listposition + ", top: " + listtop);
            }

            editor.putInt(PreferenceActivity.PREFS_LASTLIST_POSITION, listposition);
            editor.putInt(PreferenceActivity.PREFS_LASTLIST_TOP, listtop);
        }
        editor.commit();
    }

    /*
     * (non-Javadoc)
     *
     * @see android.app.Activity#onPause()
     */
    @Override
    protected void onPause() {
        // TODO Auto-generated method stub
        super.onPause();
        if (debug) {
            Log.i(TAG, "Shopping list onPause()");
        }
        if (debug) {
            Log.i(TAG, "Spinner: onPause: " + mIsActive);
        }
        mIsActive = false;
        if (debug) {
            Log.i(TAG, "Spinner: onPause: " + mIsActive);
        }

        unregisterSensor();

        saveActiveList(true);
        // TODO ???
        /*
        * // Unregister refresh intent receiver
        * unregisterReceiver(mIntentReceiver);
        */

        mItemsView.onPause();
    }

    public void onDestroy() {
        super.onDestroy();
        if (toggleBoughtInputMethod != null) {
            toggleBoughtInputMethod.release();
        }
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        if (debug) {
            Log.i(TAG, "Shopping list onSaveInstanceState()");
        }

        // Save original text from edit box
        String s = mEditText.getText().toString();
        outState.putString(ORIGINAL_ITEM, s);

        outState.putString(BUNDLE_ITEM_URI, mItemUri.toString());
        if (mRelationUri != null) {
            outState.putString(BUNDLE_RELATION_URI, mRelationUri.toString());
        }
        outState.putInt(BUNDLE_MODE, mItemsView.mMode);
        outState.putInt(BUNDLE_MODE_BEFORE_SEARCH, mItemsView.mMode);
        mUpdating = false;

        // after items have been added through an "insert from extras" the
        // action name should be different to avoid duplicate inserts e.g. on
        // rotation.
        if (mExtraItems == null && GeneralIntents.ACTION_INSERT_FROM_EXTRAS.equals(getIntent().getAction())) {
            setIntent(getIntent().setAction(Intent.ACTION_VIEW));
        }
    }

    /**
     * Hook up buttons, lists, and edittext with functionality.
     */
    private void createView() {

        // Temp-create either Spinner or List based upon the Display
        createList();

        mAddPanel = findViewById(R.id.add_panel);
        mEditText = (AutoCompleteTextView) findViewById(R.id.autocomplete_add_item);

        fillAutoCompleteTextViewAdapter(mEditText);
        mEditText.setThreshold(1);
        mEditText.setOnKeyListener(new OnKeyListener() {

            private int mLastKeyAction = KeyEvent.ACTION_UP;

            public boolean onKey(View v, int keyCode, KeyEvent key) {
                // Shortcut: Instead of pressing the button,
                // one can also press the "Enter" key.
                if (debug) {
                    Log.i(TAG, "Key action: " + key.getAction());
                }
                if (debug) {
                    Log.i(TAG, "Key code: " + keyCode);
                }
                if (keyCode == KeyEvent.KEYCODE_ENTER) {

                    if (mEditText.isPopupShowing()) {
                        mEditText.performCompletion();
                    }

                    // long key press might cause call of duplicate onKey events
                    // with ACTION_DOWN
                    // this would result in inserting an item and showing the
                    // pick list

                    if (key.getAction() == KeyEvent.ACTION_DOWN && mLastKeyAction == KeyEvent.ACTION_UP) {
                        insertNewItem();
                    }

                    mLastKeyAction = key.getAction();
                    return true;
                }
                return false;
            }
        });
        mEditText.addTextChangedListener(new TextWatcher() {

            @Override
            public void afterTextChanged(Editable s) {
                if (mItemsView.mMode == MODE_ADD_ITEMS) {
                    // small optimization: Only care about updating
                    // the button label on each key pressed if we
                    // are in "add items" mode.
                    updateButton();
                }
            }

            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
            }

        });

        mButton = (Button) findViewById(R.id.button_add_item);
        mButton.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                insertNewItem();
            }
        });
        mButton.setOnLongClickListener(new View.OnLongClickListener() {

            @Override
            public boolean onLongClick(View v) {
                if (PreferenceActivity.getAddForBarcode(getApplicationContext()) == false) {
                    if (debug) {
                        Log.v(TAG, "barcode scanner on add button long click disabled");
                    }
                    return false;
                }

                Intent intent = new Intent();
                intent.setData(mListUri);
                intent.setClassName("org.openintents.barcodescanner",
                        "org.openintents.barcodescanner.BarcodeScanner");
                intent.setAction(Intent.ACTION_GET_CONTENT);
                intent.addCategory(Intent.CATEGORY_ALTERNATIVE);
                try {
                    startActivityForResult(intent, REQUEST_CODE_CATEGORY_ALTERNATIVE);
                } catch (ActivityNotFoundException e) {
                    if (debug) {
                        Log.v(TAG, "barcode scanner not found");
                    }
                    showDialog(DIALOG_GET_FROM_MARKET);
                    return false;
                }

                // Instead of calling the class of barcode
                // scanner directly, a more generic approach would
                // be to use a general activity picker.
                //
                // TODO: Implement onActivityResult.
                // Problem: User has to pick activity every time.
                // Choice should be storeable in Stettings.
                // Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
                // intent.setData(mListUri);
                // intent.addCategory(Intent.CATEGORY_ALTERNATIVE);
                //
                // Intent pickIntent = new Intent(Intent.ACTION_PICK_ACTIVITY);
                // pickIntent.putExtra(Intent.EXTRA_INTENT, intent);
                // pickIntent.putExtra(Intent.EXTRA_TITLE,
                // getText(R.string.title_select_item_from));
                // try {
                // startActivityForResult(pickIntent,
                // REQUEST_CODE_CATEGORY_ALTERNATIVE);
                // } catch (ActivityNotFoundException e) {
                // Log.v(TAG, "barcode scanner not found");
                // return false;
                // }
                return true;
            }
        });

        mLayoutParamsItems = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.FILL_PARENT,
                LinearLayout.LayoutParams.WRAP_CONTENT);

        mToastBar = (ActionableToastBar) findViewById(R.id.toast_bar);

        mItemsView = (ShoppingItemsView) findViewById(R.id.list_items);
        mItemsView.setThemedBackground(findViewById(R.id.background));
        mItemsView.setCustomClickListener(this);
        mItemsView.setToastBar(mToastBar);
        mItemsView.initTotals();

        mItemsView.setItemsCanFocus(true);
        mItemsView.setDragListener(new DragListener() {

            @Override
            public void drag(int from, int to) {
                if (debug) {
                    Log.v("DRAG", "" + from + "/" + to);
                }

            }
        });
        mItemsView.setDropListener(new DropListener() {

            @Override
            public void drop(int from, int to) {
                if (debug) {
                    Log.v("DRAG", "" + from + "/" + to);
                }

            }
        });

        mItemsView.setOnItemClickListener(new OnItemClickListener() {

            public void onItemClick(AdapterView parent, View v, int pos, long id) {
                Cursor c = (Cursor) parent.getItemAtPosition(pos);
                onCustomClick(c, pos, EditItemDialog.FieldType.ITEMNAME, v);
                // DO NOT CLOSE THIS CURSOR - IT IS A MANAGED ONE.
                // ---- c.close();
            }

        });

        mItemsView.setOnCreateContextMenuListener(new View.OnCreateContextMenuListener() {

            public void onCreateContextMenu(ContextMenu contextmenu, View view, ContextMenuInfo info) {
                contextmenu.add(0, MENU_EDIT_ITEM, 0, R.string.menu_edit_item).setShortcut('1', 'e');
                contextmenu.add(0, MENU_MARK_ITEM, 0, R.string.menu_mark_item).setShortcut('2', 'm');
                contextmenu.add(0, MENU_ITEM_STORES, 0, R.string.menu_item_stores).setShortcut('3', 's');
                contextmenu.add(0, MENU_REMOVE_ITEM_FROM_LIST, 0, R.string.menu_remove_item).setShortcut('4', 'r');
                contextmenu.add(0, MENU_COPY_ITEM, 0, R.string.menu_copy_item).setShortcut('5', 'c');
                contextmenu.add(0, MENU_DELETE_ITEM, 0, R.string.menu_delete_item).setShortcut('6', 'd');
                contextmenu.add(0, MENU_MOVE_ITEM, 0, R.string.menu_move_item).setShortcut('7', 'l');
            }

        });
    }

    private void createList() {

        mDrawerLayout = (DrawerLayout) findViewById(R.id.drawer_layout);

        mTitle = mDrawerTitle = getTitle();
        if (mDrawerLayout != null) {
            mDrawerToggle = new ActionBarDrawerToggle(this, mDrawerLayout, R.drawable.ic_drawer,
                    R.string.drawer_open, R.string.drawer_close) {

                /**
                 * Called when a drawer has settled in a completely closed state.
                 */
                public void onDrawerClosed(View view) {
                    getSupportActionBar().setTitle(mTitle);
                    getSupportActionBar().setSubtitle(mSubTitle);
                    compat_invalidateOptionsMenu(); // creates call to onPrepareOptionsMenu()
                }

                /**
                 * Called when a drawer has settled in a completely open state.
                 */
                public void onDrawerOpened(View drawerView) {
                    getSupportActionBar().setTitle(mDrawerTitle);
                    getSupportActionBar().setSubtitle(null);
                    compat_invalidateOptionsMenu(); // creates call to onPrepareOptionsMenu()
                }
            };

            // Set the drawer toggle as the DrawerListener
            mDrawerLayout.setDrawerListener(mDrawerToggle);
        }

        mDrawerListsView = (ListView) findViewById(R.id.left_drawer);

        // TODO probably can obsolete the below; tablet mode should also use
        // the drawer rather than a separate fragment
        if (!usingListSpinner()) {

            mShoppingListsView = (ListView) findViewById(android.R.id.list);
            mShoppingListsView.setOnItemSelectedListener(new OnItemSelectedListener() {
                public void onItemSelected(AdapterView parent, View v, int position, long id) {
                    if (debug) {
                        Log.d(TAG, "ListView: onItemSelected");
                    }

                    // Update list cursor:
                    getSelectedListId();

                    // Set the theme based on the selected list:
                    setListTheme(loadListTheme());

                    // If it's the same list we had before, requery only
                    // if a preference has changed since then.
                    fillItems(id == mItemsView.getListId());

                    // Apply the theme after the list has been filled:
                    applyListTheme();

                    updateTitle();

                    ((ListView) mShoppingListsView).setItemChecked(position, true);
                }

                public void onNothingSelected(AdapterView arg0) {
                    if (debug) {
                        Log.d(TAG, "Listview: onNothingSelected: " + mIsActive);
                    }
                    if (mIsActive) {
                        fillItems(false);
                    }
                }
            });

        } else {
            mShoppingListsView = (Spinner) findViewById(R.id.spinner_listfilter);
            mShoppingListsView.setOnItemSelectedListener(new OnItemSelectedListener() {
                public void onItemSelected(AdapterView parent, View v, int position, long id) {
                    if (debug) {
                        Log.d(TAG, "Spinner: onItemSelected");
                    }

                    // Update list cursor:
                    getSelectedListId();

                    // Set the theme based on the selected list:
                    setListTheme(loadListTheme());

                    // If it's the same list we had before, requery only
                    // if a preference has changed since then.
                    fillItems(id == mItemsView.getListId());

                    updateTitle();

                    // Apply the theme after the list has been filled:
                    applyListTheme();
                }

                public void onNothingSelected(AdapterView arg0) {
                    if (debug) {
                        Log.d(TAG, "Spinner: onNothingSelected: " + mIsActive);
                    }
                    if (mIsActive) {
                        fillItems(false);
                    }
                }
            });

            mShoppingListsFilterButton = (Button) findViewById(R.id.listfilter);
            if (mShoppingListsFilterButton != null) {
                mShoppingListsFilterButton.setOnClickListener(new OnClickListener() {

                    @Override
                    public void onClick(View v) {
                        showListFilter(v);
                    }
                });
            }
        }

        mStoresFilterButton = (Button) findViewById(R.id.storefilter);
        mStoresFilterButton.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                showStoresFilter(v);
            }
        });
        mTagsFilterButton = (Button) findViewById(R.id.tagfilter);
        mTagsFilterButton.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                showTagsFilter(v);
            }
        });
    }

    protected void showListFilter(final View v) {
        QuickSelectMenu popup = new QuickSelectMenu(this, v);
        int i_list;

        Menu menu = popup.getMenu();
        if (menu == null) {
            return;
        }

        // get the list of lists
        mCursorShoppingLists.requery();
        int count = mCursorShoppingLists.getCount();
        mCursorShoppingLists.moveToFirst();
        for (i_list = 0; i_list < count; i_list++) {
            String name = mCursorShoppingLists.getString(mStringListFilterNAME);
            menu.add(0, i_list, Menu.NONE, name);
            mCursorShoppingLists.moveToNext();
        }

        popup.setOnItemSelectedListener(new QuickSelectMenu.OnItemSelectedListener() {
            public void onItemSelected(CharSequence name, int pos) {
                setSelectedListPos(pos);
            }
        });

        popup.show();
    }

    protected void showStoresFilter(final View v) {
        QuickSelectMenu popup = new QuickSelectMenu(this, v);

        Menu menu = popup.getMenu();
        if (menu == null) {
            return;
        }
        Cursor c = getContentResolver().query(
                Stores.QUERY_BY_LIST_URI.buildUpon().appendPath(this.mListUri.getLastPathSegment()).build(),
                new String[] { Stores._ID, Stores.NAME }, null, null, "stores.name COLLATE NOCASE ASC");
        int i_store, count = c.getCount();
        if (count == 0) {
            c.deactivate();
            c.close();
            Toast.makeText(this, R.string.no_stores_available, Toast.LENGTH_SHORT).show();
            return;
        }

        // prepend the "no filter" option
        menu.add(0, -1, Menu.NONE, R.string.unfiltered);

        // get the list of stores
        c.moveToFirst();
        for (i_store = 0; i_store < count; i_store++) {
            long id = c.getLong(0);
            String name = c.getString(1);
            menu.add(0, (int) id, Menu.NONE, name);
            c.moveToNext();
        }
        c.deactivate();
        c.close();

        popup.setOnItemSelectedListener(new QuickSelectMenu.OnItemSelectedListener() {
            public void onItemSelected(CharSequence name, int id) {
                // set the selected store filter
                // update the filter summary? not until filter region collapsed.
                ContentValues values = new ContentValues();
                values.put(Lists.STORE_FILTER, (long) id);
                getContentResolver().update(mListUri, values, null, null);
                if (id == -1) {
                    ((Button) v).setText(R.string.stores);
                } else {
                    ((Button) v).setText(name);
                }
                fillItems(false);
            }
        });

        popup.show();
    }

    protected void showTagsFilter(final View v) {
        QuickSelectMenu popup = new QuickSelectMenu(this, v);

        Menu menu = popup.getMenu();
        if (menu == null) {
            return;
        }
        String[] tags = getTaglist(mListUri.getLastPathSegment());
        int i_tag, count = tags.length;

        if (count == 0) {
            Toast.makeText(this, R.string.no_tags_available, Toast.LENGTH_SHORT).show();
            return;
        }

        // prepend the "no filter" option
        menu.add(0, -1, Menu.NONE, R.string.unfiltered);

        for (i_tag = 0; i_tag < count; i_tag++) {
            menu.add(tags[i_tag]);
        }

        popup.setOnItemSelectedListener(new QuickSelectMenu.OnItemSelectedListener() {
            public void onItemSelected(CharSequence name, int id) {
                // set the selected tags filter
                ContentValues values = new ContentValues();
                values.put(Lists.TAGS_FILTER, id == -1 ? "" : (String) name);
                getContentResolver().update(mListUri, values, null, null);
                if (id == -1) {
                    ((Button) v).setText(R.string.tags);
                } else {
                    ((Button) v).setText(name);
                }
                fillItems(false);
            }
        });

        popup.show();
    }

    protected void updateFilterWidgets() {
        mEditingFilter = PreferenceActivity.getUsingFiltersFromPrefs(this);

        mStoresFilterButton.setVisibility(mEditingFilter ? View.VISIBLE : View.GONE);
        mTagsFilterButton.setVisibility(mEditingFilter ? View.VISIBLE : View.GONE);

        boolean showListFilter = mEditingFilter;
        if (!usingListSpinner()) {
            // Tablet mode: always show ListView
            showListFilter = false;
        }
        if (mShoppingListsFilterButton != null) {
            mShoppingListsFilterButton.setVisibility(View.GONE);
        }
        // spinner goes the opposite way
        if (mShoppingListsView != null) {
            mShoppingListsView.setVisibility(View.GONE);
        }

        if (mEditingFilter) {
            String storeName = ShoppingUtils.getListFilterStoreName(this, mListUri);
            if (storeName != null) {
                mStoresFilterButton.setText(storeName);
            } else {
                mStoresFilterButton.setText(R.string.stores);
            }
            String tagFilter = ShoppingUtils.getListTagsFilter(this, mListUri);
            if (tagFilter != null) {
                mTagsFilterButton.setText(tagFilter);
            } else {
                mTagsFilterButton.setText(R.string.tags);
            }
        }
    }

    public void onCustomClick(Cursor c, int pos, EditItemDialog.FieldType field, View clicked_view) {
        if (mState == STATE_PICK_ITEM) {
            pickItem(c);
        } else {
            if (mItemsView.mShowCheckBox) {
                boolean handled = false;
                // In default theme, there is an extra check box,
                // so clicking on anywhere else means to edit the
                // item.

                if (field == EditItemDialog.FieldType.PRICE
                        && PreferenceActivity.getUsingPerStorePricesFromPrefs(this))
                // should really be a per-list preference
                {
                    editItemStores(pos);
                    handled = true;
                }

                if ((field == EditItemDialog.FieldType.PRIORITY || field == EditItemDialog.FieldType.QUANTITY)
                        && PreferenceActivity.getQuickEditModeFromPrefs(this)) {
                    handled = QuickEditFieldPopupMenu(c, pos, field, clicked_view);
                }

                if (!handled) {
                    editItem(pos, field);
                }
            } else {
                // For themes without a checkbox, clicking anywhere means
                // to toggle the item.
                mItemsView.toggleItemBought(pos);
            }
        }
    }

    private boolean QuickEditFieldPopupMenu(final Cursor c, final int pos, final FieldType field, View v) {
        QuickSelectMenu popup = new QuickSelectMenu(this, v);

        Menu menu = popup.getMenu();
        if (menu == null) {
            return false;
        }
        menu.add("1");
        menu.add("2");
        menu.add("3");
        menu.add("4");
        menu.add("5");
        if (field == FieldType.QUANTITY) {
            menu.add(R.string.otherqty);
        }
        if (field == FieldType.PRIORITY) {
            menu.add(R.string.otherpri);
        }

        popup.setOnItemSelectedListener(new QuickSelectMenu.OnItemSelectedListener() {
            public void onItemSelected(CharSequence name, int id) {
                // TODO: use a flavor of menu.add which takes id,
                // then identifying the selection becomes easier here.

                if (name.length() > 1) {
                    // Other ... use edit dialog
                    editItem(pos, field);
                } else {
                    long number = name.charAt(0) - '0';
                    ContentValues values = new ContentValues();
                    switch (field) {
                    case PRIORITY:
                        values.put(Contains.PRIORITY, number);
                        break;
                    case QUANTITY:
                        values.put(Contains.QUANTITY, number);
                        break;
                    }
                    mItemsView.mCursorItems.moveToPosition(pos);
                    String containsId = mItemsView.mCursorItems.getString(mStringItemsCONTAINSID);
                    Uri uri = Uri.withAppendedPath(ShoppingContract.Contains.CONTENT_URI, containsId);
                    getApplicationContext().getContentResolver().update(uri, values, null, null);
                    onItemChanged(); // probably overkill
                    mItemsView.updateTotal();
                }
            }
        });

        popup.show();
        return true;
    }

    /**
     * Inserts new item from edit box into currently selected shopping list.
     */
    private void insertNewItem() {
        String newItem = mEditText.getText().toString();

        // Only add if there is something to add:
        if (newItem.compareTo("") != 0) {
            long listId = getSelectedListId();
            if (listId < 0) {
                // No valid list - probably view is not active
                // and no item is selected.
                return;
            }
            mItemsView.insertNewItem(this, newItem, null, null, null, null);
            mEditText.setText("");
            fillAutoCompleteTextViewAdapter(mEditText);
        } else {
            // Open list to select item from
            pickItems();
        }
    }

    /**
     * Obtain items from extras.
     */
    private void getShoppingExtras(final Intent intent) {
        mExtraItems = intent.getExtras().getStringArrayList(ShoppingListIntents.EXTRA_STRING_ARRAYLIST_SHOPPING);
        mExtraQuantities = intent.getExtras()
                .getStringArrayList(ShoppingListIntents.EXTRA_STRING_ARRAYLIST_QUANTITY);
        mExtraPrices = intent.getExtras().getStringArrayList(ShoppingListIntents.EXTRA_STRING_ARRAYLIST_PRICE);
        mExtraBarcodes = intent.getExtras().getStringArrayList(ShoppingListIntents.EXTRA_STRING_ARRAYLIST_BARCODE);

        mExtraListUri = null;
        if ((intent.getDataString() != null)
                && (intent.getDataString().startsWith(ShoppingContract.Lists.CONTENT_URI.toString()))) {
            // We received a valid shopping list URI.

            // Set current list to received list:
            mExtraListUri = intent.getData();
            if (debug) {
                Log.d(TAG, "Received extras for " + mExtraListUri.toString());
            }
        }
    }

    /**
     * Inserts new item from string array received in intent extras.
     */
    private void insertItemsFromExtras() {
        if (mExtraItems != null) {
            // Make sure we are in the correct list:
            if (mExtraListUri != null) {
                long listId = Long.parseLong(mExtraListUri.getLastPathSegment());
                if (debug) {
                    Log.d(TAG, "insert items into list " + listId);
                }
                if (listId != getSelectedListId()) {
                    if (debug) {
                        Log.d(TAG, "set new list: " + listId);
                    }
                    setSelectedListId((int) listId);
                }
                mItemsView.fillItems(this, listId);
            }

            int max = mExtraItems.size();
            int maxQuantity = (mExtraQuantities != null) ? mExtraQuantities.size() : -1;
            int maxPrice = (mExtraPrices != null) ? mExtraPrices.size() : -1;
            int maxBarcode = (mExtraBarcodes != null) ? mExtraBarcodes.size() : -1;
            for (int i = 0; i < max; i++) {
                String item = mExtraItems.get(i);
                String quantity = (i < maxQuantity) ? mExtraQuantities.get(i) : null;
                String price = (i < maxPrice) ? mExtraPrices.get(i) : null;
                String barcode = (i < maxBarcode) ? mExtraBarcodes.get(i) : null;
                if (debug) {
                    Log.d(TAG, "Add item: " + item + ", quantity: " + quantity + ", price: " + price + ", barcode: "
                            + barcode);
                }
                mItemsView.insertNewItem(this, item, quantity, null, price, barcode);
            }
            // delete the string array list of extra items so it can't be
            // inserted twice
            mExtraItems = null;
            mExtraQuantities = null;
            mExtraPrices = null;
            mExtraBarcodes = null;
            mExtraListUri = null;
        } else {
            Toast.makeText(this, R.string.no_items_available, Toast.LENGTH_SHORT).show();
        }
    }

    /**
     * Picks an item and returns to calling activity.
     */
    private void pickItem(Cursor c) {
        long itemId = c.getLong(mStringItemsITEMID);
        Uri url = ContentUris.withAppendedId(ShoppingContract.Items.CONTENT_URI, itemId);

        Intent intent = new Intent();
        intent.setData(url);
        setResult(RESULT_OK, intent);
        finish();
    }

    // Menu

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        super.onCreateOptionsMenu(menu);

        /*
         * int MENU_ACTION_WITH_TEXT=0;
         * 
         * //Temp- for backward compatibility with OS 3 features
         * 
         * if(!usingListSpinner()){ try{ //setting the value equivalent to
         * desired expression
         * //MenuItem.SHOW_AS_ACTION_IF_ROOM|MenuItem.SHOW_AS_ACTION_WITH_TEXT
         * java.lang.reflect.Field
         * field=MenuItem.class.getDeclaredField("SHOW_AS_ACTION_IF_ROOM");
         * MENU_ACTION_WITH_TEXT=field.getInt(MenuItem.class);
         * field=MenuItem.class.getDeclaredField("SHOW_AS_ACTION_WITH_TEXT");
         * MENU_ACTION_WITH_TEXT|=field.getInt(MenuItem.class); }catch(Exception
         * e){ //reset value irrespective of cause MENU_ACTION_WITH_TEXT=0; }
         * 
         * }
         */

        // Add menu option for auto adding items from string array in intent
        // extra if they exist
        if (mExtraItems != null) {
            menu.add(0, MENU_INSERT_FROM_EXTRAS, 0, R.string.menu_auto_add)
                    .setIcon(android.R.drawable.ic_menu_upload);
        }

        MenuItem item = null;

        View searchView = mItemsView.getSearchView();
        if (searchView != null) {
            item = menu.add(0, MENU_SEARCH_ADD, 0, R.string.menu_search_add);
            MenuItemCompat.setActionView(item, searchView);
            MenuItemCompat.setShowAsAction(item, MenuItem.SHOW_AS_ACTION_ALWAYS);
        }
        mAddPanel.setVisibility(searchView == null ? View.VISIBLE : View.GONE);

        item = menu.add(0, MENU_SORT_LIST, 0, R.string.menu_sort_list)
                .setIcon(android.R.drawable.ic_menu_sort_alphabetically);
        MenuItemCompat.setShowAsAction(item, MenuItem.SHOW_AS_ACTION_IF_ROOM | MenuItem.SHOW_AS_ACTION_WITH_TEXT);
        if (mListSortActionProvider == null) {
            mListSortActionProvider = new ListSortActionProvider(this);
        }
        MenuItemCompat.setActionProvider(item, mListSortActionProvider);

        // Standard menu

        // tentatively moved "new list" to drawer
        //item = menu.add(0, MENU_NEW_LIST, 0, R.string.new_list)
        //      .setIcon(R.drawable.ic_menu_add_list).setShortcut('0', 'n');
        // MenuCompat.setShowAsAction(item, MenuItem.SHOW_AS_ACTION_IF_ROOM);

        item = menu.add(0, MENU_CLEAN_UP_LIST, 0, R.string.clean_up_list).setIcon(R.drawable.ic_menu_cleanup)
                .setShortcut('1', 'c');
        MenuItemCompat.setShowAsAction(item, MenuItem.SHOW_AS_ACTION_IF_ROOM | MenuItem.SHOW_AS_ACTION_WITH_TEXT);

        menu.add(0, MENU_PICK_ITEMS, 0, R.string.menu_pick_items).setIcon(android.R.drawable.ic_menu_add)
                .setShortcut('2', 'p').
                // tentatively replaced by buttons in drawer.
                setVisible(false);

        /*
         * menu.add(0, MENU_SHARE, 0, R.string.share)
         * .setIcon(R.drawable.contact_share001a) .setShortcut('4', 's');
         */

        menu.add(0, MENU_THEME, 0, R.string.theme).setIcon(android.R.drawable.ic_menu_manage).setShortcut('3', 't');

        menu.add(0, MENU_PREFERENCES, 0, R.string.preferences).setIcon(android.R.drawable.ic_menu_preferences)
                .setShortcut('4', 'p');

        menu.add(0, MENU_RENAME_LIST, 0, R.string.rename_list).setIcon(android.R.drawable.ic_menu_edit)
                .setShortcut('5', 'r');

        menu.add(0, MENU_DELETE_LIST, 0, R.string.delete_list).setIcon(android.R.drawable.ic_menu_delete);

        menu.add(0, MENU_SEND, 0, R.string.send).setIcon(android.R.drawable.ic_menu_send).setShortcut('7', 's');

        if (addLocationAlertPossible()) {
            menu.add(0, MENU_ADD_LOCATION_ALERT, 0, R.string.shopping_add_alert)
                    .setIcon(android.R.drawable.ic_menu_mylocation).setShortcut('8', 'l');
        }

        menu.add(0, MENU_MARK_ALL_ITEMS, 0, R.string.mark_all_items).setIcon(android.R.drawable.ic_menu_agenda)
                .setShortcut('9', 'm');

        menu.add(0, MENU_UNMARK_ALL_ITEMS, 0, R.string.unmark_all_items);

        menu.add(0, MENU_SYNC_WEAR, 0, R.string.sync_wear);

        // Add distribution menu items last.
        mDistribution.onCreateOptionsMenu(menu);

        // NOTE:
        // Dynamically added menu items are included in onPrepareOptionsMenu()
        // instead of here!
        // (Explanation see there.)

        return true;
    }

    /**
     * Check whether an application exists that handles the pick activity.
     *
     * @return
     */
    private boolean addLocationAlertPossible() {

        // Test whether intent exists for picking a location:
        PackageManager pm = getPackageManager();
        Intent intent = new Intent(Intent.ACTION_PICK, Uri.parse("geo:"));
        List<ResolveInfo> resolve_pick_location = pm.queryIntentActivities(intent,
                PackageManager.MATCH_DEFAULT_ONLY);
        /*
         * for (int i = 0; i < resolve_pick_location.size(); i++) { Log.d(TAG,
         * "Activity name: " + resolve_pick_location.get(i).activityInfo.name);
         * }
         */

        // Check whether adding alerts is possible.
        intent = new Intent(Intent.ACTION_VIEW, Alert.Generic.CONTENT_URI);
        List<ResolveInfo> resolve_view_alerts = pm.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);

        boolean pick_location_possible = (resolve_pick_location.size() > 0);
        boolean view_alerts_possible = (resolve_view_alerts.size() > 0);
        if (debug) {
            Log.d(TAG, "Pick location possible: " + pick_location_possible);
        }
        if (debug) {
            Log.d(TAG, "View alerts possible: " + view_alerts_possible);
        }
        if (pick_location_possible && view_alerts_possible) {
            return true;
        }

        return false;
    }

    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        super.onPrepareOptionsMenu(menu);

        boolean drawerOpen = mDrawerLayout != null && mDrawerLayout.isDrawerOpen(mDrawerListsView);
        boolean holoSearch = PreferenceActivity.getUsingHoloSearchFromPrefs(this);
        // TODO: supposed to hide content-related actions when the drawer is open.

        // TODO: Add item-specific menu items (see NotesList.java example)
        // like edit, strike-through, delete.

        // Add menu option for auto adding items from string array in intent
        // extra if they exist
        if (mExtraItems == null) {
            menu.removeItem(MENU_INSERT_FROM_EXTRAS);
        }

        // Selected list:
        long listId = getSelectedListId();

        // set menu title for change mode
        MenuItem menuItem = menu.findItem(MENU_PICK_ITEMS);

        if (mItemsView.mMode == MODE_ADD_ITEMS) {
            menuItem.setTitle(R.string.menu_start_shopping);
            menuItem.setIcon(android.R.drawable.ic_menu_myplaces);
        } else {
            menu.findItem(MENU_PICK_ITEMS).setTitle(R.string.menu_pick_items);
            menuItem.setIcon(android.R.drawable.ic_menu_add);
        }

        menuItem = menu.findItem(MENU_SEARCH_ADD);
        if (menuItem != null) {
            menuItem.setVisible(holoSearch && !drawerOpen);
            if (!holoSearch) {
                mAddPanel.setVisibility(View.VISIBLE);
            }

            View searchView = menuItem.getActionView();
            int searchImgId = getResources().getIdentifier("android:id/search_button", null, null);
            View imageView = searchView.findViewById(searchImgId);
            if (imageView instanceof ImageView) {
                ((ImageView) imageView).setImageResource(android.R.drawable.ic_menu_add);
            }

        }

        menuItem = menu.findItem(MENU_SYNC_WEAR);
        if (menuItem != null) {
            menuItem.setVisible(mItemsView.isWearSupportAvailable());
        }

        menuItem = menu.findItem(MENU_MARK_ALL_ITEMS).setVisible(mItemsView.mNumUnchecked > 0);
        menuItem = menu.findItem(MENU_UNMARK_ALL_ITEMS).setVisible(mItemsView.mNumChecked > 0);

        menuItem = menu.findItem(MENU_CLEAN_UP_LIST).setEnabled(mItemsView.mNumChecked > 0).setVisible(!drawerOpen);

        // Delete list is possible, if we have more than one list:
        // AND
        // the current list is not the default list (listId == 0) - issue #105
        // TODO: Later, the default list should be user-selectable,
        // and not deletable.

        // TODO ???
        /*
         * menu.setItemShown(MENU_DELETE_LIST, mCursorListFilter.count() > 1 &&
         * listId != 1); // 1 is hardcoded number of default first list.
         */

        // The following code is put from onCreateOptionsMenu to
        // onPrepareOptionsMenu,
        // because the URI of the shopping list can change if the user switches
        // to another list.
        // Generate any additional actions that can be performed on the
        // overall list. This allows other applications to extend
        // our menu with their own actions.
        Intent intent = new Intent(null, getIntent().getData());
        intent.addCategory(Intent.CATEGORY_ALTERNATIVE);
        // menu.addIntentOptions(Menu.CATEGORY_ALTERNATIVE, 0, 0,
        // new ComponentName(this, NoteEditor.class), null, intent, 0, null);

        // Workaround to add icons:
        MenuIntentOptionsWithIcons menu2 = new MenuIntentOptionsWithIcons(this, menu);
        menu2.addIntentOptions(Menu.CATEGORY_ALTERNATIVE, 0, 0,
                new ComponentName(this, org.openintents.shopping.ShoppingActivity.class), null, intent, 0, null);

        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        if (debug) {
            Log.d(TAG, "onOptionsItemSelected getItemId: " + item.getItemId());
        }
        Intent intent;
        switch (item.getItemId()) {
        case MENU_NEW_LIST:
            showDialog(DIALOG_NEW_LIST);
            return true;

        case MENU_CLEAN_UP_LIST:
            cleanupList();
            return true;

        case MENU_RENAME_LIST:
            showDialog(DIALOG_RENAME_LIST);
            return true;

        case MENU_DELETE_LIST:
            deleteListConfirm();
            return true;

        case MENU_PICK_ITEMS:
            pickItems();
            return true;

        case MENU_SHARE:
            setShareSettings();
            return true;

        case MENU_THEME:
            setThemeSettings();
            return true;

        case MENU_ADD_LOCATION_ALERT:
            addLocationAlert();
            return true;

        case MENU_PREFERENCES:
            intent = new Intent(this, PreferenceActivity.class);
            startActivity(intent);
            return true;
        case MENU_SEND:
            sendList();
            return true;
        case MENU_INSERT_FROM_EXTRAS:
            insertItemsFromExtras();
            return true;
        case MENU_MARK_ALL_ITEMS:
            mItemsView.toggleAllItems(true);
            return true;
        case MENU_UNMARK_ALL_ITEMS:
            mItemsView.toggleAllItems(false);
            return true;
        case MENU_SYNC_WEAR:
            mItemsView.pushItemsToWear();
            return true;
        }
        if (debug) {
            Log.d(TAG, "Start intent group id : " + item.getGroupId());
        }
        if (Menu.CATEGORY_ALTERNATIVE == item.getGroupId()) {
            // Start alternative cateogory intents with option to return a
            // result.
            if (debug) {
                Log.d(TAG, "Start alternative intent for : " + item.getIntent().getDataString());
            }
            startActivityForResult(item.getIntent(), REQUEST_CODE_CATEGORY_ALTERNATIVE);
            return true;
        }
        if (mDrawerToggle != null && mDrawerToggle.onOptionsItemSelected(item)) {
            return true;
        }
        return super.onOptionsItemSelected(item);

    }

    /**
     *
     */
    private void pickItems() {
        if (PreferenceActivity.getPickItemsInListFromPrefs(getApplicationContext())) {
            if (mItemsView.mMode == MODE_IN_SHOP) {
                mItemsView.mMode = MODE_ADD_ITEMS;
            } else {
                mItemsView.mMode = MODE_IN_SHOP;
            }
            onModeChanged();
        } else {
            if (mItemsView.mMode != MODE_IN_SHOP) {
                mItemsView.mMode = MODE_IN_SHOP;
                onModeChanged();
            }
            pickItemsUsingDialog();
        }
    }

    private void pickItemsUsingDialog() {
        Intent intent;
        intent = new Intent(this, PickItemsActivity.class);
        intent.setData(mListUri);
        startActivity(intent);
    }

    @Override
    public boolean onContextItemSelected(MenuItem item) {
        super.onContextItemSelected(item);
        AdapterContextMenuInfo menuInfo = (AdapterContextMenuInfo) item.getMenuInfo();
        switch (item.getItemId()) {
        case MENU_MARK_ITEM:
            markItem(menuInfo.position);
            break;
        case MENU_EDIT_ITEM:
            editItem(menuInfo.position, EditItemDialog.FieldType.ITEMNAME);
            break;
        case MENU_REMOVE_ITEM_FROM_LIST:
            removeItemFromList(menuInfo.position);
            break;
        case MENU_DELETE_ITEM:
            deleteItemDialog(menuInfo.position);
            break;
        case MENU_MOVE_ITEM:
            Intent intent = new Intent();
            intent.setAction(Intent.ACTION_PICK);
            intent.setData(ShoppingContract.Lists.CONTENT_URI);
            startActivityForResult(intent, REQUEST_PICK_LIST);
            mMoveItemPosition = menuInfo.position;
            break;
        case MENU_COPY_ITEM:
            copyItem(menuInfo.position);
            break;
        case MENU_ITEM_STORES:
            editItemStores(menuInfo.position);
            break;
        }

        return true;
    }

    // /////////////////////////////////////////////////////
    //
    // Menu functions
    //

    /**
     * Creates a new list from dialog.
     *
     * @return true if new list was created. False if new list was not created,
     * because user has not given any name.
     */
    private boolean createNewList(String name) {

        if (name.equals("")) {
            // User has not provided any name
            Toast.makeText(this, getString(R.string.please_enter_name), Toast.LENGTH_SHORT).show();
            return false;
        }

        String previousTheme = loadListTheme();

        int newId = (int) ShoppingUtils.getList(this, name);
        fillListFilter();

        setSelectedListId(newId);

        // Now set the theme based on the selected list:
        saveListTheme(previousTheme);
        setListTheme(previousTheme);
        applyListTheme();

        return true;
    }

    private void setListTheme(String theme) {
        mItemsView.setListTheme(theme);
    }

    private void applyListTheme() {
        mItemsView.applyListTheme();

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            // In Holo themes, apply the theme text color also to the
            // input box and the button, because the background is
            // semi-transparent.
            mEditText.setTextColor(mItemsView.mTextColor);
            if (mStoresFilterButton != null) {
                mStoresFilterButton.setTextColor(mItemsView.mTextColor);
            }
            if (mTagsFilterButton != null) {
                mTagsFilterButton.setTextColor(mItemsView.mTextColor);
            }
            if (mShoppingListsFilterButton != null) {
                mShoppingListsFilterButton.setTextColor(mItemsView.mTextColor);
            }
            if (mShoppingListsView instanceof Spinner) {
                View view = mShoppingListsView.getChildAt(0);
                setSpinnerTextColorInHoloTheme(view);
            }
        }
    }

    /**
     * For holo themes with transparent widgets, set font color of the spinner
     * using theme color.
     *
     * @param view
     */
    private void setSpinnerTextColorInHoloTheme(View view) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            if (view instanceof TextView) {
                ((TextView) view).setTextColor(mItemsView.mTextColor);
            }
        }
    }

    /**
     * Rename list from dialog.
     *
     * @return true if new list was renamed. False if new list was not renamed,
     * because user has not given any name.
     */
    private boolean renameList(String newName) {

        if (newName.equals("")) {
            // User has not provided any name
            Toast.makeText(this, getString(R.string.please_enter_name), Toast.LENGTH_SHORT).show();
            return false;
        }

        // Rename currently selected list:
        ContentValues values = new ContentValues();
        values.put(Lists.NAME, "" + newName);
        getContentResolver().update(Uri.withAppendedPath(Lists.CONTENT_URI, mCursorShoppingLists.getString(0)),
                values, null, null);

        mCursorShoppingLists.requery();
        updateTitle();
        return true;
    }

    private void sendList() {
        if (mItemsView.getAdapter() instanceof CursorAdapter) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < mItemsView.getAdapter().getCount(); i++) {
                Cursor item = (Cursor) mItemsView.getAdapter().getItem(i);
                if (item.getLong(mStringItemsSTATUS) == ShoppingContract.Status.BOUGHT) {
                    sb.append("[X] ");
                } else {
                    sb.append("[ ] ");
                }
                String quantity = item.getString(mStringItemsQUANTITY);
                long pricecent = item.getLong(mStringItemsITEMPRICE);
                String price = PriceConverter.getStringFromCentPrice(pricecent);
                String tags = item.getString(mStringItemsITEMTAGS);
                if (!TextUtils.isEmpty(quantity)) {
                    sb.append(quantity);
                    sb.append(" ");
                }
                String units = item.getString(mStringItemsITEMUNITS);
                if (!TextUtils.isEmpty(units)) {
                    sb.append(units);
                    sb.append(" ");
                }
                sb.append(item.getString(mStringItemsITEMNAME));
                // Put additional info (price, tags) in brackets
                boolean p = !TextUtils.isEmpty(price);
                boolean t = !TextUtils.isEmpty(tags);
                if (p || t) {
                    sb.append(" (");
                    if (p) {
                        sb.append(price);
                    }
                    if (p && t) {
                        sb.append(", ");
                    }
                    if (t) {
                        sb.append(tags);
                    }
                    sb.append(")");
                }
                sb.append("\n");
            }

            Intent i = new Intent();
            i.setAction(Intent.ACTION_SEND);
            i.setType("text/plain");
            i.putExtra(Intent.EXTRA_SUBJECT, getCurrentListName());
            i.putExtra(Intent.EXTRA_TEXT, sb.toString());

            try {
                startActivity(Intent.createChooser(i, getString(R.string.send)));
            } catch (ActivityNotFoundException e) {
                Toast.makeText(this, R.string.email_not_available, Toast.LENGTH_SHORT).show();
                Log.e(TAG, "Email client not installed");
            }
        } else {
            Toast.makeText(this, R.string.empty_list_not_sent, Toast.LENGTH_SHORT);
        }

    }

    /**
     * Clean up the currently visible shopping list by removing items from list
     * that are marked BOUGHT.
     */
    private void cleanupList() {
        // Remove all items from current list
        // which have STATUS = Status.BOUGHT

        if (!mItemsView.cleanupList()) {
            // Show toast
            Toast.makeText(this, R.string.no_items_marked, Toast.LENGTH_SHORT).show();
        }
    }

    // TODO: Convert into proper dialog that remains across screen orientation
    // changes.

    /**
     * Confirm 'delete list' command by AlertDialog.
     */
    private void deleteListConfirm() {
        new AlertDialog.Builder(this)
                // .setIcon(R.drawable.alert_dialog_icon)
                .setTitle(R.string.confirm_delete_list)
                .setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int whichButton) {
                        // click Ok
                        deleteList();
                    }
                }).setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int whichButton) {
                        // click Cancel
                    }
                })
                // .create()
                .show();
    }

    /**
     * Deletes currently selected shopping list.
     */
    private void deleteList() {
        String listId = mCursorShoppingLists.getString(0);
        ShoppingUtils.deleteList(this, listId);

        // Update view
        fillListFilter();

        getSelectedListId();

        // Set the theme based on the selected list:
        setListTheme(loadListTheme());

        fillItems(false);
        applyListTheme();
        updateTitle();
    }

    /**
     * Mark item
     */
    void markItem(int position) {
        mItemsView.toggleItemBought(position);
    }

    /**
     * Edit item
     *
     * @param field
     */
    void editItem(long itemId, long containsId, EditItemDialog.FieldType field) {
        mItemUri = Uri.withAppendedPath(ShoppingContract.Items.CONTENT_URI, "" + itemId);
        mListItemUri = Uri.withAppendedPath(mListUri, "" + itemId);
        mRelationUri = Uri.withAppendedPath(ShoppingContract.Contains.CONTENT_URI, "" + containsId);
        mEditItemFocusField = field;

        showDialog(DIALOG_EDIT_ITEM);
    }

    /**
     * Edit item
     *
     * @param field
     */
    void editItem(int position, EditItemDialog.FieldType field) {
        if (debug) {
            Log.d(TAG, "EditItems: Position: " + position);
        }
        mItemsView.mCursorItems.moveToPosition(position);
        // mEditItemPosition = position;

        long itemId = mItemsView.mCursorItems.getLong(mStringItemsITEMID);
        long containsId = mItemsView.mCursorItems.getLong(mStringItemsCONTAINSID);

        editItem(itemId, containsId, field);
    }

    void editItemStores(int position) {
        if (debug) {
            Log.d(TAG, "EditItemStores: Position: " + position);
        }

        mItemsView.mCursorItems.moveToPosition(position);
        // mEditItemPosition = position;
        long itemId = mItemsView.mCursorItems.getLong(mStringItemsITEMID);

        Intent intent;
        intent = new Intent(this, ItemStoresActivity.class);
        intent.setData(mListUri.buildUpon().appendPath(String.valueOf(itemId)).build());
        startActivity(intent);
    }

    int mDeleteItemPosition;

    /**
     * delete item
     */
    void deleteItemDialog(int position) {
        if (debug) {
            Log.d(TAG, "EditItems: Position: " + position);
        }
        mItemsView.mCursorItems.moveToPosition(position);
        mDeleteItemPosition = position;

        showDialog(DIALOG_DELETE_ITEM);
    }

    /**
     * delete item
     */
    void deleteItem(int position) {
        Cursor c = mItemsView.mCursorItems;
        c.moveToPosition(position);

        String listId = mListUri.getLastPathSegment();
        String itemId = c.getString(mStringItemsITEMID);
        ShoppingUtils.deleteItem(this, itemId, listId);

        // c.requery();
        mItemsView.requery();
        fillAutoCompleteTextViewAdapter(mEditText);
    }

    /**
     * move item
     */
    void moveItem(int position, int targetListId) {
        Cursor c = mItemsView.mCursorItems;
        mItemsView.mCursorItems.requery();
        c.moveToPosition(position);

        long listId = getSelectedListId();
        if (false && listId < 0) {
            // No valid list - probably view is not active
            // and no item is selected.
            return;
        }
        listId = Integer.parseInt(mListUri.getLastPathSegment());

        // Attach item to new list, preserving all other fields
        String containsId = c.getString(mStringItemsCONTAINSID);
        ContentValues cv = new ContentValues(1);
        cv.put(Contains.LIST_ID, targetListId);
        getContentResolver().update(Uri.withAppendedPath(Contains.CONTENT_URI, containsId), cv, null, null);

        mItemsView.requery();
    }

    /**
     * copy item
     */
    void copyItem(int position) {
        Cursor c = mItemsView.mCursorItems;
        mItemsView.mCursorItems.requery();
        c.moveToPosition(position);
        String containsId = c.getString(mStringItemsCONTAINSID);
        Long newContainsId;
        Long newItemId;

        c = getContentResolver().query(
                Uri.withAppendedPath(Uri.withAppendedPath(Contains.CONTENT_URI, "copyof"), containsId),
                new String[] { "item_id", "contains_id" }, null, null, null);

        if (c.getCount() != 1) {
            return;
        }

        c.moveToFirst();
        newItemId = c.getLong(0);
        newContainsId = c.getLong(1);
        c.deactivate();
        c.close();

        editItem(newItemId, newContainsId, FieldType.ITEMNAME);

        // mItemsView.requery();
    }

    /**
     * removeItemFromList
     */
    void removeItemFromList(int position) {
        Cursor c = mItemsView.mCursorItems;
        c.moveToPosition(position);
        // Remember old values before delete (for share below)
        String itemName = c.getString(mStringItemsITEMNAME);
        long oldstatus = c.getLong(mStringItemsSTATUS);

        // Delete item by changing its state
        ContentValues values = new ContentValues();
        values.put(Contains.STATUS, Status.REMOVED_FROM_LIST);
        if (PreferenceActivity.getResetQuantity(getApplicationContext())) {
            values.put(Contains.QUANTITY, "");
        }
        getContentResolver().update(Contains.CONTENT_URI, values, "_id = ?",
                new String[] { c.getString(mStringItemsCONTAINSID) });

        // c.requery();

        mItemsView.requery();

        // If we share items, mark item on other lists:
        // TODO ???
        /*
         * String recipients =
         * mCursorListFilter.getString(mStringListFilterSHARECONTACTS); if (!
         * recipients.equals("")) { String shareName =
         * mCursorListFilter.getString(mStringListFilterSHARENAME); long
         * newstatus = Shopping.Status.BOUGHT;
         * 
         * Log.i(TAG, "Update shared item. " + " recipients: " + recipients +
         * ", shareName: " + shareName + ", status: " + newstatus);
         * mGTalkSender.sendItemUpdate(recipients, shareName, itemName,
         * itemName, oldstatus, newstatus); }
         */
    }

    /**
     * Calls the share settings with the currently selected list.
     */
    void setShareSettings() {
        // Obtain URI of current list

        // Call share settings as subactivity
        Intent intent = new Intent(OpenIntents.SET_SHARE_SETTINGS_ACTION, mListUri);
        startActivityForResult(intent, SUBACTIVITY_LIST_SHARE_SETTINGS);

    }

    void setThemeSettings() {
        showDialog(DIALOG_THEME);
    }

    @Override
    public String onLoadTheme() {
        return loadListTheme();
    }

    @Override
    public void onSaveTheme(String theme) {
        saveListTheme(theme);
    }

    @Override
    public void onSetTheme(String theme) {
        setListTheme(theme);
        applyListTheme();
    }

    @Override
    public void onSetThemeForAll(String theme) {
        setThemeForAll(this, theme);
    }

    /**
     * Set theme for all lists.
     *
     * @param context
     * @param theme
     */
    public static void setThemeForAll(Context context, String theme) {
        ContentValues values = new ContentValues();
        values.put(Lists.SKIN_BACKGROUND, theme);
        context.getContentResolver().update(Lists.CONTENT_URI, values, null, null);
    }

    /**
     * Loads the theme settings for the currently selected theme.
     * <p/>
     * Up to version 1.2.1, only one of 3 hardcoded themes are available. These
     * are stored in 'skin_background' as '1', '2', or '3'.
     * <p/>
     * Starting in 1.2.2, also themes of other packages are allowed.
     *
     * @return
     */
    public String loadListTheme() {
        /*
         * long listId = getSelectedListId(); if (listId < 0) { // No valid list
         * - probably view is not active // and no item is selected. return 1;
         * // return default theme }
         */

        // Return default theme if something unexpected happens:
        if (mCursorShoppingLists == null) {
            return "1";
        }
        if (mCursorShoppingLists.getPosition() < 0) {
            return "1";
        }

        // mCursorListFilter has been set to correct position
        // by calling getSelectedListId(),
        // so we can read out further elements:
        String skinBackground = mCursorShoppingLists.getString(mStringListFilterSKINBACKGROUND);

        return skinBackground;
    }

    public void saveListTheme(String theme) {
        long listId = getSelectedListId();
        if (listId < 0) {
            // No valid list - probably view is not active
            // and no item is selected.
            return; // return default theme
        }

        ContentValues values = new ContentValues();
        values.put(Lists.SKIN_BACKGROUND, theme);
        getContentResolver().update(Uri.withAppendedPath(Lists.CONTENT_URI, mCursorShoppingLists.getString(0)),
                values, null, null);

        mCursorShoppingLists.requery();
    }

    /**
     * Calls a dialog for setting the locations alert.
     */
    void addLocationAlert() {

        // Call dialog as activity
        Intent intent = new Intent(OpenIntents.ADD_LOCATION_ALERT_ACTION, mListUri);
        // startSubActivity(intent, SUBACTIVITY_ADD_LOCATION_ALERT);
        startActivity(intent);
    }

    @Override
    protected Dialog onCreateDialog(int id) {

        switch (id) {

        case DIALOG_NEW_LIST:
            return new NewListDialog(this, new DialogActionListener() {

                public void onAction(String name) {
                    createNewList(name);
                }
            });

        case DIALOG_RENAME_LIST:
            return new RenameListDialog(this, getCurrentListName(), new DialogActionListener() {

                public void onAction(String name) {
                    renameList(name);
                }
            });

        case DIALOG_EDIT_ITEM:
            return new EditItemDialog(this, mItemUri, mRelationUri, mListItemUri);

        case DIALOG_DELETE_ITEM:
            return new AlertDialog.Builder(this).setIcon(android.R.drawable.ic_dialog_alert)
                    .setTitle(R.string.menu_delete_item).setMessage(R.string.delete_item_confirm)
                    .setPositiveButton(R.string.delete, new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int whichButton) {
                            deleteItem(mDeleteItemPosition);
                        }
                    }).setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int whichButton) {
                            // Don't do anything
                        }
                    }).create();

        case DIALOG_THEME:
            return new ThemeDialog(this, this);

        case DIALOG_GET_FROM_MARKET:
            return new DownloadOIAppDialog(this, DownloadOIAppDialog.OI_BARCODESCANNER);
        }
        return super.onCreateDialog(id);

    }

    @Override
    protected void onPrepareDialog(int id, Dialog dialog) {
        super.onPrepareDialog(id, dialog);

        switch (id) {

        case DIALOG_RENAME_LIST:
            ((RenameListDialog) dialog).setName(getCurrentListName());
            break;

        case DIALOG_EDIT_ITEM:
            EditItemDialog d = (EditItemDialog) dialog;
            d.setItemUri(mItemUri, mListItemUri);
            d.setRelationUri(mRelationUri);
            d.setFocusField(mEditItemFocusField);

            String[] taglist = getTaglist();
            d.setTagList(taglist);

            d.setOnItemChangedListener(this);
            break;

        case DIALOG_THEME:
            ((ThemeDialog) dialog).prepareDialog();
            break;
        case DIALOG_GET_FROM_MARKET:
            DownloadOIAppDialog.onPrepareDialog(this, dialog);
            break;
        }
    }

    // /////////////////////////////////////////////////////
    //
    // Helper functions
    //

    /**
     * Returns the ID of the selected shopping list.
     * <p/>
     * As a side effect, the item URI is updated. Returns -1 if nothing is
     * selected.
     *
     * @return ID of selected shopping list.
     */
    private long getSelectedListId() {
        int pos = mShoppingListsView.getSelectedItemPosition();
        // Temp- Due to architecture requirements of OS 3, the value can not be
        // passed directly
        if (pos == -1 && !usingListSpinner()) {
            try {
                pos = (Integer) mShoppingListsView.getTag();
                pos = mCursorShoppingLists.getCount() <= pos ? -1 : pos;
            } catch (Exception e) {
                // e.printStackTrace();
            }
        }
        if (pos < 0) {
            // nothing selected - probably view is out of focus:
            // Do nothing.
            return -1;
        }

        // Obtain Id of currently selected shopping list:
        mCursorShoppingLists.moveToPosition(pos);

        long listId = mCursorShoppingLists.getLong(mStringListFilterID);

        mListUri = Uri.withAppendedPath(ShoppingContract.Lists.CONTENT_URI, "" + listId);

        getIntent().setData(mListUri);

        return listId;
    }

    /**
     * sets the selected list to a specific list Id
     */
    private void setSelectedListId(int id) {
        // Is there a nicer way to accomplish the following?
        // (we look through all elements to look for the
        // one entry that has the same ID as returned by
        // getDefaultList()).
        //
        // unfortunately, a SQL query won't work, as it would
        // return 1 row, but I still would not know which
        // row in the mCursorListFilter corresponds to that id.
        //
        // one could use: findViewById() but how will this
        // translate to the position in the list?
        mCursorShoppingLists.moveToPosition(-1);
        while (mCursorShoppingLists.moveToNext()) {
            int posId = mCursorShoppingLists.getInt(mStringListFilterID);
            if (posId == id) {
                int row = mCursorShoppingLists.getPosition();

                // if we found the Id, then select this in
                // the Spinner:
                setSelectedListPos(row);
                break;
            }
        }
    }

    private void setSelectedListPos(int pos) {
        mShoppingListsView.setTag(pos);

        mShoppingListsView.setSelection(pos);

        long id = getSelectedListId();

        // Set the theme based on the selected list:
        setListTheme(loadListTheme());

        if (id != mItemsView.getListId()) {
            fillItems(false);
        }
        applyListTheme();
        updateTitle();
        if (mShoppingListsView instanceof ListView) {
            ((ListView) mShoppingListsView).setItemChecked(pos, true);
        }
    }

    /**
     *
     */
    private void fillListFilter() {
        // Get a cursor with all lists

        mCursorShoppingLists = getContentResolver().query(Lists.CONTENT_URI, mStringListFilter, null, null,
                mSortOrder);
        startManagingCursor(mCursorShoppingLists);

        if (mCursorShoppingLists == null) {
            Log.e(TAG, "missing shopping provider");
            ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, R.layout.list_item_shopping_list,
                    new String[] { getString(R.string.no_shopping_provider) });
            setSpinnerListAdapter(adapter);

            return;
        }

        if (mCursorShoppingLists.getCount() < 1) {
            // We have to create default shopping list:
            long listId = ShoppingUtils.getList(this, getText(R.string.my_shopping_list).toString());

            // Check if insertion really worked. Otherwise
            // we may end up in infinite recursion.
            if (listId < 0) {
                // for some reason insertion did not work.
                return;
            }

            // The insertion should have worked, so let us call ourselves
            // to try filling the list again:
            fillListFilter();
            return;
        }

        class mListContentObserver extends ContentObserver {

            public mListContentObserver(Handler handler) {
                super(handler);
                if (debug) {
                    Log.i(TAG, "mListContentObserver: Constructor");
                }
            }

            /*
             * (non-Javadoc)
             *
             * @see android.database.ContentObserver#deliverSelfNotifications()
             */
            @Override
            public boolean deliverSelfNotifications() {
                // TODO Auto-generated method stub
                if (debug) {
                    Log.i(TAG, "mListContentObserver: deliverSelfNotifications");
                }
                return super.deliverSelfNotifications();
            }

            /*
             * (non-Javadoc)
             *
             * @see android.database.ContentObserver#onChange(boolean)
             */
            @Override
            public void onChange(boolean arg0) {
                // TODO Auto-generated method stub
                if (debug) {
                    Log.i(TAG, "mListContentObserver: onChange");
                }

                mCursorShoppingLists.requery();

                super.onChange(arg0);
            }

        }

        mListContentObserver observer = new mListContentObserver(new Handler());
        mCursorShoppingLists.registerContentObserver(observer);

        // Register a ContentObserver, so that a new list can be
        // automatically detected.
        // mCursor

        /*
         * ArrayList<String> list = new ArrayList<String>(); // TODO Create
         * summary of all lists // list.add(ALL); while
         * (mCursorListFilter.next()) {
         * list.add(mCursorListFilter.getString(mStringListFilterNAME)); }
         * ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,
         * android.R.layout.simple_spinner_item, list);
         * adapter.setDropDownViewResource(
         * android.R.layout.simple_spinner_dropdown_item);
         * mSpinnerListFilter.setAdapter(adapter);
         */

        SimpleCursorAdapter adapter;

        if (mShoppingListsView instanceof Spinner) {
            adapter = new HoloThemeSimpleCursorAdapter(this,
                    // Use a template that displays a text view
                    R.layout.list_item_shopping_list,
                    // Give the cursor to the list adapter
                    mCursorShoppingLists, new String[] { Lists.NAME }, new int[] { R.id.text1 });
            // adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
        } else {
            // mShoppingListView is a ListView
            adapter = new SimpleCursorAdapter(this,
                    // Use a template that displays a text view
                    R.layout.list_item_shopping_list,
                    // Give the cursor to the list adapter
                    mCursorShoppingLists, new String[] { Lists.NAME }, new int[] { R.id.text1 });
        }
        // mSpinnerListFilter.setAdapter(adapter);//Temp- redirected through
        // method
        setSpinnerListAdapter(adapter);

    }

    class HoloThemeSimpleCursorAdapter extends SimpleCursorAdapter {

        public HoloThemeSimpleCursorAdapter(Context context, int layout, Cursor c, String[] from, int[] to) {
            super(context, layout, c, from, to);
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            View view = super.getView(position, convertView, parent);
            setSpinnerTextColorInHoloTheme(view);
            return view;
        }

    }

    private void onModeChanged() {

        if (debug) {
            Log.d(TAG, "onModeChanged()");
        }
        fillItems(false);

        compat_invalidateOptionsMenu();

        updateTitle();
    }

    java.lang.reflect.Method mMethodInvalidateOptionsMenu = null;

    /**
     * Update the ActionBar (Honeycomb or higher)
     */
    private void compat_invalidateOptionsMenu() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            // invalidateOptionsMenu();
            try {
                if (mMethodInvalidateOptionsMenu == null) {
                    mMethodInvalidateOptionsMenu = Activity.class.getMethod("invalidateOptionsMenu");
                }
                mMethodInvalidateOptionsMenu.invoke(this);
            } catch (Exception e) {
                mMethodInvalidateOptionsMenu = null;
            }
        }
    }

    @Override
    public void updateActionBar() {
        compat_invalidateOptionsMenu();
    }

    private String getCurrentListName() {
        long listId = getSelectedListId();

        // calling getSelectedListId also updates mCursorShoppingLists:
        if (listId >= 0) {
            return mCursorShoppingLists.getString(mStringListFilterNAME);
        } else {
            return "";
        }
    }

    private void fillItems(boolean onlyIfPrefsChanged) {
        if (debug) {
            Log.d(TAG, "fillItems()");
        }

        long listId = getSelectedListId();
        if (listId < 0) {
            // No valid list - probably view is not active
            // and no item is selected.
            Log.d(TAG, "fillItems: listId not availalbe");
            return;
        }

        // Insert any pending items received either through intents
        // or in onActivityResult:
        if (mExtraItems != null) {
            insertItemsFromExtras();
        }

        updateFilterWidgets();

        if (onlyIfPrefsChanged && (lastAppliedPrefChange == PreferenceActivity.updateCount)) {
            return;
        }

        if (debug) {
            Log.d(TAG, "fillItems() for list " + listId);
        }
        lastAppliedPrefChange = PreferenceActivity.updateCount;
        mItemsView.fillItems(this, listId);

        // Also refresh AutoCompleteTextView:
        fillAutoCompleteTextViewAdapter(mEditText);
    }

    /**
     * Fill input field (AutoCompleteTextView) with suggestions: Unique item
     * names from all lists are collected. The adapter is filled in the
     * background.
     */
    public void fillAutoCompleteTextViewAdapter(final AutoCompleteTextView textView) {
        boolean limit_selections = PreferenceActivity.getCompleteFromCurrentListOnlyFromPrefs(this);
        String listId = null;
        if (limit_selections) {
            listId = mListUri.getLastPathSegment();
        }

        // TODO: Optimize: This routine is called too often.
        if (debug) {
            Log.d(TAG, "fill AutoCompleteTextViewAdapter");
        }

        new AsyncTask<String, Integer, ArrayAdapter<String>>() {

            ArrayAdapter<String> adapter;

            @Override
            protected ArrayAdapter<String> doInBackground(String... params) {
                return fillAutoCompleteAdapter(params[0]);
            }

            @Override
            protected void onPostExecute(ArrayAdapter<String> adapter) {
                if (textView != null) {
                    // use result from doInBackground()
                    textView.setAdapter(adapter);
                }
            }

            private ArrayAdapter<String> fillAutoCompleteAdapter(String listId) {
                // Create list of item names
                Uri uri;
                String retCol;
                if (listId == null) {
                    uri = Items.CONTENT_URI;
                    retCol = Items.NAME;
                } else {
                    uri = Uri.parse("content://org.openintents.shopping/containsfull/list").buildUpon()
                            .appendPath(listId).build();
                    retCol = "items.name";
                }
                List<String> autocompleteItems = new LinkedList<String>();
                Cursor c = getContentResolver().query(uri, new String[] { retCol }, null, null, retCol + " asc");
                if (c != null) {
                    String lastitem = "";
                    while (c.moveToNext()) {
                        String newitem = c.getString(0);
                        // Only add items if they have not been added previously
                        // (list is sorted)
                        if (!newitem.equals(lastitem)) {
                            autocompleteItems.add(newitem);
                            lastitem = newitem;
                        }
                    }
                    c.close();
                }
                return new ArrayAdapter<String>(ShoppingActivity.this, android.R.layout.simple_dropdown_item_1line,
                        autocompleteItems);
            }

        }.execute(listId);
    }

    /**
     * Create list of tags.
     * <p/>
     * Tags for notes can be comma-separated. Here we create a list of the
     * unique tags.
     *
     * @return
     */
    String[] getTaglist() {
        return getTaglist(null);
    }

    /**
     * Create list of tags.
     * <p/>
     * Tags for notes can be comma-separated. Here we create a list of the
     * unique tags.
     *
     * @param listId
     * @return
     */
    String[] getTaglist(String listId) {
        Cursor c;

        if (listId == null) {
            c = getContentResolver().query(ShoppingContract.Items.CONTENT_URI,
                    new String[] { ShoppingContract.Items.TAGS }, null, null,
                    ShoppingContract.Items.DEFAULT_SORT_ORDER);
        } else {
            Uri uri = Uri.parse("content://org.openintents.shopping/listtags").buildUpon().appendPath(listId)
                    .build();
            c = getContentResolver().query(uri, new String[] { ShoppingContract.ContainsFull.ITEM_TAGS }, null,
                    null, null);
        }

        // Create a set of all tags (every tag should only appear once).
        HashSet<String> tagset = new HashSet<String>();
        c.moveToPosition(-1);
        while (c.moveToNext()) {
            String tags = c.getString(0);
            if (tags != null) {
                // Split several tags in a line, separated by comma
                String[] smalltaglist = tags.split(",");
                for (String tag : smalltaglist) {
                    if (!tag.equals("")) {
                        tagset.add(tag.trim());
                    }
                }
            }
        }
        c.close();

        // Sort the list
        // 1. Convert HashSet to String list.
        ArrayList<String> list = new ArrayList<String>();
        list.addAll(tagset);
        // 2. Sort the String list
        Collections.sort(list);
        // 3. Convert it to String array
        return list.toArray(new String[list.size()]);
    }

    /**
     * Tests whether the current list is shared via GTalk. (not local sharing!)
     *
     * @return true if SHARE_CONTACTS contains the '@' character.
     */
    boolean isCurrentListShared() {
        long listId = getSelectedListId();
        if (listId < 0) {
            // No valid list - probably view is not active
            // and no item is selected.
            return false;
        }

        // mCursorListFilter has been set to correct position
        // by calling getSelectedListId(),
        // so we can read out further elements:
        // String shareName =
        // mCursorListFilter.getString(mStringListFilterSHARENAME);
        String recipients = mCursorShoppingLists.getString(mStringListFilterSHARECONTACTS);

        // If recipients contains the '@' symbol, it is shared.
        return recipients.contains("@");
    }

    // Handle the process of automatically updating enabled sensors:
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == MESSAGE_UPDATE_CURSORS) {
                mCursorShoppingLists.requery();

                if (mUpdating) {
                    sendMessageDelayed(obtainMessage(MESSAGE_UPDATE_CURSORS), mUpdateInterval);
                }

            }
        }
    };

    /**
     * Listens for intents for updates in the database.
     *
     * @param context
     * @param intent
     */
    // TODO ???
    /*
     * public class ListIntentReceiver extends IntentReceiver {
     * 
     * public void onReceiveIntent(Context context, Intent intent) { String
     * action = intent.getAction(); Log.i(TAG, "ShoppingList received intent " +
     * action);
     * 
     * if (action.equals(OpenIntents.REFRESH_ACTION)) {
     * mCursorListFilter.requery();
     * 
     * } } }
     */
    /*
     * ListIntentReceiver mIntentReceiver;
     */

    /**
     * This method is called when the sending activity has finished, with the
     * result it supplied.
     *
     * @param requestCode The original request code as given to startActivity().
     * @param resultCode  From sending activity as per setResult().
     * @param data        From sending activity as per setResult().
     * @see android.app.Activity#onActivityResult(int, int, android.content.Intent)
     */
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (debug) {
            Log.i(TAG, "ShoppingView: onActivityResult. ");
        }

        if (requestCode == SUBACTIVITY_LIST_SHARE_SETTINGS) {
            if (debug) {
                Log.i(TAG, "SUBACTIVITY_LIST_SHARE_SETTINGS");
            }

            if (resultCode == RESULT_CANCELED) {
                // Don't do anything.
                if (debug) {
                    Log.i(TAG, "RESULT_CANCELED");
                }

            } else {
                // Broadcast the intent
                if (debug) {
                    Log.i(TAG, "Broadcast intent.");
                }

                // TODO ???
                /*
                 * Uri uri = Uri.parse(data);
                 */
                Uri uri = Uri.parse(data.getDataString());

                if (!mListUri.equals(uri)) {
                    Log.e(TAG, "Unexpected uri returned: Should be " + mListUri + " but was " + uri);
                    return;
                }

                // TODO ???
                Bundle extras = data.getExtras();

                String sharename = extras.getString(ShoppingContract.Lists.SHARE_NAME);
                String contacts = extras.getString(ShoppingContract.Lists.SHARE_CONTACTS);

                if (debug) {
                    Log.i(TAG, "Received bundle: sharename: " + sharename + ", contacts: " + contacts);
                }

                // Here we also send the current content of the list
                // to all recipients.
                // This could probably be optimized - by sending
                // content only to the new recipients, as the
                // old ones should be in sync already.
                // First delete all items in list
                /*
                 * mCursorItems.moveToPosition(-1); while
                 * (mCursorItems.moveToNext()) { String itemName = mCursorItems
                 * .getString(mStringItemsITEMNAME); Long status =
                 * mCursorItems.getLong(mStringItemsSTATUS); Log.i(TAG,
                 * "Update shared item. " + " recipients: " + contacts +
                 * ", shareName: " + sharename + ", item: " + itemName); // TODO
                 * ??? /* mGTalkSender.sendItemUpdate(contacts, sharename,
                 * itemName, itemName, status, status); / }
                 */
            }

        } else if (REQUEST_CODE_CATEGORY_ALTERNATIVE == requestCode) {
            if (debug) {
                Log.d(TAG, "result received");
            }
            if (RESULT_OK == resultCode) {
                if (debug) {
                    Log.d(TAG, "result OK");
                }
                // Check if any results have been returned:
                /*
                 * if ((data.getDataString() != null) &&
                 * (data.getDataString().startsWith
                 * (Shopping.Lists.CONTENT_URI.toString()))) { // We received a
                 * valid shopping list URI.
                 * 
                 * // Set current list to received list: mListUri =
                 * data.getData(); intent.setData(mListUri); }
                 */
                if (data.getExtras() != null) {
                    if (debug) {
                        Log.d(TAG, "extras received");
                    }
                    getShoppingExtras(data);
                }
            }
        } else if (REQUEST_PICK_LIST == requestCode) {
            if (debug) {
                Log.d(TAG, "result received");
            }

            if (RESULT_OK == resultCode) {
                int position = mMoveItemPosition;
                if (mMoveItemPosition >= 0) {
                    moveItem(position, Integer.parseInt(data.getData().getLastPathSegment()));
                }
            }

            mMoveItemPosition = -1;
        }
    }

    public void changeList(int value) {

        int pos = mShoppingListsView.getSelectedItemPosition();
        // Temp- Due to architecture requirements of OS 3, the value can not be
        // passed directly
        if (pos == -1 && !usingListSpinner()) {
            try {
                pos = (Integer) mShoppingListsView.getTag();
                pos = mCursorShoppingLists.getCount() <= pos ? -1 : pos;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        int newPos;

        if (pos < 0) {
            // nothing selected - probably view is out of focus:
            // Do nothing.
            newPos = -1;
        } else if (pos == 0) {
            newPos = mShoppingListsView.getCount() - 1;
        } else if (pos == mShoppingListsView.getCount()) {
            newPos = 0;
        } else {
            newPos = pos + value;
        }
        setSelectedListPos(newPos);
    }

    private class DrawerListAdapter implements WrapperListAdapter, OnItemClickListener {

        private ListAdapter mAdapter = null;
        private int mNumAboveList = 3;
        private int mNumBelowList = 1;
        private int mWrappedViewTypeNum;
        private int mViewTypeNum;
        private int[] mHeaderItemTypes;
        LayoutInflater mInflater;

        public DrawerListAdapter(Context context, ListAdapter adapter) {
            mAdapter = adapter;
            mViewTypeNum = mWrappedViewTypeNum = mAdapter.getViewTypeCount();
            mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        }

        @Override
        public boolean areAllItemsEnabled() {
            return false;
        }

        @Override
        public boolean isEnabled(int position) {
            int list_pos, post_pos;
            int list_count = mAdapter.getCount();
            if (position < mNumAboveList) {
                return (position != 2); // not the "Lists" header
            } else if ((list_pos = position - mNumAboveList) < list_count) {
                // actual list entries can be selected
            } else {
                post_pos = list_pos - list_count;
                // New List button can be selected
            }
            return true;
        }

        @Override
        public int getCount() {
            // TODO Auto-generated method stub
            return mAdapter.getCount() + mNumAboveList + mNumBelowList;
        }

        @Override
        public Object getItem(int position) {
            int list_pos, post_pos;
            int list_count = mAdapter.getCount();
            if (position < mNumAboveList) {
            } else if ((list_pos = position - mNumAboveList) < list_count) {
                return mAdapter.getItem(list_pos);
            } else {
                post_pos = list_pos - list_count;
            }
            return null;
        }

        @Override
        public long getItemId(int position) {
            int list_pos, post_pos;
            int list_count = mAdapter.getCount();
            if (position < mNumAboveList) {

            } else if ((list_pos = position - mNumAboveList) < list_count) {
                return mAdapter.getItemId(list_pos);
            } else {
                post_pos = list_pos - list_count;
            }
            return -1;
        }

        @Override
        public int getItemViewType(int position) {
            int list_pos, post_pos;
            int list_count = mAdapter.getCount();
            if (position < mNumAboveList) {
            } else if ((list_pos = position - mNumAboveList) < list_count) {
                return mAdapter.getItemViewType(list_pos);
            }
            return IGNORE_ITEM_VIEW_TYPE;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            int list_pos, post_pos;
            int list_count = mAdapter.getCount();
            View v = null;
            View v2 = null;

            if (position < mNumAboveList) {
                switch (position) {
                case 1:
                    v = mInflater.inflate(R.layout.drawer_item_radio, parent, false);
                    v2 = v.findViewById(R.id.text1);
                    ((TextView) v2).setText(R.string.menu_pick_items);
                    v2 = v.findViewById(R.id.mode_radio_button);
                    v2.setSelected(mItemsView.mMode == MODE_ADD_ITEMS);
                    break;
                case 0:
                    v = mInflater.inflate(R.layout.drawer_item_radio, parent, false);
                    v2 = v.findViewById(R.id.text1);
                    ((TextView) v2).setText(R.string.menu_start_shopping);
                    v2 = v.findViewById(R.id.mode_radio_button);
                    v2.setSelected(mItemsView.mMode == MODE_IN_SHOP);
                    break;
                case 2:
                    v = mInflater.inflate(R.layout.drawer_item_header, parent, false);
                    ((TextView) v).setText(R.string.list); // fix me
                    break;
                }
            } else if ((list_pos = position - mNumAboveList) < list_count) {
                int curListPos = mShoppingListsView.getSelectedItemPosition();
                if (list_pos == curListPos) {
                    mDrawerListsView.setItemChecked(position, true);
                }
                v = mAdapter.getView(list_pos, convertView, parent);
            } else {
                post_pos = list_pos - list_count;
                v = mInflater.inflate(R.layout.drawer_item_radio, parent, false);
                v2 = v.findViewById(R.id.text1);
                ((TextView) v2).setText(R.string.new_list);
                v2 = v.findViewById(R.id.mode_radio_button);
                ((ImageView) v2).setImageResource(R.drawable.ic_menu_add_list);
            }
            return v;
        }

        @Override
        public int getViewTypeCount() {
            return mViewTypeNum;
        }

        @Override
        public boolean hasStableIds() {
            // TODO Auto-generated method stub
            return false;
        }

        @Override
        public boolean isEmpty() {
            return false;
        }

        @Override
        public void registerDataSetObserver(DataSetObserver observer) {
            mAdapter.registerDataSetObserver(observer);
        }

        @Override
        public void unregisterDataSetObserver(DataSetObserver observer) {
            mAdapter.unregisterDataSetObserver(observer);
        }

        @Override
        public ListAdapter getWrappedAdapter() {
            return mAdapter;
        }

        public void onItemClick(AdapterView parent, View v, int position, long id) {
            if (debug) {
                Log.d(TAG, "DrawerListAdapter: onItemClick");
            }

            int list_pos;
            int list_count = mAdapter.getCount();
            if (position < mNumAboveList) {
                // Pick Items or Shopping selected
                closeDrawer();
                mItemsView.mMode = (position == 1) ? MODE_ADD_ITEMS : MODE_IN_SHOP;
                mDrawerListsView.setItemChecked(position, true);
                mDrawerListsView.setItemChecked(1 - position, false);
                onModeChanged();
                // need to toggle the radio buttons too
            } else if ((list_pos = position - mNumAboveList) < list_count) {
                // Update list cursor:
                mShoppingListsView.setSelection(list_pos);
                getSelectedListId();

                // Set the theme based on the selected list:
                setListTheme(loadListTheme());

                // If it's the same list we had before, requery only
                // if a preference has changed since then.
                fillItems(id == mItemsView.getListId());

                // Apply the theme after the list has been filled:
                applyListTheme();

                updateTitle();

                mDrawerListsView.setItemChecked(position, true);
                closeDrawer();
            } else {
                closeDrawer();
                showDialog(DIALOG_NEW_LIST);
            }
        }
    }

    private void closeDrawer() {
        if (mDrawerLayout != null) {
            mDrawerLayout.closeDrawer(mDrawerListsView);
        }
    }

    /**
     * With the requirement of OS3, making an intermediary decision depending
     * upon the widget
     *
     * @param adapter
     */
    private void setSpinnerListAdapter(ListAdapter adapter) {
        DrawerListAdapter adapterWrapper = (new DrawerListAdapter(this, adapter));
        mDrawerListsView.setAdapter(adapterWrapper);
        mDrawerListsView.setOnItemClickListener(adapterWrapper);
        if (usingListSpinner()) {// Temp - restricted for OS3
            mShoppingListsView.setAdapter(adapter);
        } else {
            // TODO
        }
    }

    @Override
    public void onItemChanged() {
        mItemsView.mCursorItems.requery();
        fillAutoCompleteTextViewAdapter(mEditText);
    }

    private class ListSortActionProvider extends ActionProvider implements OnMenuItemClickListener {

        private Context mContext;
        private String mSortLabels[];
        private String mSortVals[];
        private Integer mSortValInts[];

        public ListSortActionProvider(Context context) {
            super(context);
            mContext = context;
            mSortLabels = mContext.getResources().getStringArray(R.array.preference_sortorder_entries);
            mSortVals = mContext.getResources().getStringArray(R.array.preference_sortorder_entryvalues);
            mSortValInts = new Integer[mSortVals.length];
            for (int i = 0; i < mSortVals.length; i++)
                mSortValInts[i] = Integer.parseInt(mSortVals[i]);
        }

        @Override
        public View onCreateActionView() {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public boolean hasSubMenu() {
            return true;
        }

        public void onPrepareSubMenu(SubMenu subMenu) {
            int i;
            saveActiveList(false);
            subMenu.clear();
            int curSort = PreferenceActivity.getSortOrderIndexFromPrefs(mContext, MODE_IN_SHOP);
            for (i = 0; i < mSortLabels.length; i++) {
                subMenu.add(1, i, i, mSortLabels[i]).setOnMenuItemClickListener(this)
                        .setChecked(mSortValInts[i] == curSort);
            }
            subMenu.setGroupCheckable(1, true, true);
        }

        public boolean overridesItemVisibility() {
            return true;
        }

        public boolean isVisible() {
            boolean vis = true;
            if (mItemsView.mMode != MODE_IN_SHOP) {
                vis = false;
            } else if (PreferenceActivity.getUsingPerListSortFromPrefs(mContext) == false) {
                vis = false;
            }
            if (mDrawerLayout != null && mDrawerLayout.isDrawerOpen(mDrawerListsView)) {
                vis = false;
            }
            return vis;
        }

        public boolean onMenuItemClick(MenuItem item) {
            int sortOrderNum = Integer.parseInt(mSortVals[item.getItemId()]);
            // String sortOrder = Contains.SORT_ORDERS[sortOrderNum];
            ContentValues values = new ContentValues();
            values.put(Lists.ITEMS_SORT, sortOrderNum);
            getContentResolver().update(mListUri, values, null, null);
            fillItems(false);
            return true;
        }
    }

    @Override
    public void onUndoAvailable(ToastBarOperation undoOp) {
        mToastBar.show(null, 0, undoOp.getDescription(this), true, R.string.undo, true, undoOp);
    }
}