diff --git a/src/com/android/browser/BaseUi.java b/src/com/android/browser/BaseUi.java
index 95e795c..1e9038d 100644
--- a/src/com/android/browser/BaseUi.java
+++ b/src/com/android/browser/BaseUi.java
@@ -231,22 +231,6 @@
         mActiveTab = tab;
         attachTabToContentView(tab);
         setShouldShowErrorConsole(tab, mUiController.shouldShowErrorConsole());
-        WebView view = tab.getWebView();
-        // TabControl.setCurrentTab has been called before this,
-        // so the tab is guaranteed to have a webview
-        if (view == null) {
-            Log.e(LOGTAG, "active tab with no webview detected");
-            return;
-        }
-        view.setEmbeddedTitleBar(getEmbeddedTitleBar());
-        if (tab.isInVoiceSearchMode()) {
-            showVoiceTitleBar(tab.getVoiceDisplayTitle());
-        } else {
-            revertVoiceTitleBar(tab);
-        }
-        resetTitleIconAndProgress(tab);
-        updateLockIconToLatest(tab);
-        tab.getTopWindow().requestFocus();
     }
 
     Tab getActiveTab() {
diff --git a/src/com/android/browser/BrowserSettings.java b/src/com/android/browser/BrowserSettings.java
index 1f091e2..1b8acc6 100644
--- a/src/com/android/browser/BrowserSettings.java
+++ b/src/com/android/browser/BrowserSettings.java
@@ -117,6 +117,9 @@
     private boolean navDump = false;
     private boolean hardwareAccelerated = true;
 
+    // Lab settings
+    private boolean quickControls = false;
+
     // By default the error console is shown once the user navigates to about:debug.
     // The setting can be then toggled from the settings menu.
     private boolean showConsole = true;
@@ -167,6 +170,8 @@
     public final static String PREF_HARDWARE_ACCEL = "enable_hardware_accel";
     public final static String PREF_USER_AGENT = "user_agent";
 
+    public final static String PREF_QUICK_CONTROLS = "enable_quick_controls";
+
     private static final String DESKTOP_USERAGENT = "Mozilla/5.0 (Macintosh; " +
             "U; Intel Mac OS X 10_6_3; en-us) AppleWebKit/533.16 (KHTML, " +
             "like Gecko) Version/5.0 Safari/533.16";
@@ -490,6 +495,8 @@
             navDump = p.getBoolean("enable_nav_dump", navDump);
         }
 
+        quickControls = p.getBoolean(PREF_QUICK_CONTROLS, quickControls);
+
         // Only set these on startup if it is a dev build
         if (DEV_BUILD) {
             userAgent = Integer.parseInt(p.getString(PREF_USER_AGENT, "0"));
@@ -573,6 +580,10 @@
         return hardwareAccelerated;
     }
 
+    public boolean useQuickControls() {
+        return quickControls;
+    }
+
     public boolean showDebugSettings() {
         return showDebugSettings;
     }
@@ -836,6 +847,8 @@
         } else if (PREF_USER_AGENT.equals(key)) {
             userAgent = Integer.parseInt(p.getString(PREF_USER_AGENT, "0"));
             update();
+        } else if (PREF_QUICK_CONTROLS.equals(key)) {
+            quickControls = p.getBoolean(PREF_QUICK_CONTROLS, quickControls);
         }
     }
 }
diff --git a/src/com/android/browser/PhoneUi.java b/src/com/android/browser/PhoneUi.java
index 66656cf..e35e624 100644
--- a/src/com/android/browser/PhoneUi.java
+++ b/src/com/android/browser/PhoneUi.java
@@ -19,6 +19,7 @@
 import android.app.Activity;
 import android.content.Context;
 import android.graphics.PixelFormat;
+import android.util.Log;
 import android.view.ActionMode;
 import android.view.Gravity;
 import android.view.Menu;
@@ -118,6 +119,27 @@
     }
 
     @Override
+    public void setActiveTab(Tab tab) {
+        super.setActiveTab(tab);
+        WebView view = tab.getWebView();
+        // TabControl.setCurrentTab has been called before this,
+        // so the tab is guaranteed to have a webview
+        if (view == null) {
+            Log.e(LOGTAG, "active tab with no webview detected");
+            return;
+        }
+        view.setEmbeddedTitleBar(getEmbeddedTitleBar());
+        if (tab.isInVoiceSearchMode()) {
+            showVoiceTitleBar(tab.getVoiceDisplayTitle());
+        } else {
+            revertVoiceTitleBar(tab);
+        }
+        resetTitleIconAndProgress(tab);
+        updateLockIconToLatest(tab);
+        tab.getTopWindow().requestFocus();
+    }
+
+    @Override
     protected void attachFakeTitleBar(WebView mainView) {
         WindowManager manager = (WindowManager)
                 mActivity.getSystemService(Context.WINDOW_SERVICE);
diff --git a/src/com/android/browser/PieControl.java b/src/com/android/browser/PieControl.java
new file mode 100644
index 0000000..210e9ea
--- /dev/null
+++ b/src/com/android/browser/PieControl.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.browser;
+
+import com.android.browser.view.PieMenu;
+
+import android.app.Activity;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup.LayoutParams;
+import android.webkit.WebView;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * controller for Quick Controls pie menu
+ */
+public class PieControl implements OnClickListener, PieMenu.PieController {
+
+    private Activity mActivity;
+    private UiController mUiController;
+    private XLargeUi mUi;
+    private PieMenu mPie;
+    private ImageView mBack;
+    private ImageView mForward;
+    private ImageView mRefresh;
+    private ImageView mUrl;
+    private ImageView mOptions;
+    private ImageView mBookmarks;
+    private ImageView mNewTab;
+    private ImageView mClose;
+
+    private Map<View,Tab> mTabItems;
+
+    boolean mNewTabMode = true;
+
+    public PieControl(Activity activity, UiController controller, XLargeUi ui) {
+        mActivity = activity;
+        mUiController = controller;
+        mUi = ui;
+        mTabItems = new HashMap<View, Tab>();
+    }
+
+    protected void attachToContainer(FrameLayout container) {
+        if (mPie == null) {
+            mPie = new PieMenu(mActivity);
+            LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT,
+                    LayoutParams.MATCH_PARENT);
+            mPie.setLayoutParams(lp);
+            mForward = makeMenuView(R.drawable.ic_pie_forward);
+            mPie.addItem(mForward);
+            mRefresh = makeMenuView(R.drawable.ic_pie_refresh);
+            mPie.addItem(mRefresh);
+            mBack = makeMenuView(R.drawable.ic_pie_back);
+            mPie.addItem(mBack);
+            mUrl = makeMenuView(R.drawable.ic_pie_search);
+            mPie.addItem(mUrl);
+            mBookmarks = makeMenuView(R.drawable.ic_pie_bookmarks);
+            mPie.addItem(mBookmarks);
+            mNewTab = makeMenuView(R.drawable.ic_pie_new_tab);
+            mPie.addItem(mNewTab);
+            mOptions = makeMenuView(R.drawable.ic_pie_more);
+            mPie.addItem(mOptions);
+            setClickListener(mBack, mForward, mRefresh, mUrl, mOptions,
+                    mBookmarks, mNewTab);
+            mPie.setController(this);
+        }
+        container.addView(mPie);
+    }
+
+    protected void removeFromContainer(FrameLayout container) {
+        container.removeView(mPie);
+    }
+
+    private ImageView makeMenuView(int image) {
+        ImageView item = new ImageView(mActivity);
+        item.setImageResource(image);
+        LayoutParams lp = new LayoutParams(48, 48);
+        item.setLayoutParams(lp);
+        return item;
+    }
+
+    private void setClickListener(View... views) {
+        for (View view : views) {
+            view.setOnClickListener(this);
+        }
+    }
+
+    protected void forceToTop(FrameLayout container) {
+        if (mPie.getParent() != null) {
+            container.removeView(mPie);
+            container.addView(mPie);
+        }
+    }
+
+    @Override
+    public void onClick(View v) {
+        mPie.show(false);
+        Tab tab = mUiController.getTabControl().getCurrentTab();
+        WebView web = tab.getWebView();
+        if (mBack == v) {
+            web.goBack();
+        } else if (mForward == v) {
+            web.goForward();
+        } else if (mRefresh == v) {
+            if (tab.inPageLoad()) {
+                web.stopLoading();
+            } else {
+                web.reload();
+            }
+        } else if (mUrl == v) {
+            mUi.showFakeTitleBarAndEdit();
+        } else if (mOptions == v) {
+            mActivity.openOptionsMenu();
+        } else if (mBookmarks == v) {
+            mUiController.bookmarksOrHistoryPicker(false);
+        } else if (mNewTab == v) {
+            mUiController.openTabToHomePage();
+        } else if (mClose == v) {
+            mUiController.closeCurrentTab();
+        } else {
+            Tab ntab = mTabItems.get(v);
+            if (ntab != null) {
+                mUiController.switchToTab(mUiController.getTabControl().getTabIndex(ntab));
+            }
+        }
+    }
+
+    @Override
+    public boolean onOpen() {
+        return true;
+    }
+
+}
diff --git a/src/com/android/browser/TabBar.java b/src/com/android/browser/TabBar.java
index 6a139f3..ea734a6 100644
--- a/src/com/android/browser/TabBar.java
+++ b/src/com/android/browser/TabBar.java
@@ -88,6 +88,7 @@
     private int mTabOverlap;
     private int mTabSliceWidth;
     private int mTabPadding;
+    private boolean mUseQuickControls;
 
     public TabBar(Activity activity, UiController controller, XLargeUi ui) {
         super(activity);
@@ -139,6 +140,14 @@
         mShaderPaint.setAntiAlias(true);
     }
 
+    void setUseQuickControls(boolean useQuickControls) {
+        mUseQuickControls = useQuickControls;
+    }
+
+    int getTabCount() {
+        return mTabMap.size();
+    }
+
     void updateTabs(List<Tab> tabs) {
         mTabs.clearTabs();
         mTabMap.clear();
@@ -182,6 +191,7 @@
         if (mNewTab == view) {
             mUiController.openTabToHomePage();
         } else if (mTabs.getSelectedTab() == view) {
+            if (mUseQuickControls) return;
             if (mUi.isFakeTitleBarShowing() && !isLoading()) {
                 mUi.hideFakeTitleBar();
             } else {
@@ -202,7 +212,7 @@
         mUserRequestedUrlbar = true;
     }
 
-    private void showTitleBarIndicator(boolean show) {
+    void showTitleBarIndicator(boolean show) {
         Tab tab = mTabControl.getCurrentTab();
         if (tab != null) {
             TabViewData tvd = mTabMap.get(tab);
@@ -229,6 +239,7 @@
 
     @Override
     public void onScroll(int visibleTitleHeight) {
+        if (mUseQuickControls) return;
         // isLoading is using the current tab, which initially might not be set yet
         if (mTabControl.getCurrentTab() != null) {
             if ((mVisibleTitleHeight != 0) && (visibleTitleHeight == 0)
@@ -417,7 +428,7 @@
             int[] pos = new int[2];
             getLocationInWindow(mWindowPos);
             Drawable drawable = mSelected ? mActiveDrawable : mInactiveDrawable;
-            drawable.setBounds(0, 0, mUi.getTitleBarWidth(), getHeight());
+            drawable.setBounds(0, 0, mUi.getContentWidth(), getHeight());
             drawClipped(canvas, drawable, mPath, mWindowPos[0]);
             canvas.restoreToCount(state);
             super.dispatchDraw(canvas);
diff --git a/src/com/android/browser/TitleBarXLarge.java b/src/com/android/browser/TitleBarXLarge.java
index b680512..f1c6c6b 100644
--- a/src/com/android/browser/TitleBarXLarge.java
+++ b/src/com/android/browser/TitleBarXLarge.java
@@ -73,6 +73,7 @@
 
     private boolean mInLoad;
     private boolean mEditable;
+    private boolean mUseQuickControls;
 
     public TitleBarXLarge(Activity activity, UiController controller,
             XLargeUi ui) {
@@ -140,6 +141,29 @@
         }
     }
 
+    void setUseQuickControls(boolean useQuickControls) {
+        mUseQuickControls = useQuickControls;
+        if (mUseQuickControls) {
+            mBackButton.setVisibility(View.GONE);
+            mForwardButton.setVisibility(View.GONE);
+            mStopButton.setVisibility(View.GONE);
+            mAllButton.setVisibility(View.GONE);
+        } else {
+            mBackButton.setVisibility(View.VISIBLE);
+            mForwardButton.setVisibility(View.VISIBLE);
+            mStopButton.setVisibility(View.VISIBLE);
+            mAllButton.setVisibility(View.VISIBLE);
+        }
+    }
+
+    void setShowProgressOnly(boolean progress) {
+        if (progress) {
+            mContainer.setVisibility(View.GONE);
+        } else {
+            mContainer.setVisibility(View.VISIBLE);
+        }
+    }
+
     @Override
     public void onFocusChange(View view, boolean hasFocus) {
         if (!mEditable && hasFocus) {
@@ -291,12 +315,16 @@
             updateSearchMode();
         } else {
             mUrlInput.clearFocus();
-            mSearchButton.setVisibility(View.VISIBLE);
             mGoButton.setVisibility(View.GONE);
             mVoiceSearch.setVisibility(View.GONE);
             mStar.setVisibility(View.VISIBLE);
             mClearButton.setVisibility(View.GONE);
             mVoiceSearchIndicator.setVisibility(View.GONE);
+            if (mUseQuickControls) {
+                mSearchButton.setVisibility(View.GONE);
+            } else {
+                mSearchButton.setVisibility(View.VISIBLE);
+            }
         }
     }
 
diff --git a/src/com/android/browser/XLargeUi.java b/src/com/android/browser/XLargeUi.java
index 69e6724..7f9baa7 100644
--- a/src/com/android/browser/XLargeUi.java
+++ b/src/com/android/browser/XLargeUi.java
@@ -21,8 +21,12 @@
 import android.app.ActionBar;
 import android.app.Activity;
 import android.graphics.Bitmap;
+import android.util.Log;
 import android.view.ActionMode;
+import android.view.Gravity;
 import android.webkit.WebView;
+import android.widget.FrameLayout;
+import android.widget.FrameLayout.LayoutParams;
 
 import java.util.List;
 
@@ -33,11 +37,15 @@
 
     private static final String LOGTAG = "XLargeUi";
 
+    private ActionBar mActionBar;
     private TabBar mTabBar;
 
     private TitleBarXLarge mTitleBar;
     private TitleBarXLarge mFakeTitleBar;
 
+    private boolean mUseQuickControls;
+    private PieControl mPieControl;
+
     /**
      * @param browser
      * @param controller
@@ -49,10 +57,51 @@
         mTitleBar.setEditable(false);
         mFakeTitleBar = new TitleBarXLarge(mActivity, mUiController, this);
         mFakeTitleBar.setEditable(true);
-        ActionBar actionBar = mActivity.getActionBar();
         mTabBar = new TabBar(mActivity, mUiController, this);
-        actionBar.setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM);
-        actionBar.setCustomView(mTabBar);
+        mActionBar = mActivity.getActionBar();
+        mActionBar.setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM);
+        mActionBar.setCustomView(mTabBar);
+        setUseQuickControls(BrowserSettings.getInstance().useQuickControls());
+    }
+
+    private void setUseQuickControls(boolean useQuickControls) {
+        mUseQuickControls = useQuickControls;
+        if (useQuickControls) {
+            checkTabCount();
+            mPieControl = new PieControl(mActivity, mUiController, this);
+            mPieControl.attachToContainer(mContentView);
+            setFakeTitleBarGravity(Gravity.BOTTOM);
+
+            // remove embedded title bar if present
+            WebView web = mTabControl.getCurrentWebView();
+            if ((web != null) && (web.getVisibleTitleHeight() > 0)) {
+                web.setEmbeddedTitleBar(null);
+            }
+        } else {
+            mActivity.getActionBar().show();
+            if (mPieControl != null) {
+                mPieControl.removeFromContainer(mContentView);
+            }
+            setFakeTitleBarGravity(Gravity.TOP);
+            // remove embedded title bar if present
+            WebView web = mTabControl.getCurrentWebView();
+            if ((web != null) && (web.getVisibleTitleHeight() == 0)) {
+                web.setEmbeddedTitleBar(mTitleBar);
+            }
+        }
+        mTabBar.setUseQuickControls(mUseQuickControls);
+        mFakeTitleBar.setUseQuickControls(mUseQuickControls);
+    }
+
+    private void checkTabCount() {
+        if (mUseQuickControls) {
+            int n = mTabBar.getTabCount();
+            if (n >= 2) {
+                mActivity.getActionBar().show();
+            } else if (n == 1) {
+                mActivity.getActionBar().hide();
+            }
+        }
     }
 
     @Override
@@ -114,6 +163,9 @@
     public void onPageFinished(Tab tab, String url) {
         mTabBar.onPageFinished(tab);
         super.onPageFinished(tab, url);
+        if (mUseQuickControls) {
+            mFakeTitleBar.setShowProgressOnly(false);
+        }
     }
 
     @Override
@@ -123,7 +175,17 @@
             mFakeTitleBar.setProgress(progress);
             if (progress == 100) {
                 hideFakeTitleBar();
+                if (mUseQuickControls) {
+                    mFakeTitleBar.setShowProgressOnly(false);
+                    setFakeTitleBarGravity(Gravity.BOTTOM);
+                }
             } else {
+                if (mUseQuickControls) {
+                    mFakeTitleBar.setShowProgressOnly(true);
+                    if (!isFakeTitleBarShowing()) {
+                        setFakeTitleBarGravity(Gravity.TOP);
+                    }
+                }
                 showFakeTitleBar();
             }
         }
@@ -137,28 +199,55 @@
     @Override
     public void addTab(Tab tab) {
         mTabBar.onNewTab(tab);
+        checkTabCount();
     }
 
     @Override
     public void setActiveTab(Tab tab) {
         super.setActiveTab(tab);
+        ScrollWebView view = (ScrollWebView) tab.getWebView();
+        // TabControl.setCurrentTab has been called before this,
+        // so the tab is guaranteed to have a webview
+        if (view == null) {
+            Log.e(LOGTAG, "active tab with no webview detected");
+            return;
+        }
+        // Request focus on the top window.
+        if (mUseQuickControls) {
+            mPieControl.forceToTop(mContentView);
+            view.setScrollListener(null);
+            mTabBar.showTitleBarIndicator(false);
+        } else {
+            view.setEmbeddedTitleBar(mTitleBar);
+            view.setScrollListener(this);
+        }
         mTabBar.onSetActiveTab(tab);
+        if (tab.isInVoiceSearchMode()) {
+            showVoiceTitleBar(tab.getVoiceDisplayTitle());
+        } else {
+            revertVoiceTitleBar(tab);
+        }
+        resetTitleIconAndProgress(tab);
+        updateLockIconToLatest(tab);
+        tab.getTopWindow().requestFocus();
     }
 
     @Override
     public void updateTabs(List<Tab> tabs) {
         mTabBar.updateTabs(tabs);
+        checkTabCount();
     }
 
     @Override
     public void removeTab(Tab tab) {
         super.removeTab(tab);
         mTabBar.onRemoveTab(tab);
+        checkTabCount();
     }
 
-    int getTitleBarWidth() {
-        if (mTitleBar != null) {
-            return mTitleBar.getWidth();
+    int getContentWidth() {
+        if (mContentView != null) {
+            return mContentView.getWidth();
         }
         return 0;
     }
@@ -168,6 +257,22 @@
         mFakeTitleBar.onEditUrl(clearInput);
     }
 
+    void setFakeTitleBarGravity(int gravity) {
+        FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams)
+                mFakeTitleBar.getLayoutParams();
+        if (lp == null) {
+            lp = new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT,
+                    LayoutParams.WRAP_CONTENT);
+        }
+        lp.gravity = gravity;
+        mFakeTitleBar.setLayoutParams(lp);
+    }
+
+    void showFakeTitleBarAndEdit() {
+        showFakeTitleBar();
+        mFakeTitleBar.onEditUrl(false);
+    }
+
     @Override
     protected void attachFakeTitleBar(WebView mainView) {
         mContentView.addView(mFakeTitleBar);
@@ -208,6 +313,20 @@
     }
 
     @Override
+    public void onActionModeFinished(boolean inLoad) {
+        checkTabCount();
+        if (inLoad) {
+            // the titlebar was removed when the CAB was shown
+            // if the page is loading, show it again
+            mFakeTitleBar.setShowProgressOnly(true);
+            if (!isFakeTitleBarShowing()) {
+                setFakeTitleBarGravity(Gravity.TOP);
+            }
+            showFakeTitleBar();
+        }
+    }
+
+    @Override
     public void setUrlTitle(Tab tab, String url, String title) {
         super.setUrlTitle(tab, url, title);
         mTabBar.onUrlAndTitle(tab, url, title);
diff --git a/src/com/android/browser/preferences/LabPreferencesFragment.java b/src/com/android/browser/preferences/LabPreferencesFragment.java
new file mode 100644
index 0000000..8a8546f
--- /dev/null
+++ b/src/com/android/browser/preferences/LabPreferencesFragment.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.browser.preferences;
+
+import com.android.browser.BrowserActivity;
+import com.android.browser.BrowserSettings;
+import com.android.browser.Controller;
+import com.android.browser.R;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceChangeListener;
+import android.preference.PreferenceActivity.Header;
+import android.preference.PreferenceFragment;
+import android.preference.PreferenceManager.OnActivityResultListener;
+
+import java.io.IOException;
+import java.io.Serializable;
+
+public class LabPreferencesFragment extends PreferenceFragment
+        implements OnPreferenceChangeListener {
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // Load the XML preferences file
+        addPreferencesFromResource(R.xml.lab_preferences);
+
+        Preference e = findPreference(BrowserSettings.PREF_QUICK_CONTROLS);
+        e.setOnPreferenceChangeListener(this);
+    }
+
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        // Attempt to restart
+        startActivity(new Intent(BrowserActivity.ACTION_RESTART, null,
+                getActivity(), BrowserActivity.class));
+        return true;
+    }
+
+}
diff --git a/src/com/android/browser/view/PieMenu.java b/src/com/android/browser/view/PieMenu.java
new file mode 100644
index 0000000..d838a34
--- /dev/null
+++ b/src/com/android/browser/view/PieMenu.java
@@ -0,0 +1,463 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.browser.view;
+
+import com.android.browser.R;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Point;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.FrameLayout;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class PieMenu extends FrameLayout {
+
+    private static final int RADIUS_GAP = 10;
+
+    public interface PieController {
+        /**
+         * called before menu opens to customize menu
+         * returns if pie state has been changed
+         */
+        public boolean onOpen();
+    }
+    private Point mCenter;
+    private int mRadius;
+    private int mRadiusInc;
+    private int mSlop;
+
+    private boolean mOpen;
+    private Paint mPaint;
+    private Paint mSelectedPaint;
+    private PieController mController;
+
+    private Map<View, List<View>> mMenu;
+    private List<View> mStack;
+
+    private boolean mDirty;
+
+    /**
+     * @param context
+     * @param attrs
+     * @param defStyle
+     */
+    public PieMenu(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        init(context);
+    }
+
+    /**
+     * @param context
+     * @param attrs
+     */
+    public PieMenu(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context);
+    }
+
+    /**
+     * @param context
+     */
+    public PieMenu(Context context) {
+        super(context);
+        init(context);
+    }
+
+    private void init(Context ctx) {
+        this.setTag(new MenuTag(0));
+        mStack = new ArrayList<View>();
+        mStack.add(this);
+        Resources res = ctx.getResources();
+        mRadius = (int) res.getDimension(R.dimen.qc_radius);
+        mRadiusInc = (int) res.getDimension(R.dimen.qc_radius_inc);
+        mSlop = (int) res.getDimension(R.dimen.qc_slop);
+        mPaint = new Paint();
+        mPaint.setAntiAlias(true);
+        mPaint.setColor(res.getColor(R.color.qc_slice_normal));
+        mSelectedPaint = new Paint();
+        mSelectedPaint.setAntiAlias(true);
+        mSelectedPaint.setColor(res.getColor(R.color.qc_slice_active));
+        mOpen = false;
+        mMenu = new HashMap<View, List<View>>();
+        setWillNotDraw(false);
+        setDrawingCacheEnabled(false);
+        mCenter = new Point(0,0);
+        mDirty = true;
+    }
+
+    public void setController(PieController ctl) {
+        mController = ctl;
+    }
+
+    public void setRadius(int r) {
+        mRadius = r;
+        requestLayout();
+    }
+
+    public void setRadiusIncrement(int ri) {
+        mRadiusInc = ri;
+        requestLayout();
+    }
+
+    /**
+     * add a menu item to another item as a submenu
+     * @param item
+     * @param parent
+     */
+    public void addItem(View item, View parent) {
+        List<View> subs = mMenu.get(parent);
+        if (subs == null) {
+            subs = new ArrayList<View>();
+            mMenu.put(parent, subs);
+        }
+        subs.add(item);
+        MenuTag tag = new MenuTag(((MenuTag) parent.getTag()).level + 1);
+        item.setTag(tag);
+    }
+
+    public void addItem(View view) {
+        // add the item to the pie itself
+        addItem(view, this);
+    }
+
+    public void removeItem(View view) {
+        List<View> subs = mMenu.get(view);
+        mMenu.remove(view);
+        for (View p : mMenu.keySet()) {
+            List<View> sl = mMenu.get(p);
+            if (sl != null) {
+                sl.remove(view);
+            }
+        }
+    }
+
+    public void clearItems(View parent) {
+        List<View> subs = mMenu.remove(parent);
+        if (subs != null) {
+            for (View sub: subs) {
+                clearItems(sub);
+            }
+        }
+    }
+
+    public void clearItems() {
+        mMenu.clear();
+    }
+
+
+    public void show(boolean show) {
+        mOpen = show;
+        if (mOpen) {
+            if (mController != null) {
+                boolean changed = mController.onOpen();
+            }
+            mDirty = true;
+        }
+        if (!show) {
+            // hide sub items
+            mStack.clear();
+            mStack.add(this);
+        }
+        invalidate();
+    }
+
+    private void setCenter(int x, int y) {
+        if (x < mSlop) {
+            mCenter.x = 0;
+        } else {
+            mCenter.x = getWidth();
+        }
+        mCenter.y = y;
+    }
+
+    private boolean onTheLeft() {
+        return mCenter.x < mSlop;
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        if (mOpen) {
+            int radius = mRadius;
+            // start in the center for 0 level menu
+            float anchor = (float) Math.PI / 2;
+            PointF angles = new PointF();
+            int state = canvas.save();
+            if (onTheLeft()) {
+                // left handed
+                canvas.scale(-1, 1);
+            }
+            for (View parent : mStack) {
+                List<View> subs = mMenu.get(parent);
+                if (subs != null) {
+                    setGeometry(anchor, subs.size(), angles);
+                }
+                anchor = drawSlices(canvas, subs, radius, angles.x, angles.y);
+                radius += mRadiusInc + RADIUS_GAP;
+            }
+            canvas.restoreToCount(state);
+            mDirty = false;
+        }
+    }
+
+    /**
+     * draw the set of slices
+     * @param canvas
+     * @param items
+     * @param radius
+     * @param start
+     * @param sweep
+     * @return the angle of the selected slice
+     */
+    private float drawSlices(Canvas canvas, List<View> items, int radius,
+            float start, float sweep) {
+        float angle = start + sweep / 2;
+        // gap between slices in degrees
+        float gap = 1f;
+        float newanchor = 0f;
+        for (View item : items) {
+            if (mDirty) {
+                item.measure(item.getLayoutParams().width,
+                        item.getLayoutParams().height);
+                int w = item.getMeasuredWidth();
+                int h = item.getMeasuredHeight();
+                int x = (int) (radius * Math.sin(angle));
+                int y =  mCenter.y - (int) (radius * Math.cos(angle)) - h / 2;
+                if (onTheLeft()) {
+                    x = mCenter.x + x - w / 2;
+                } else {
+                    x = mCenter.x - x - w / 2;
+                }
+                item.layout(x, y, x + w, y + h);
+            }
+            float itemstart = angle - sweep / 2;
+            int inner = radius - mRadiusInc / 2;
+            int outer = radius + mRadiusInc / 2;
+            Path slice = makeSlice(getDegrees(itemstart) - gap,
+                    getDegrees(itemstart + sweep) + gap,
+                    outer, inner, mCenter);
+            MenuTag tag = (MenuTag) item.getTag();
+            tag.start = itemstart;
+            tag.sweep = sweep;
+            tag.inner = inner;
+            tag.outer = outer;
+
+            Paint p = item.isPressed() ? mSelectedPaint : mPaint;
+            canvas.drawPath(slice, p);
+            int state = canvas.save();
+            if (onTheLeft()) {
+                canvas.scale(-1, 1);
+            }
+            canvas.translate(item.getX(), item.getY());
+            item.draw(canvas);
+            canvas.restoreToCount(state);
+            if (mStack.contains(item)) {
+                // item is anchor for sub menu
+                newanchor = angle;
+            }
+            angle += sweep;
+        }
+        return newanchor;
+    }
+
+    /**
+     * converts a
+     * @param angle from 0..PI to Android degrees (clockwise starting at 3 o'clock)
+     * @return skia angle
+     */
+    private float getDegrees(double angle) {
+        return (float) (270 - 180 * angle / Math.PI);
+    }
+
+    private Path makeSlice(float startangle, float endangle, int outerradius,
+            int innerradius, Point center) {
+        RectF bb = new RectF(center.x - outerradius, center.y - outerradius,
+                center.x + outerradius, center.y + outerradius);
+        RectF bbi = new RectF(center.x - innerradius, center.y - innerradius,
+                center.x + innerradius, center.y + innerradius);
+        Path path = new Path();
+        path.arcTo(bb, startangle, endangle - startangle, true);
+        path.arcTo(bbi, endangle, startangle - endangle);
+        path.close();
+        return path;
+    }
+
+    /**
+     * all angles are 0 .. MATH.PI where 0 points up, and rotate counterclockwise
+     * set the startangle and slice sweep in result
+     * @param anchorangle : angle at which the menu is anchored
+     * @param nslices
+     * @param result : x : start, y : sweep
+     */
+    private void setGeometry(float anchorangle, int nslices, PointF result) {
+        float span = (float) Math.min(anchorangle, Math.PI - anchorangle);
+        float sweep = 2 * span / (nslices + 1);
+        result.x = anchorangle - span + sweep / 2;
+        result.y = sweep;
+    }
+
+    // touch handling for pie
+
+    View mCurrentView;
+    Rect mHitRect = new Rect();
+
+    @Override
+    public boolean onTouchEvent(MotionEvent evt) {
+        float x = evt.getX();
+        float y = evt.getY();
+        int action = evt.getActionMasked();
+        int edges = evt.getEdgeFlags();
+        if (MotionEvent.ACTION_DOWN == action) {
+            if ((x > getWidth() - mSlop) || (x < mSlop)) {
+                setCenter((int) x, (int) y);
+                show(true);
+                return true;
+            }
+        } else if (MotionEvent.ACTION_UP == action) {
+            if (mOpen) {
+                View v = mCurrentView;
+                deselect();
+                if (v != null) {
+                    v.performClick();
+                }
+                show(false);
+                return true;
+            }
+        } else if (MotionEvent.ACTION_CANCEL == action) {
+            if (mOpen) {
+                show(false);
+            }
+            deselect();
+            return false;
+        } else if (MotionEvent.ACTION_MOVE == action) {
+            View v = findView((int) x, (int) y);
+            if (mCurrentView != v) {
+                onEnter(v);
+                invalidate();
+            }
+        }
+        // always re-dispatch event
+        return false;
+    }
+
+    /**
+     * enter a slice for a view
+     * updates model only
+     * @param view
+     */
+    private void onEnter(View view) {
+        // deselect
+        if (mCurrentView != null) {
+            if (getLevel(mCurrentView) >= getLevel(view)) {
+                mCurrentView.setPressed(false);
+            }
+        }
+        if (view != null) {
+            // clear up stack
+            MenuTag tag = (MenuTag) view.getTag();
+            int i = mStack.size() - 1;
+            while (i > 0) {
+                View v = mStack.get(i);
+                if (((MenuTag) v.getTag()).level >= tag.level) {
+                    v.setPressed(false);
+                    mStack.remove(i);
+                } else {
+                    break;
+                }
+                i--;
+            }
+            List<View> items = mMenu.get(view);
+            if (items != null) {
+                mStack.add(view);
+                mDirty = true;
+            }
+            view.setPressed(true);
+        }
+        mCurrentView = view;
+    }
+
+    private void deselect() {
+        if (mCurrentView != null) {
+            mCurrentView.setPressed(false);
+        }
+        mCurrentView = null;
+    }
+
+    private int getLevel(View v) {
+        if (v == null) return -1;
+        return ((MenuTag) v.getTag()).level;
+    }
+
+    private View findView(int x, int y) {
+        // get angle and radius from x/y
+        float angle = (float) Math.PI / 2;
+        x = mCenter.x - x;
+        if (mCenter.x < mSlop) {
+            x = -x;
+        }
+        y = mCenter.y - y;
+        float dist = (float) Math.sqrt(x * x + y * y);
+        if (y > 0) {
+            angle = (float) Math.asin(x / dist);
+        } else if (y < 0) {
+            angle = (float) (Math.PI - Math.asin(x / dist ));
+        }
+        // find the matching item:
+        for (View parent : mStack) {
+            List<View> subs = mMenu.get(parent);
+            if (subs != null) {
+                for (View item : subs) {
+                    MenuTag tag = (MenuTag) item.getTag();
+                    if ((tag.inner < dist)
+                            && (tag.outer > dist)
+                            && (tag.start < angle)
+                            && (tag.start + tag.sweep > angle)) {
+                        return item;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    class MenuTag {
+
+        int level;
+        float start;
+        float sweep;
+        int inner;
+        int outer;
+
+        public MenuTag(int l) {
+            level = l;
+        }
+
+    }
+
+}