diff --git a/src/com/android/browser/BrowserActivity.java b/src/com/android/browser/BrowserActivity.java
index ad82fd0..8afd3b4 100644
--- a/src/com/android/browser/BrowserActivity.java
+++ b/src/com/android/browser/BrowserActivity.java
@@ -121,9 +121,9 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.Vector;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import java.util.Vector;
 
 public class BrowserActivity extends Activity
     implements View.OnCreateContextMenuListener, DownloadListener {
@@ -214,8 +214,12 @@
                 & Configuration.SCREENLAYOUT_SIZE_MASK)
                 == Configuration.SCREENLAYOUT_SIZE_XLARGE;
 
+        // Create the tab control and our initial tab
+        mTabControl = new TabControl(this);
+
+
         if (mXLargeScreenSize) {
-            mTitleBar = new TitleBarXLarge(this);
+            mTitleBar = new TitleBarXLarge(this, mTabControl);
             LinearLayout layout = (LinearLayout) mBrowserFrameLayout.
                     findViewById(R.id.vertical_layout);
             layout.addView(mTitleBar, 0, new LinearLayout.LayoutParams(
@@ -230,8 +234,6 @@
             mFakeTitleBar = new TitleBar(this);
         }
 
-        // Create the tab control and our initial tab
-        mTabControl = new TabControl(this);
 
         // Open the icon database and retain all the bookmark urls for favicons
         retainIconsOnStartup();
@@ -851,6 +853,12 @@
         return true;
     }
 
+    private void rebuildTitleBar() {
+        if (mXLargeScreenSize) {
+            ((TitleBarXLarge) mTitleBar).rebuildLayout();
+        }
+    }
+
     private void showFakeTitleBar() {
         if (mXLargeScreenSize) return;
         if (mFakeTitleBar.getParent() == null && mActiveTabsPage == null
@@ -1060,6 +1068,7 @@
             showHttpAuthentication(mHttpAuthHandler, null, null, title,
                     name, password, focusId);
         }
+        rebuildTitleBar();
     }
 
     @Override
diff --git a/src/com/android/browser/BrowserBookmarksPage.java b/src/com/android/browser/BrowserBookmarksPage.java
index 320c438..6af14e8 100644
--- a/src/com/android/browser/BrowserBookmarksPage.java
+++ b/src/com/android/browser/BrowserBookmarksPage.java
@@ -23,16 +23,6 @@
 import android.content.SharedPreferences;
 import android.content.SharedPreferences.Editor;
 import android.graphics.Bitmap;
-import android.graphics.BitmapFactory;
-import android.graphics.Canvas;
-import android.graphics.Color;
-import android.graphics.Paint;
-import android.graphics.Path;
-import android.graphics.PorterDuff;
-import android.graphics.PorterDuffXfermode;
-import android.graphics.Rect;
-import android.graphics.RectF;
-import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.Handler;
@@ -53,6 +43,7 @@
 import android.widget.GridView;
 import android.widget.ListView;
 import android.widget.Toast;
+import android.widget.AdapterView.OnItemClickListener;
 
 /*package*/ enum BookmarkViewMode { NONE, GRID, LIST }
 /**
@@ -269,13 +260,14 @@
         new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... unused) {
-                BrowserBookmarksAdapter adapter = new BrowserBookmarksAdapter(
-                        BrowserBookmarksPage.this,
-                        url,
-                        title,
-                        thumbnail,
-                        createShortcut,
-                        mostVisited);
+                BrowserBookmarksAdapter adapter =
+                    new BrowserBookmarksAdapter(
+                            BrowserBookmarksPage.this,
+                            url,
+                            title,
+                            thumbnail,
+                            createShortcut,
+                            mostVisited);
                 mHandler.obtainMessage(ADAPTER_CREATED, adapter).sendToTarget();
                 return null;
             }
@@ -352,7 +344,7 @@
                 }
                 listView.setDrawSelectorOnTop(false);
                 listView.setVerticalScrollBarEnabled(true);
-                listView.setOnItemClickListener(mListener);
+                listView.setOnItemClickListener(mListListener);
                 if (mMostVisited) {
                     listView.setEmptyView(mEmptyView);
                 }
@@ -416,7 +408,29 @@
         }
     };
 
-    private AdapterView.OnItemClickListener mListener = new AdapterView.OnItemClickListener() {
+    private OnItemClickListener mListener = new OnItemClickListener() {
+        public void onItemClick(AdapterView parent, View v, int position, long id) {
+            // It is possible that the view has been canceled when we get to
+            // this point as back has a higher priority
+            if (mCanceled) {
+                android.util.Log.e(LOGTAG, "item clicked when dismissing");
+                return;
+            }
+            if (!mCreateShortcut) {
+                if (0 == position && !mMostVisited) {
+                    // XXX: Work-around for a framework issue.
+                    mHandler.sendEmptyMessage(SAVE_CURRENT_PAGE);
+                } else {
+                    loadUrl(position);
+                }
+            } else {
+                setResultToParent(RESULT_OK, createShortcutIntent(position));
+                finish();
+            }
+        }
+    };
+
+    private OnItemClickListener mListListener = new OnItemClickListener() {
         public void onItemClick(AdapterView parent, View v, int position, long id) {
             // It is possible that the view has been canceled when we get to
             // this point as back has a higher priority
@@ -658,4 +672,5 @@
                     resultCode, data);
         }
     }
+
 }
diff --git a/src/com/android/browser/BrowserProvider.java b/src/com/android/browser/BrowserProvider.java
index 1eec52b..7064180 100644
--- a/src/com/android/browser/BrowserProvider.java
+++ b/src/com/android/browser/BrowserProvider.java
@@ -29,8 +29,7 @@
 import android.content.SharedPreferences;
 import android.content.UriMatcher;
 import android.content.SharedPreferences.Editor;
-import android.content.pm.PackageManager;
-import android.content.pm.ResolveInfo;
+import android.content.res.Configuration;
 import android.database.AbstractCursor;
 import android.database.ContentObserver;
 import android.database.Cursor;
@@ -47,8 +46,6 @@
 import android.text.TextUtils;
 import android.util.Log;
 import android.util.Patterns;
-import android.util.TypedValue;
-
 
 import java.io.File;
 import java.io.FilenameFilter;
@@ -91,6 +88,17 @@
     private static final int SUGGEST_COLUMN_QUERY_ID = 8;
     private static final int SUGGEST_COLUMN_INTENT_EXTRA_DATA = 9;
 
+    // how many suggestions will be shown in dropdown
+    // 0..SHORT: filled by browser db
+    private static final int MAX_SUGGEST_SHORT_SMALL = 3;
+    // SHORT..LONG: filled by search suggestions
+    private static final int MAX_SUGGEST_LONG_SMALL = 6;
+
+    // large screen size shows more
+    private static final int MAX_SUGGEST_SHORT_LARGE = 6;
+    private static final int MAX_SUGGEST_LONG_LARGE = 9;
+
+
     // shared suggestion columns
     private static final String[] COLUMNS = new String[] {
             "_id",
@@ -104,10 +112,6 @@
             SearchManager.SUGGEST_COLUMN_QUERY,
             SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA};
 
-    private static final int MAX_SUGGESTION_SHORT_ENTRIES = 3;
-    private static final int MAX_SUGGESTION_LONG_ENTRIES = 6;
-    private static final String MAX_SUGGESTION_LONG_ENTRIES_STRING =
-            Integer.valueOf(MAX_SUGGESTION_LONG_ENTRIES).toString();
 
     // make sure that these match the index of TABLE_NAMES
     private static final int URI_MATCH_BOOKMARKS = 0;
@@ -167,6 +171,9 @@
 
     private SearchManager mSearchManager;
 
+    private int mMaxSuggestionShortSize;
+    private int mMaxSuggestionLongSize;
+
     public BrowserProvider() {
     }
 
@@ -350,6 +357,20 @@
     @Override
     public boolean onCreate() {
         final Context context = getContext();
+        boolean xlargeScreenSize = (context.getResources().getConfiguration().screenLayout
+                & Configuration.SCREENLAYOUT_SIZE_MASK)
+                == Configuration.SCREENLAYOUT_SIZE_XLARGE;
+        boolean isPortrait = (context.getResources().getConfiguration().orientation
+                == Configuration.ORIENTATION_PORTRAIT);
+
+
+        if (xlargeScreenSize && isPortrait) {
+            mMaxSuggestionLongSize = MAX_SUGGEST_LONG_LARGE;
+            mMaxSuggestionShortSize = MAX_SUGGEST_SHORT_LARGE;
+        } else {
+            mMaxSuggestionLongSize = MAX_SUGGEST_LONG_SMALL;
+            mMaxSuggestionShortSize = MAX_SUGGEST_SHORT_SMALL;
+        }
         mOpenHelper = new DatabaseHelper(context);
         mBackupManager = new BackupManager(context);
         // we added "picasa web album" into default bookmarks for version 19.
@@ -467,8 +488,8 @@
             mSuggestCursor = sc;
             mHistoryCount = hc != null ? hc.getCount() : 0;
             mSuggestionCount = sc != null ? sc.getCount() : 0;
-            if (mSuggestionCount > (MAX_SUGGESTION_LONG_ENTRIES - mHistoryCount)) {
-                mSuggestionCount = MAX_SUGGESTION_LONG_ENTRIES - mHistoryCount;
+            if (mSuggestionCount > (mMaxSuggestionLongSize - mHistoryCount)) {
+                mSuggestionCount = mMaxSuggestionLongSize - mHistoryCount;
             }
             mString = string;
             mIncludeWebSearch = string.length() > 0;
@@ -682,6 +703,7 @@
         }
 
         // TODO Temporary change, finalize after jq's changes go in
+        @Override
         public void deactivate() {
             if (mHistoryCursor != null) {
                 mHistoryCursor.deactivate();
@@ -692,12 +714,14 @@
             super.deactivate();
         }
 
+        @Override
         public boolean requery() {
             return (mHistoryCursor != null ? mHistoryCursor.requery() : false) |
                     (mSuggestCursor != null ? mSuggestCursor.requery() : false);
         }
 
         // TODO Temporary change, finalize after jq's changes go in
+        @Override
         public void close() {
             super.close();
             if (mHistoryCursor != null) {
@@ -762,12 +786,15 @@
         public ResultsCursor(ArrayList<String> results) {
             mResults = results;
         }
+        @Override
         public int getCount() { return mResults.size(); }
 
+        @Override
         public String[] getColumnNames() {
             return RESULTS_COLUMNS;
         }
 
+        @Override
         public String getString(int column) {
             switch (column) {
                 case RESULT_ACTION_ID:
@@ -789,24 +816,30 @@
                     return null;
             }
         }
+        @Override
         public short getShort(int column) {
             throw new UnsupportedOperationException();
         }
+        @Override
         public int getInt(int column) {
             throw new UnsupportedOperationException();
         }
+        @Override
         public long getLong(int column) {
             if ((mPos != -1) && column == 0) {
                 return mPos;        // use row# as the _id
             }
             throw new UnsupportedOperationException();
         }
+        @Override
         public float getFloat(int column) {
             throw new UnsupportedOperationException();
         }
+        @Override
         public double getDouble(int column) {
             throw new UnsupportedOperationException();
         }
+        @Override
         public boolean isNull(int column) {
             throw new UnsupportedOperationException();
         }
@@ -868,7 +901,7 @@
 
             Cursor c = db.query(TABLE_NAMES[URI_MATCH_BOOKMARKS],
                     SUGGEST_PROJECTION, suggestSelection, myArgs, null, null,
-                    ORDER_BY, MAX_SUGGESTION_LONG_ENTRIES_STRING);
+                    ORDER_BY, Integer.toString(mMaxSuggestionLongSize));
 
             if (match == URI_MATCH_BOOKMARKS_SUGGEST
                     || Patterns.WEB_URL.matcher(selectionArgs[0]).matches()) {
@@ -877,7 +910,7 @@
                 // get Google suggest if there is still space in the list
                 if (myArgs != null && myArgs.length > 1
                         && mSearchableInfo != null
-                        && c.getCount() < (MAX_SUGGESTION_SHORT_ENTRIES - 1)) {
+                        && c.getCount() < (mMaxSuggestionShortSize - 1)) {
                     Cursor sc = mSearchManager.getSuggestions(mSearchableInfo, selectionArgs[0]);
                     return new MySuggestionCursor(c, sc, selectionArgs[0]);
                 }
@@ -1120,4 +1153,10 @@
         }
     }
 
+    public static Cursor getBookmarksSuggestions(ContentResolver cr, String constraint) {
+        Uri uri = Uri.parse("content://browser/" + SearchManager.SUGGEST_URI_PATH_QUERY);
+        return cr.query(uri, SUGGEST_PROJECTION, SUGGEST_SELECTION,
+            new String[] { constraint }, ORDER_BY);
+    }
+
 }
diff --git a/src/com/android/browser/CircularProgressView.java b/src/com/android/browser/CircularProgressView.java
new file mode 100644
index 0000000..48f293a
--- /dev/null
+++ b/src/com/android/browser/CircularProgressView.java
@@ -0,0 +1,140 @@
+
+/*
+ * 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 android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.RectF;
+import android.util.AttributeSet;
+import android.widget.ImageButton;
+
+/**
+ *
+ */
+public class CircularProgressView extends ImageButton {
+
+    private static final int[] ALPHAS = {
+       64, 96, 128, 160, 192, 192, 160, 128, 96, 64
+    };
+
+    // 100 ms delay between frames, 10fps
+    private static int ALPHA_REFRESH_DELAY = 100;
+
+    private int     mEndAngle;
+    private int     mProgress;
+    private Paint   mPaint;
+    private int     mAlpha;
+    private boolean mAnimated;
+    private RectF   mRect;
+    private int     mMaxProgress;
+
+    /**
+     * @param context
+     * @param attrs
+     * @param defStyle
+     */
+    public CircularProgressView(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        init(context);
+    }
+
+    /**
+     * @param context
+     * @param attrs
+     */
+    public CircularProgressView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context);
+    }
+
+    /**
+     * @param context
+     */
+    public CircularProgressView(Context context) {
+        super(context);
+        init(context);
+    }
+
+    private void init(Context ctx) {
+        mEndAngle = 0;
+        mProgress = 0;
+        mMaxProgress = 100;
+        mPaint = new Paint();
+        mPaint.setAntiAlias(true);
+        mPaint.setColor(Color.BLACK);
+        mRect = new RectF();
+    }
+
+    void setMaxProgress(int max) {
+        mMaxProgress = max;
+    }
+
+    private synchronized boolean isAnimated() {
+        return mAnimated;
+    }
+
+    private synchronized void setAnimated(boolean animated) {
+        mAnimated = animated;
+    }
+
+    void setProgress(int progress) {
+        mProgress = progress;
+        mEndAngle = 360 * progress / mMaxProgress;
+        invalidate();
+        if (!isAnimated() && (progress > 0) && (progress < mMaxProgress)) {
+            setAnimated(true);
+            mAlpha = 0;
+            post(new Runnable() {
+                @Override
+                public void run() {
+                    if (isAnimated()) {
+                        mAlpha = (mAlpha + 1) % ALPHAS.length;
+                        mPaint.setAlpha(ALPHAS[mAlpha]);
+                        invalidate();
+                        postDelayed(this, ALPHA_REFRESH_DELAY);
+                    }
+                }
+            });
+        } else if ((progress <= 0) || (progress >= mMaxProgress))  {
+            setAnimated(false);
+        }
+    }
+
+    @Override
+    public void onDraw(Canvas canvas) {
+        int w = getWidth();
+        int h = getHeight();
+        float cx = w * 0.5f;
+        float cy = h * 0.5f;
+        mRect.set(0, 0, w, h);
+        if ((mProgress > 0) && (mProgress < mMaxProgress)) {
+            Path p = new Path();
+            p.moveTo(cx, cy);
+            p.lineTo(cx, 0);
+            p.arcTo(mRect, 270, mEndAngle);
+            p.lineTo(cx, cy);
+            int state = canvas.save();
+            canvas.drawPath(p, mPaint);
+            canvas.restoreToCount(state);
+        }
+        super.onDraw(canvas);
+    }
+
+}
diff --git a/src/com/android/browser/Tab.java b/src/com/android/browser/Tab.java
index 6b74a6c..1d9482b 100644
--- a/src/com/android/browser/Tab.java
+++ b/src/com/android/browser/Tab.java
@@ -16,21 +16,13 @@
 
 package com.android.browser;
 
-import java.io.File;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Map;
-import java.util.Vector;
-
 import android.app.AlertDialog;
 import android.app.SearchManager;
 import android.content.ContentResolver;
 import android.content.ContentValues;
 import android.content.DialogInterface;
-import android.content.DialogInterface.OnCancelListener;
 import android.content.Intent;
+import android.content.DialogInterface.OnCancelListener;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteException;
@@ -71,8 +63,17 @@
 import android.widget.LinearLayout;
 import android.widget.TextView;
 
+import com.android.browser.TabControl.TabChangeListener;
 import com.android.common.speech.LoggingEvents;
 
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Vector;
+
 /**
  * Class for maintaining Tabs with a main WebView and a subwindow.
  */
@@ -502,6 +503,9 @@
             if (mInForeground) {
                 mActivity.onPageStarted(view, url, favicon);
             }
+            if (getTabChangeListener() != null) {
+                getTabChangeListener().onPageStarted(Tab.this);
+            }
         }
 
         @Override
@@ -523,6 +527,9 @@
             if (mInForeground) {
                 mActivity.onPageFinished(view, url);
             }
+            if (getTabChangeListener() != null) {
+                getTabChangeListener().onPageFinished(Tab.this);
+            }
         }
 
         // return true if want to hijack the url to let another app to handle it
@@ -672,6 +679,7 @@
             final ContentResolver cr = mActivity.getContentResolver();
             final String newUrl = url;
             new AsyncTask<Void, Void, Void>() {
+                @Override
                 protected Void doInBackground(Void... unused) {
                     Browser.updateVisitedHistory(cr, newUrl, true);
                     return null;
@@ -948,6 +956,9 @@
             if (mInForeground) {
                 mActivity.onProgressChanged(view, newProgress);
             }
+            if (getTabChangeListener() != null) {
+                getTabChangeListener().onProgress(Tab.this, newProgress);
+            }
         }
 
         @Override
@@ -957,11 +968,16 @@
                 // here, if url is null, we want to reset the title
                 mActivity.setUrlTitle(pageUrl, title);
             }
+            TabChangeListener tcl = getTabChangeListener();
+            if (tcl != null) {
+                tcl.onUrlAndTitle(Tab.this, pageUrl,title);
+            }
             if (pageUrl == null || pageUrl.length()
                     >= SQLiteDatabase.SQLITE_MAX_LIKE_PATTERN_LENGTH) {
                 return;
             }
             new AsyncTask<Void, Void, Void>() {
+                @Override
                 protected Void doInBackground(Void... unused) {
                     // See if we can find the current url in our history
                     // database and add the new title to it.
@@ -1020,6 +1036,9 @@
             if (mInForeground) {
                 mActivity.setFavicon(icon);
             }
+            if (getTabChangeListener() != null) {
+                getTabChangeListener().onFavicon(Tab.this, icon);
+            }
         }
 
         @Override
@@ -1208,10 +1227,12 @@
         @Override
         public void getVisitedHistory(final ValueCallback<String[]> callback) {
             AsyncTask<Void, Void, String[]> task = new AsyncTask<Void, Void, String[]>() {
+                @Override
                 public String[] doInBackground(Void... unused) {
                     return Browser.getVisitedHistory(mActivity
                             .getContentResolver());
                 }
+                @Override
                 public void onPostExecute(String[] result) {
                     callback.onReceiveValue(result);
                 };
@@ -1990,4 +2011,13 @@
         LinearLayout parent = (LinearLayout) dialog.getParent();
         if (parent != null) parent.removeView(dialog);
     }
+
+    /**
+     * always get the TabChangeListener form the tab control
+     * @return the TabControl change listener
+     */
+    private TabChangeListener getTabChangeListener() {
+        return mActivity.getTabControl().getTabChangeListener();
+    }
+
 }
diff --git a/src/com/android/browser/TabControl.java b/src/com/android/browser/TabControl.java
index afd4ea8..0fbdd7a 100644
--- a/src/com/android/browser/TabControl.java
+++ b/src/com/android/browser/TabControl.java
@@ -132,7 +132,7 @@
     int getCurrentIndex() {
         return mCurrentTab;
     }
-    
+
     /**
      * Given a Tab, find it's index
      * @param Tab to find
@@ -167,6 +167,9 @@
         mTabs.add(t);
         // Initially put the tab in the background.
         t.putInBackground();
+        if (mTabChangeListener != null) {
+            mTabChangeListener.onNewTab(t);
+        }
         return t;
     }
 
@@ -231,6 +234,9 @@
 
         // Remove it from the queue of viewed tabs.
         mTabQueue.remove(t);
+        if (mTabChangeListener != null) {
+            mTabChangeListener.onRemoveTab(t);
+        }
         return true;
     }
 
@@ -617,6 +623,47 @@
                 mainView.loadUrl(BrowserSettings.getInstance().getHomePage());
             }
         }
+        if (mTabChangeListener != null) {
+            mTabChangeListener.onCurrentTab(newTab);
+        }
         return true;
     }
+
+    interface TabChangeListener {
+
+        public void onNewTab(Tab tab);
+
+        public void onRemoveTab(Tab tab);
+
+        public void onCurrentTab(Tab tab);
+
+        public void onProgress(Tab tab, int progress);
+
+        public void onUrlAndTitle(Tab tab, String url, String title);
+
+        public void onFavicon(Tab tab, Bitmap favicon);
+
+        public void onPageStarted(Tab tab);
+
+        public void onPageFinished(Tab tab);
+
+    }
+
+    private TabChangeListener mTabChangeListener;
+
+    /**
+     * register the TabChangeListener with the tab control
+     * @param listener
+     */
+    void setOnTabChangeListener(TabChangeListener listener) {
+        mTabChangeListener = listener;
+    }
+
+    /**
+     * get the current TabChangeListener (used by the tabs)
+     */
+    TabChangeListener getTabChangeListener() {
+        return mTabChangeListener;
+    }
+
 }
diff --git a/src/com/android/browser/TabScrollView.java b/src/com/android/browser/TabScrollView.java
new file mode 100644
index 0000000..6d8b91b
--- /dev/null
+++ b/src/com/android/browser/TabScrollView.java
@@ -0,0 +1,136 @@
+/*
+ * 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 android.content.Context;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.HorizontalScrollView;
+import android.widget.LinearLayout;
+
+/**
+ * custom view for displaying tabs in the tabbed title bar
+ */
+public class TabScrollView extends HorizontalScrollView {
+
+    private Context mContext;
+
+    private LinearLayout mContentView;
+
+    private int mSelected;
+
+    /**
+     * @param context
+     * @param attrs
+     * @param defStyle
+     */
+    public TabScrollView(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        init(context);
+    }
+
+    /**
+     * @param context
+     * @param attrs
+     */
+    public TabScrollView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context);
+    }
+
+    /**
+     * @param context
+     */
+    public TabScrollView(Context context) {
+        super(context);
+        init(context);
+    }
+
+    private void init(Context ctx) {
+        mContext = ctx;
+        setHorizontalScrollBarEnabled(false);
+        mContentView = new LinearLayout(mContext);
+        mContentView.setOrientation(LinearLayout.HORIZONTAL);
+        mContentView.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT,
+                LayoutParams.WRAP_CONTENT));
+        addView(mContentView);
+        mSelected = -1;
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+        ensureChildVisible(getSelectedTab());
+    }
+
+    void setSelectedTab(int position) {
+        View v = getSelectedTab();
+        if (v != null) {
+            v.setSelected(false);
+        }
+        mSelected = position;
+        v = getSelectedTab();
+        if (v != null) {
+            v.setSelected(true);
+        }
+        requestLayout();
+    }
+
+    View getSelectedTab() {
+        if ((mSelected >= 0) && (mSelected < mContentView.getChildCount())) {
+            return mContentView.getChildAt(mSelected);
+        } else {
+            return null;
+        }
+    }
+
+    void clearTabs() {
+        mContentView.removeAllViews();
+    }
+
+    void addTab(View tab) {
+        mContentView.addView(tab);
+        tab.setSelected(false);
+    }
+
+    void addTab(View tab, int pos) {
+        mContentView.addView(tab, pos);
+        tab.setSelected(false);
+    }
+
+    void removeTab(View tab) {
+        mContentView.removeView(tab);
+    }
+
+    void ensureChildVisible(View child) {
+        if (child != null) {
+            int childl = child.getLeft();
+            int childr = childl + child.getWidth();
+            int viewl = getScrollX();
+            int viewr = viewl + getWidth();
+            if (childl < viewl) {
+                // need scrolling to left
+                scrollTo(childl, 0);
+            } else if (childr > viewr) {
+                // need scrolling to right
+                scrollTo(childr - viewr + viewl, 0);
+            }
+        }
+    }
+
+
+}
diff --git a/src/com/android/browser/TitleBarBase.java b/src/com/android/browser/TitleBarBase.java
index 3d234e8..7016dc0 100644
--- a/src/com/android/browser/TitleBarBase.java
+++ b/src/com/android/browser/TitleBarBase.java
@@ -35,7 +35,7 @@
     protected ImageView mFavicon;
     protected ImageView mLockIcon;
 
-    private Drawable mGenericFavicon;
+    protected Drawable mGenericFavicon;
 
     public TitleBarBase(Context context) {
         super(context, null);
diff --git a/src/com/android/browser/TitleBarXLarge.java b/src/com/android/browser/TitleBarXLarge.java
index 0d799a8..fd6d67b 100644
--- a/src/com/android/browser/TitleBarXLarge.java
+++ b/src/com/android/browser/TitleBarXLarge.java
@@ -16,108 +16,168 @@
 
 package com.android.browser;
 
+import android.app.SearchManager;
 import android.content.Context;
+import android.content.Intent;
+import android.content.res.Configuration;
 import android.content.res.Resources;
-import android.graphics.drawable.Animatable;
+import android.graphics.Bitmap;
+import android.graphics.Color;
+import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
-import android.util.DisplayMetrics;
-import android.util.TypedValue;
+import android.graphics.drawable.LayerDrawable;
+import android.graphics.drawable.PaintDrawable;
 import android.view.ContextMenu;
 import android.view.LayoutInflater;
 import android.view.MenuInflater;
 import android.view.View;
 import android.widget.ImageView;
-import android.widget.ProgressBar;
+import android.widget.LinearLayout;
 import android.widget.TextView;
 
-import com.android.common.speech.LoggingEvents;
+import com.android.browser.TabControl.TabChangeListener;
+import com.android.browser.UrlInputView.UrlInputListener;
+
+import java.util.HashMap;
+import java.util.Map;
 
 /**
- * This class represents a title bar for a particular "tab" or "window" in the
- * browser.
+ * tabbed title bar for xlarge screen browser
  */
-public class TitleBarXLarge extends TitleBarBase {
-    private Drawable        mCircularProgress;
-    private ProgressBar     mHorizontalProgress;
-    private Drawable        mStopDrawable;
-    private Drawable        mReloadDrawable;
-    private boolean         mInLoad;
-    private BrowserActivity mBrowserActivity;
+public class TitleBarXLarge extends TitleBarBase
+    implements TabChangeListener, UrlInputListener {
 
-    private final View            mBackButton;
-    private final View            mForwardButton;
-    private final View            mStar;
-    private final View            mMenu;
-    private final ImageView       mStopButton;
-    private final TextView        mTitle;
-    private final View            mAllButton;
+    private static final int PROGRESS_MAX = 100;
 
-    public TitleBarXLarge(BrowserActivity context) {
+    private static final int TAB_WIDTH_SELECTED = 400;
+    private static final int TAB_WIDTH_UNSELECTED = 150;
+
+    private BrowserActivity       mBrowserActivity;
+    private Drawable              mStopDrawable;
+    private Drawable              mReloadDrawable;
+    private Drawable              mSelectedBackground;
+    private Drawable              mUnselectedBackground;
+
+    private View                  mBackButton;
+    private View                  mForwardButton;
+    private View                  mStar;
+    private View                  mMenu;
+    private View                  mAllButton;
+    private TabScrollView         mTabs;
+    private View                  mNewButton;
+    private TabControl            mControl;
+    private UrlInputView          mUrlView;
+
+    private boolean               mIsInLandscape;
+    private Map<Tab, TabViewData> mTabMap;
+
+    private float                 mDensityScale;
+
+    public TitleBarXLarge(BrowserActivity context, TabControl tabcontrol) {
         super(context);
-        Resources resources = context.getResources();
-        LayoutInflater factory = LayoutInflater.from(context);
-        factory.inflate(R.layout.title_bar_xlarge, this);
+        mDensityScale = context.getResources().getDisplayMetrics().density;
+        mTabMap = new HashMap<Tab, TabViewData>();
         mBrowserActivity = context;
-
-        mTitle = (TextView) findViewById(R.id.title);
-        mTitle.setCompoundDrawablePadding(5);
-        mTitle.setLongClickable(true);
-
-        mLockIcon = (ImageView) findViewById(R.id.lock);
-        mFavicon = (ImageView) findViewById(R.id.favicon);
-        mStopButton = (ImageView) findViewById(R.id.stop);
-        mStopDrawable = mStopButton.getDrawable();
+        mControl = tabcontrol;
+        Resources resources = context.getResources();
+        mSelectedBackground = resources.getDrawable(R.drawable.tab_selected_bg);
+        mUnselectedBackground = resources.getDrawable(R.drawable.tab_unselected_bg);
+        mStopDrawable = resources.getDrawable(R.drawable.progress_stop);
         mReloadDrawable = resources.getDrawable(R.drawable.ic_reload);
+        rebuildLayout(context, true);
+        // register the tab change listener
+        mControl.setOnTabChangeListener(this);
+    }
 
-        mAllButton = (ImageView) findViewById(R.id.all_btn);
-        mCircularProgress = (Drawable) resources.getDrawable(
-                com.android.internal.R.drawable.search_spinner);
-        DisplayMetrics metrics = resources.getDisplayMetrics();
-        int iconDimension = (int) TypedValue.applyDimension(
-                TypedValue.COMPLEX_UNIT_DIP, 20f, metrics);
-        mCircularProgress.setBounds(0, 0, iconDimension, iconDimension);
-        mHorizontalProgress = (ProgressBar) findViewById(
-                R.id.progress_horizontal);
-        mHorizontalProgress.setProgressDrawable(
-                resources.getDrawable(R.drawable.progress));
+    void rebuildLayout() {
+        rebuildLayout(mBrowserActivity, false);
+    }
 
-        // FIXME: Change enabled states based on whether you can go
+    private void rebuildLayout(Context context, boolean rebuildData) {
+        removeAllViews();
+        LayoutInflater factory = LayoutInflater.from(context);
+        factory.inflate(R.layout.title_bar_tabbed, this);
+
+        mTabs = (TabScrollView) findViewById(R.id.tabs);
+        mNewButton = findViewById(R.id.newtab);
+        mUrlView = (UrlInputView) findViewById(R.id.editurl);
+        mAllButton = findViewById(R.id.all_btn);
+        // TODO: Change enabled states based on whether you can go
         // back/forward.  Probably should be done inside onPageStarted.
         mBackButton = findViewById(R.id.back);
         mForwardButton = findViewById(R.id.forward);
         mStar = findViewById(R.id.star);
         mMenu = findViewById(R.id.menu);
         View.OnClickListener listener = new View.OnClickListener() {
-                public void onClick(View v) {
-                    if (mBackButton == v) {
-                        mBrowserActivity.getTopWindow().goBack();
-                    } else if (mForwardButton == v) {
-                        mBrowserActivity.getTopWindow().goForward();
-                    } else if (mStar == v) {
-                        mBrowserActivity.promptAddOrInstallBookmark();
-                    } else if (mMenu == v) {
-                        mBrowserActivity.openOptionsMenu();
-                    } else if (mStopButton == v) {
-                        if (mInLoad) {
-                            mBrowserActivity.stopLoading();
-                        } else {
-                            mBrowserActivity.getTopWindow().reload();
-                        }
-                    } else if (mTitle == v) {
-                        mBrowserActivity.editUrl();
-                    } else if (mAllButton == v) {
-                        // FIXME: Show the new bookmarks/windows view.
-                        mBrowserActivity.bookmarksOrHistoryPicker(false);
-                    }
+            public void onClick(View v) {
+                if (mBackButton == v) {
+                    mBrowserActivity.getTopWindow().goBack();
+                } else if (mForwardButton == v) {
+                    mBrowserActivity.getTopWindow().goForward();
+                } else if (mStar == v) {
+                    mBrowserActivity.promptAddOrInstallBookmark();
+                } else if (mMenu == v) {
+                    mBrowserActivity.openOptionsMenu();
+                } else if (mAllButton == v) {
+                    // TODO: Show the new bookmarks/windows view.
+                    mBrowserActivity.bookmarksOrHistoryPicker(false);
+                } else if (mNewButton == v) {
+                    mBrowserActivity.openTabToHomePage();
                 }
+            }
         };
         mBackButton.setOnClickListener(listener);
         mForwardButton.setOnClickListener(listener);
         mStar.setOnClickListener(listener);
-        mStopButton.setOnClickListener(listener);
-        mTitle.setOnClickListener(listener);
         mAllButton.setOnClickListener(listener);
         mMenu.setOnClickListener(listener);
+        mNewButton.setOnClickListener(listener);
+
+        mIsInLandscape = mBrowserActivity.getResources().getConfiguration().orientation
+                == Configuration.ORIENTATION_LANDSCAPE;
+        mUrlView.setVisibility(mIsInLandscape ? View.GONE : View.VISIBLE);
+        mUrlView.setUrlInputListener(this);
+        buildTabs(rebuildData);
+        // ensure title bar state
+        onCurrentTab(mControl.getCurrentTab());
+    }
+
+    void showUrlEditor(TabViewData tabdata) {
+        mUrlView.setVisibility(View.VISIBLE);
+        if (mIsInLandscape) {
+            mTabs.setVisibility(View.GONE);
+            mUrlView.requestFocus();
+            mUrlView.forceIme();
+        }
+    }
+
+    void hideUrlEditor() {
+        Tab tab = mControl.getCurrentTab();
+        if (mIsInLandscape) {
+            mUrlView.setVisibility(View.GONE);
+            mTabs.setVisibility(View.VISIBLE);
+        } else {
+            // portrait mode
+            mUrlView.setText(tab.getWebView().getUrl());
+        }
+        tab.getWebView().requestFocus();
+    }
+
+
+    // UrlInputListener implementation
+
+    @Override
+    public void onAction(String text) {
+        hideUrlEditor();
+        Intent i = new Intent();
+        i.setAction(Intent.ACTION_SEARCH);
+        i.putExtra(SearchManager.QUERY, text);
+        mBrowserActivity.onNewIntent(i);
+    }
+
+    @Override
+    public void onDismiss() {
+        hideUrlEditor();
     }
 
     @Override
@@ -127,44 +187,321 @@
         mBrowserActivity.onCreateContextMenu(menu, this, null);
     }
 
-    /**
-     * Update the progress, from 0 to 100.
-     */
-    /* package */ void setProgress(int newProgress) {
-        if (newProgress >= mHorizontalProgress.getMax()) {
-            mTitle.setCompoundDrawables(null, null, null, null);
-            ((Animatable) mCircularProgress).stop();
-            mHorizontalProgress.setVisibility(View.GONE);
-            mInLoad = false;
-            mStopButton.setImageDrawable(mReloadDrawable);
-        } else {
-            mHorizontalProgress.setProgress(newProgress);
-            if (!mInLoad && getWindowToken() != null) {
-                // checking the window token lets us be sure that we
-                // are attached to a window before starting the animation,
-                // preventing a potential race condition
-                // (fix for bug http://b/2115736)
-                mTitle.setCompoundDrawables(null, null, mCircularProgress,
-                        null);
-                ((Animatable) mCircularProgress).start();
-                mHorizontalProgress.setVisibility(View.VISIBLE);
-                mInLoad = true;
-                mStopButton.setImageDrawable(mStopDrawable);
-            }
-        }
+    @Override
+    /* package */ void setLock(Drawable d) {
+        // TODO: handle in tab specific callback
+    }
+
+    @Override
+    /* package */ void setFavicon(Bitmap icon) {
+        // this is handled in the tab specific callback
     }
 
     /**
-     * Update the text displayed in the title bar.
-     * @param title String to display.  If null, the loading string will be
-     *      shown.
+     * Update the progress, from 0 to 100.
      */
+    @Override
+    /* package */ void setProgress(int newProgress) {
+        // this is handled in tab specific callback
+    }
+
+    @Override
     /* package */ void setDisplayTitle(String title) {
-        if (title == null) {
-            mTitle.setText(R.string.title_bar_loading);
+        // this is done in tab specific callback
+    }
+
+    private void buildTabs(boolean needsRebuilding) {
+        mTabs.clearTabs();
+        for (int i = 0; i < mControl.getTabCount(); i++) {
+            Tab tab = mControl.getTab(i);
+            TabViewData data = buildTab(needsRebuilding, tab);
+            TabView tv = buildView(data);
+        }
+        mTabs.setSelectedTab(mControl.getCurrentIndex());
+    }
+
+    private TabViewData buildTab(boolean needsRebuilding, Tab tab) {
+        TabViewData data = null;
+        if (needsRebuilding) {
+            data = new TabViewData(tab);
+            mTabMap.put(tab, data);
         } else {
+            data = mTabMap.get(tab);
+        }
+        return data;
+    }
+
+    private TabView buildView(final TabViewData data) {
+        TabView tv = new TabView(mBrowserActivity, data);
+        tv.setOnClickListener(new OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                if (mTabs.getSelectedTab() == v) {
+                    showUrlEditor(data);
+                } else {
+                    int ix = mControl.getTabIndex(data.mTab);
+                    mTabs.setSelectedTab(ix);
+                    mBrowserActivity.switchToTab(ix);
+                }
+            }
+        });
+        mTabs.addTab(tv);
+        return tv;
+    }
+
+    /**
+     * the views used in the tab bar
+     */
+    class TabView extends LinearLayout {
+
+        TabViewData          mTabData;
+        View                 mTabContent;
+        TextView             mTitle;
+        ImageView            mIconView;
+        ImageView            mLock;
+        CircularProgressView mStop;
+        ImageView            mClose;
+        boolean              mSelected;
+        boolean              mInLoad;
+
+        /**
+         * @param context
+         */
+        public TabView(Context context, TabViewData tab) {
+            super(context);
+            mTabData = tab;
+            LayoutInflater inflater = LayoutInflater.from(mContext);
+            mTabContent = inflater.inflate(R.layout.tab_title, this);
+            mTitle = (TextView) mTabContent.findViewById(R.id.title);
+            mIconView = (ImageView) mTabContent.findViewById(R.id.favicon);
+            mLock = (ImageView) mTabContent.findViewById(R.id.lock);
+            mStop = (CircularProgressView) mTabContent.findViewById(R.id.stop);
+            mStop.setMaxProgress(PROGRESS_MAX);
+            mClose = (ImageView) mTabContent.findViewById(R.id.close);
+            mClose.setOnClickListener(new OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    closeTab();
+                }
+            });
+            mStop.setOnClickListener(new OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    if (mInLoad) {
+                        mBrowserActivity.stopLoading();
+                    } else {
+                        mBrowserActivity.getTopWindow().reload();
+                    }
+                }
+            });
+            mSelected = false;
+            mInLoad = false;
+            // update the status
+            updateFromData();
+        }
+
+        private void updateFromData() {
+            mTabData.mTabView = this;
+            if (mTabData.mUrl != null) {
+                setDisplayTitle(mTabData.mUrl);
+            }
+            if (mTabData.mTitle != null) {
+                setDisplayTitle(mTabData.mTitle);
+            }
+            setProgress(mTabData.mProgress);
+            if (mTabData.mIcon != null) {
+                setFavicon(mTabData.mIcon);
+            }
+            if (mTabData.mLock != null) {
+                setLock(mTabData.mLock);
+            }
+        }
+
+        @Override
+        public void setSelected(boolean selected) {
+            mSelected = selected;
+            mStop.setVisibility(mSelected ? View.VISIBLE : View.GONE);
+            mIconView.setVisibility(mSelected ? View.VISIBLE : View.GONE);
+            super.setSelected(selected);
+            setBackgroundDrawable(selected ? mSelectedBackground
+                    : mUnselectedBackground);
+            setLayoutParams(new LayoutParams(selected ?
+                    (int) (TAB_WIDTH_SELECTED * mDensityScale)
+                    : (int) (TAB_WIDTH_UNSELECTED * mDensityScale),
+                    LayoutParams.WRAP_CONTENT));
+        }
+
+        void setDisplayTitle(String title) {
             mTitle.setText(title);
         }
+
+        void setFavicon(Drawable d) {
+            mIconView.setImageDrawable(d);
+        }
+
+        void setLock(Drawable d) {
+            if (null == d) {
+                mLock.setVisibility(View.GONE);
+            } else {
+                mLock.setImageDrawable(d);
+                mLock.setVisibility(View.VISIBLE);
+            }
+        }
+
+        void setTitleCompoundDrawables(Drawable left, Drawable top,
+                                              Drawable right, Drawable bottom) {
+            mTitle.setCompoundDrawables(left, top, right, bottom);
+        }
+
+        void setProgress(int newProgress) {
+            mStop.setProgress(newProgress);
+            if (newProgress >= PROGRESS_MAX) {
+                mInLoad = false;
+                mStop.setImageDrawable(mReloadDrawable);
+            } else {
+                if (!mInLoad && getWindowToken() != null) {
+                    // checking the window token lets us be sure that we
+                    // are attached to a window before starting the animation,
+                    // preventing a potential race condition
+                    // (fix for bug http://b/2115736)
+                    mInLoad = true;
+                    mStop.setImageDrawable(mStopDrawable);
+                }
+            }
+        }
+
+        private void closeTab() {
+            if (mTabData.mTab == mControl.getCurrentTab()) {
+                mBrowserActivity.closeCurrentWindow();
+            } else {
+                mBrowserActivity.closeTab(mTabData.mTab);
+            }
+        }
+
+    }
+
+    /**
+     * class to store tab state within the title bar
+     */
+    class TabViewData {
+
+        Tab mTab;
+        TabView mTabView;
+        int mProgress;
+        Drawable mIcon;
+        Drawable mLock;
+        String mTitle;
+        String mUrl;
+
+        TabViewData(Tab tab) {
+            mTab = tab;
+        }
+
+        void setUrlAndTitle(String url, String title) {
+            mUrl = url;
+            mTitle = title;
+            if (mTabView != null) {
+                if (title != null) {
+                    mTabView.setDisplayTitle(title);
+                } else if (url != null) {
+                    mTabView.setDisplayTitle(url);
+                }
+            }
+        }
+
+        void setProgress(int newProgress) {
+            mProgress = newProgress;
+            if (mTabView != null) {
+                mTabView.setProgress(mProgress);
+            }
+        }
+
+        void setFavicon(Bitmap icon) {
+            Drawable[] array = new Drawable[3];
+            array[0] = new PaintDrawable(Color.BLACK);
+            array[1] = new PaintDrawable(Color.WHITE);
+            if (icon == null) {
+                array[2] = mGenericFavicon;
+            } else {
+                array[2] = new BitmapDrawable(icon);
+            }
+            LayerDrawable d = new LayerDrawable(array);
+            d.setLayerInset(1, 1, 1, 1, 1);
+            d.setLayerInset(2, 2, 2, 2, 2);
+            mIcon = d;
+            if (mTabView != null) {
+                mTabView.setFavicon(mIcon);
+            }
+        }
+
+    }
+
+    // TabChangeListener implementation
+
+    @Override
+    public void onCurrentTab(Tab tab) {
+        mTabs.setSelectedTab(mControl.getCurrentIndex());
+        TabViewData tvd = mTabMap.get(tab);
+        if (tvd != null) {
+            if (tvd.mUrl != null) {
+                mUrlView.setText(tvd.mUrl);
+            }
+            setProgress(tvd.mProgress);
+        }
+    }
+
+    @Override
+    public void onFavicon(Tab tab, Bitmap favicon) {
+        TabViewData tvd = mTabMap.get(tab);
+        if (tvd != null) {
+            tvd.setFavicon(favicon);
+        }
+    }
+
+    @Override
+    public void onNewTab(Tab tab) {
+        TabViewData tvd = buildTab(true, tab);
+        buildView(tvd);
+    }
+
+    @Override
+    public void onProgress(Tab tab, int progress) {
+        TabViewData tvd = mTabMap.get(tab);
+        if (tvd != null) {
+            tvd.setProgress(progress);
+        }
+        if (tab == mControl.getCurrentTab()) {
+            setProgress(progress);
+        }
+    }
+
+    @Override
+    public void onRemoveTab(Tab tab) {
+        TabViewData tvd = mTabMap.get(tab);
+        TabView tv = tvd.mTabView;
+        if (tv != null) {
+            mTabs.removeTab(tv);
+        }
+        mTabMap.remove(tab);
+    }
+
+    @Override
+    public void onUrlAndTitle(Tab tab, String url, String title) {
+        TabViewData tvd = mTabMap.get(tab);
+        if (tvd != null) {
+            tvd.setUrlAndTitle(url, title);
+        }
+        if ((url != null) && (tab == mControl.getCurrentTab())) {
+            mUrlView.setText(url);
+        }
+    }
+
+    @Override
+    public void onPageFinished(Tab tab) {
+    }
+
+    @Override
+    public void onPageStarted(Tab tab) {
     }
 
 }
diff --git a/src/com/android/browser/UrlInputView.java b/src/com/android/browser/UrlInputView.java
new file mode 100644
index 0000000..3841257
--- /dev/null
+++ b/src/com/android/browser/UrlInputView.java
@@ -0,0 +1,206 @@
+/*
+ * 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 android.app.SearchManager;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.database.Cursor;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.AdapterView;
+import android.widget.AutoCompleteTextView;
+import android.widget.CursorAdapter;
+import android.widget.Filterable;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.AdapterView.OnItemClickListener;
+
+/**
+ * url/search input view
+ * handling suggestions
+ */
+public class UrlInputView extends AutoCompleteTextView {
+
+    private UrlInputListener   mListener;
+    private InputMethodManager mInputManager;
+    private SuggestionsAdapter mAdapter;
+    private Drawable           mFocusDrawable;
+    private Drawable           mNoFocusDrawable;
+
+
+    public UrlInputView(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        init(context);
+    }
+
+    public UrlInputView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context);
+    }
+
+    public UrlInputView(Context context) {
+        super(context);
+        init(context);
+    }
+
+    private void init(Context ctx) {
+        mFocusDrawable = ctx.getResources().getDrawable(R.drawable.textfield_stroke);
+        mNoFocusDrawable = ctx.getResources().getDrawable(R.drawable.textfield_nostroke);
+        mInputManager = (InputMethodManager) ctx.getSystemService(Context.INPUT_METHOD_SERVICE);
+        setOnEditorActionListener(new OnEditorActionListener() {
+            @Override
+            public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
+                finishInput(getText().toString());
+                return true;
+            }
+        });
+        setOnFocusChangeListener(new OnFocusChangeListener() {
+            @Override
+            public void onFocusChange(View v, boolean hasFocus) {
+                setBackgroundDrawable(hasFocus ? mFocusDrawable : mNoFocusDrawable);
+            }
+        });
+        final ContentResolver cr = mContext.getContentResolver();
+        mAdapter = new SuggestionsAdapter(mContext,
+                BrowserProvider.getBookmarksSuggestions(cr, null));
+        setAdapter(mAdapter);
+        setOnItemClickListener(new OnItemClickListener() {
+            @Override
+            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+                String url = mAdapter.getViewString(view);
+                finishInput(url);
+            }
+        });
+        setSelectAllOnFocus(true);
+    }
+
+    public void setUrlInputListener(UrlInputListener listener) {
+        mListener = listener;
+    }
+
+    public void forceIme() {
+        mInputManager.showSoftInput(this, 0);
+    }
+
+    private void finishInput(String url) {
+        this.dismissDropDown();
+        mInputManager.hideSoftInputFromWindow(getWindowToken(), 0);
+        if (url == null) {
+            mListener.onDismiss();
+        } else {
+            mListener.onAction(url);
+        }
+
+    }
+
+    @Override
+    public boolean onKeyPreIme(int keyCode, KeyEvent evt) {
+        if (keyCode == KeyEvent.KEYCODE_BACK) {
+            // catch back key in order to do slightly more cleanup than usual
+            finishInput(null);
+            return true;
+        }
+        return super.onKeyPreIme(keyCode, evt);
+    }
+
+    interface UrlInputListener {
+
+        public void onDismiss();
+
+        public void onAction(String text);
+
+    }
+
+    /**
+     * adapter used by suggestion dropdown
+     */
+    class SuggestionsAdapter extends CursorAdapter implements Filterable {
+
+        private Cursor          mLastCursor;
+        private ContentResolver mContent;
+        private int             mIndexText1;
+        private int             mIndexText2;
+        private int             mIndexIcon;
+
+        public SuggestionsAdapter(Context context, Cursor c) {
+            super(context, c);
+            mContent = context.getContentResolver();
+            mIndexText1 = c.getColumnIndex(SearchManager.SUGGEST_COLUMN_TEXT_1);
+            mIndexText2 = c.getColumnIndex(SearchManager.SUGGEST_COLUMN_TEXT_2_URL);
+            mIndexIcon = c.getColumnIndex(SearchManager.SUGGEST_COLUMN_ICON_1);
+        }
+
+        public String getViewString(View view) {
+            TextView tv2 = (TextView) view.findViewById(android.R.id.text2);
+            if (tv2.getText().length() > 0) {
+                return tv2.getText().toString();
+            } else {
+                TextView tv1 = (TextView) view.findViewById(android.R.id.text1);
+                return tv1.getText().toString();
+            }
+        }
+
+        @Override
+        public View newView(Context context, Cursor cursor, ViewGroup parent) {
+            final LayoutInflater inflater = LayoutInflater.from(context);
+            final View view = inflater.inflate(
+                    R.layout.simple_dropdown_item_2line, parent, false);
+            bindView(view, context, cursor);
+            return view;
+        }
+
+        @Override
+        public void bindView(View view, Context context, Cursor cursor) {
+            TextView tv1 = (TextView) view.findViewById(android.R.id.text1);
+            TextView tv2 = (TextView) view.findViewById(android.R.id.text2);
+            ImageView ic1 = (ImageView) view.findViewById(R.id.icon1);
+            tv1.setText(cursor.getString(mIndexText1));
+            String url = cursor.getString(mIndexText2);
+            tv2.setText((url != null) ? url : "");
+            // assume an id
+            try {
+                int id = Integer.parseInt(cursor.getString(mIndexIcon));
+                Drawable d = context.getResources().getDrawable(id);
+                ic1.setImageDrawable(d);
+            } catch (NumberFormatException nfx) {
+            }
+        }
+
+        @Override
+        public String convertToString(Cursor cursor) {
+            return cursor.getString(mIndexText1);
+        }
+
+        @Override
+        public Cursor runQueryOnBackgroundThread(CharSequence constraint) {
+            if (getFilterQueryProvider() != null) {
+                return getFilterQueryProvider().runQuery(constraint);
+            }
+            mLastCursor = BrowserProvider.getBookmarksSuggestions(mContent,
+                    (constraint != null) ? constraint.toString() : null);
+            return mLastCursor;
+        }
+
+    }
+
+}