auto import from //depot/cupcake/@136594

54 files changed, 2543 insertions, 670 deletions

diff --git a/core/java/android/database/sqlite/SQLiteProgram.java b/core/java/android/database/sqlite/SQLiteProgram.java
index f89c87d..9e85452 100644
--- a/core/java/android/database/sqlite/SQLiteProgram.java
+++ b/core/java/android/database/sqlite/SQLiteProgram.java
@@ -22,7 +22,7 @@ import android.util.Log;
  * A base class for compiled SQLite programs.
  */
 public abstract class SQLiteProgram extends SQLiteClosable {
-    static final String TAG = "SQLiteProgram";
+    private static final String TAG = "SQLiteProgram";
 
     /** The database this program is compiled against. */
     protected SQLiteDatabase mDatabase;
diff --git a/core/java/android/database/sqlite/SQLiteQuery.java b/core/java/android/database/sqlite/SQLiteQuery.java
index 5bfa0e8..1386a0d 100644
--- a/core/java/android/database/sqlite/SQLiteQuery.java
+++ b/core/java/android/database/sqlite/SQLiteQuery.java
@@ -18,13 +18,14 @@ package android.database.sqlite;
 
 import android.database.CursorWindow;
 import android.os.SystemClock;
+import android.util.Log;
 
 /**
  * A SQLite program that represents a query that reads the resulting rows into a CursorWindow.
  * This class is used by SQLiteCursor and isn't useful itself.
  */
 public class SQLiteQuery extends SQLiteProgram {
-    //private static final String TAG = "Cursor";
+    private static final String TAG = "Cursor";
 
     /** The index of the unbound OFFSET parameter */
     private int mOffsetIndex;
@@ -73,6 +74,11 @@ public class SQLiteQuery extends SQLiteProgram {
                 // is not safe in this situation. the native code will ignore maxRead
                 int numRows = native_fill_window(window, window.getStartPosition(), mOffsetIndex,
                         maxRead, lastPos);
+
+                // Logging
+                if (SQLiteDebug.DEBUG_SQL_STATEMENTS) {
+                    Log.d(TAG, "fillWindow(): " + mQuery);
+                }
                 if (logStats) {
                     mDatabase.logTimeStat(true /* read */, startTime,
                             SystemClock.elapsedRealtime());
diff --git a/core/java/android/inputmethodservice/IInputMethodSessionWrapper.java b/core/java/android/inputmethodservice/IInputMethodSessionWrapper.java
index 5a85c66..6cf90d6 100644
--- a/core/java/android/inputmethodservice/IInputMethodSessionWrapper.java
+++ b/core/java/android/inputmethodservice/IInputMethodSessionWrapper.java
@@ -30,6 +30,7 @@ class IInputMethodSessionWrapper extends IInputMethodSession.Stub
     private static final int DO_UPDATE_SELECTION = 90;
     private static final int DO_UPDATE_CURSOR = 95;
     private static final int DO_APP_PRIVATE_COMMAND = 100;
+    private static final int DO_TOGGLE_SOFT_INPUT = 105;
    
     final HandlerCaller mCaller;
     final InputMethodSession mInputMethodSession;
@@ -106,6 +107,10 @@ class IInputMethodSessionWrapper extends IInputMethodSession.Stub
                 mCaller.recycleArgs(args);
                 return;
             }
+            case DO_TOGGLE_SOFT_INPUT: {
+                mInputMethodSession.toggleSoftInput(msg.arg1, msg.arg2);
+                return;
+            }
         }
         Log.w(TAG, "Unhandled message code: " + msg.what);
     }
@@ -149,4 +154,8 @@ class IInputMethodSessionWrapper extends IInputMethodSession.Stub
     public void appPrivateCommand(String action, Bundle data) {
         mCaller.executeOrSendMessage(mCaller.obtainMessageOO(DO_APP_PRIVATE_COMMAND, action, data));
     }
+    
+    public void toggleSoftInput(int showFlags, int hideFlags) {
+        mCaller.executeOrSendMessage(mCaller.obtainMessageII(DO_TOGGLE_SOFT_INPUT, showFlags, hideFlags));
+    }
 }
diff --git a/core/java/android/inputmethodservice/IInputMethodWrapper.java b/core/java/android/inputmethodservice/IInputMethodWrapper.java
index a2c75b5..20a05a5 100644
--- a/core/java/android/inputmethodservice/IInputMethodWrapper.java
+++ b/core/java/android/inputmethodservice/IInputMethodWrapper.java
@@ -13,6 +13,7 @@ import android.os.Binder;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.RemoteException;
+import android.os.ResultReceiver;
 import android.util.Log;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.InputBinding;
@@ -144,10 +145,10 @@ class IInputMethodWrapper extends IInputMethod.Stub
                 mInputMethod.revokeSession((InputMethodSession)msg.obj);
                 return;
             case DO_SHOW_SOFT_INPUT:
-                mInputMethod.showSoftInput(msg.arg1);
+                mInputMethod.showSoftInput(msg.arg1, (ResultReceiver)msg.obj);
                 return;
             case DO_HIDE_SOFT_INPUT:
-                mInputMethod.hideSoftInput();
+                mInputMethod.hideSoftInput(msg.arg1, (ResultReceiver)msg.obj);
                 return;
         }
         Log.w(TAG, "Unhandled message code: " + msg.what);
@@ -225,12 +226,13 @@ class IInputMethodWrapper extends IInputMethod.Stub
         }
     }
     
-    public void showSoftInput(int flags) {
-        mCaller.executeOrSendMessage(mCaller.obtainMessageI(DO_SHOW_SOFT_INPUT,
-                flags));
+    public void showSoftInput(int flags, ResultReceiver resultReceiver) {
+        mCaller.executeOrSendMessage(mCaller.obtainMessageIO(DO_SHOW_SOFT_INPUT,
+                flags, resultReceiver));
     }
     
-    public void hideSoftInput() {
-        mCaller.executeOrSendMessage(mCaller.obtainMessage(DO_HIDE_SOFT_INPUT));
+    public void hideSoftInput(int flags, ResultReceiver resultReceiver) {
+        mCaller.executeOrSendMessage(mCaller.obtainMessageIO(DO_HIDE_SOFT_INPUT,
+                flags, resultReceiver));
     }
 }
diff --git a/core/java/android/inputmethodservice/InputMethodService.java b/core/java/android/inputmethodservice/InputMethodService.java
index 1e2e2f3..f1e613e 100644
--- a/core/java/android/inputmethodservice/InputMethodService.java
+++ b/core/java/android/inputmethodservice/InputMethodService.java
@@ -26,6 +26,7 @@ import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
 import android.os.Bundle;
 import android.os.IBinder;
+import android.os.ResultReceiver;
 import android.os.SystemClock;
 import android.provider.Settings;
 import android.text.InputType;
@@ -53,7 +54,6 @@ import android.view.inputmethod.InputMethodManager;
 import android.view.inputmethod.EditorInfo;
 import android.widget.Button;
 import android.widget.FrameLayout;
-
 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 
@@ -348,23 +348,37 @@ public class InputMethodService extends AbstractInputMethodService {
         /**
          * Handle a request by the system to hide the soft input area.
          */
-        public void hideSoftInput() {
+        public void hideSoftInput(int flags, ResultReceiver resultReceiver) {
             if (DEBUG) Log.v(TAG, "hideSoftInput()");
+            boolean wasVis = isInputViewShown();
             mShowInputFlags = 0;
             mShowInputRequested = false;
             mShowInputForced = false;
             hideWindow();
+            if (resultReceiver != null) {
+                resultReceiver.send(wasVis != isInputViewShown()
+                        ? InputMethodManager.RESULT_HIDDEN
+                        : (wasVis ? InputMethodManager.RESULT_UNCHANGED_SHOWN
+                                : InputMethodManager.RESULT_UNCHANGED_HIDDEN), null);
+            }
         }
 
         /**
          * Handle a request by the system to show the soft input area.
          */
-        public void showSoftInput(int flags) {
+        public void showSoftInput(int flags, ResultReceiver resultReceiver) {
             if (DEBUG) Log.v(TAG, "showSoftInput()");
+            boolean wasVis = isInputViewShown();
             mShowInputFlags = 0;
             if (onShowInputRequested(flags, false)) {
                 showWindow(true);
             }
+            if (resultReceiver != null) {
+                resultReceiver.send(wasVis != isInputViewShown()
+                        ? InputMethodManager.RESULT_SHOWN
+                        : (wasVis ? InputMethodManager.RESULT_UNCHANGED_SHOWN
+                                : InputMethodManager.RESULT_UNCHANGED_HIDDEN), null);
+            }
         }
     }
     
@@ -440,6 +454,13 @@ public class InputMethodService extends AbstractInputMethodService {
             }
             InputMethodService.this.onAppPrivateCommand(action, data);
         }
+        
+        /**
+         * 
+         */
+        public void toggleSoftInput(int showFlags, int hideFlags) {
+            InputMethodService.this.onToggleSoftInput(showFlags, hideFlags);
+        }
     }
     
     /**
@@ -1048,7 +1069,7 @@ public class InputMethodService extends AbstractInputMethodService {
      * text; you can override this (not calling the base class implementation)
      * to perform whatever behavior you would like.
      * 
-     * @boolean finishingInput If true, {@link #onFinishInput} will be
+     * @param finishingInput If true, {@link #onFinishInput} will be
      * called immediately after.
      */
     public void onFinishInputView(boolean finishingInput) {
@@ -1092,7 +1113,7 @@ public class InputMethodService extends AbstractInputMethodService {
      * text; you can override this (not calling the base class implementation)
      * to perform whatever behavior you would like.
      * 
-     * @boolean finishingInput If true, {@link #onFinishInput} will be
+     * @param finishingInput If true, {@link #onFinishInput} will be
      * called immediately after.
      */
     public void onFinishCandidatesView(boolean finishingInput) {
@@ -1107,14 +1128,14 @@ public class InputMethodService extends AbstractInputMethodService {
     /**
      * The system has decided that it may be time to show your input method.
      * This is called due to a corresponding call to your
-     * {@link InputMethod#showSoftInput(int) InputMethod.showSoftInput(int)}
+     * {@link InputMethod#showSoftInput InputMethod.showSoftInput()}
      * method.  The default implementation uses
      * {@link #onEvaluateInputViewShown()}, {@link #onEvaluateFullscreenMode()},
      * and the current configuration to decide whether the input view should
      * be shown at this point.
      * 
      * @param flags Provides additional information about the show request,
-     * as per {@link InputMethod#showSoftInput(int) InputMethod.showSoftInput(int)}.
+     * as per {@link InputMethod#showSoftInput InputMethod.showSoftInput()}.
      * @param configChange This is true if we are re-showing due to a
      * configuration change.
      * @return Returns true to indicate that the window should be shown.
@@ -1290,7 +1311,7 @@ public class InputMethodService extends AbstractInputMethodService {
         mStartedInputConnection = null;
         mCurCompletions = null;
     }
-    
+
     void doStartInput(InputConnection ic, EditorInfo attribute, boolean restarting) {
         if (!restarting) {
             doFinishInput();
@@ -1399,11 +1420,25 @@ public class InputMethodService extends AbstractInputMethodService {
      * 0 or have the {@link InputMethodManager#HIDE_IMPLICIT_ONLY
      * InputMethodManager.HIDE_IMPLICIT_ONLY} bit set.
      */
-    public void dismissSoftInput(int flags) {
+    public void requestHideSelf(int flags) {
         mImm.hideSoftInputFromInputMethod(mToken, flags);
     }
     
     /**
+     * Show the input method. This is a call back to the
+     * IMF to handle showing the input method.
+     * Close this input method's soft input area, removing it from the display.
+     * The input method will continue running, but the user can no longer use
+     * it to generate input by touching the screen.
+     * @param flags Provides additional operating flags.  Currently may be
+     * 0 or have the {@link InputMethodManager#SHOW_FORCED
+     * InputMethodManager.} bit set.
+     */
+    private void requestShowSelf(int flags) {
+        mImm.showSoftInputFromInputMethod(mToken, flags);
+    }
+    
+    /**
      * Override this to intercept key down events before they are processed by the
      * application.  If you return true, the application will not itself
      * process the event.  If you return true, the normal application processing
@@ -1421,7 +1456,7 @@ public class InputMethodService extends AbstractInputMethodService {
             if (mShowInputRequested) {
                 // If the soft input area is shown, back closes it and we
                 // consume the back key.
-                dismissSoftInput(0);
+                requestHideSelf(0);
                 return true;
             } else if (mWindowVisible) {
                 if (mCandidatesVisibility == View.VISIBLE) {
@@ -1438,7 +1473,6 @@ public class InputMethodService extends AbstractInputMethodService {
                 }
             }
         }
-        
         return doMovementKey(keyCode, event, MOVEMENT_DOWN);
     }
 
@@ -1480,6 +1514,18 @@ public class InputMethodService extends AbstractInputMethodService {
     public void onAppPrivateCommand(String action, Bundle data) {
     }
     
+    /**
+     * Handle a request by the system to toggle the soft input area.
+     */
+    private void onToggleSoftInput(int showFlags, int hideFlags) {
+        if (DEBUG) Log.v(TAG, "toggleSoftInput()");
+        if (isInputViewShown()) {
+            requestHideSelf(hideFlags);
+        } else {
+            requestShowSelf(showFlags);
+        }
+    }
+    
     static final int MOVEMENT_DOWN = -1;
     static final int MOVEMENT_UP = -2;
     
@@ -1737,6 +1783,8 @@ public class InputMethodService extends AbstractInputMethodService {
                 return getText(com.android.internal.R.string.ime_action_send);
             case EditorInfo.IME_ACTION_NEXT:
                 return getText(com.android.internal.R.string.ime_action_next);
+            case EditorInfo.IME_ACTION_DONE:
+                return getText(com.android.internal.R.string.ime_action_done);
             default:
                 return getText(com.android.internal.R.string.ime_action_default);
         }
@@ -1777,7 +1825,7 @@ public class InputMethodService extends AbstractInputMethodService {
      */
     public void onExtractingInputChanged(EditorInfo ei) {
         if (ei.inputType == InputType.TYPE_NULL) {
-            dismissSoftInput(InputMethodManager.HIDE_NOT_ALWAYS);
+            requestHideSelf(InputMethodManager.HIDE_NOT_ALWAYS);
         }
     }
     
diff --git a/core/java/android/inputmethodservice/KeyboardView.java b/core/java/android/inputmethodservice/KeyboardView.java
index c838779..f58b7ef 100755
--- a/core/java/android/inputmethodservice/KeyboardView.java
+++ b/core/java/android/inputmethodservice/KeyboardView.java
@@ -502,7 +502,7 @@ public class KeyboardView extends View implements View.OnClickListener {
     }
 
     private CharSequence adjustCase(CharSequence label) {
-        if (mKeyboard.isShifted() && label != null && label.length() == 1
+        if (mKeyboard.isShifted() && label != null && label.length() < 3
                 && Character.isLowerCase(label.charAt(0))) {
             label = label.toString().toUpperCase();
         }
diff --git a/core/java/android/net/http/AndroidHttpClient.java b/core/java/android/net/http/AndroidHttpClient.java
index 0c4fcda..c2013d5 100644
--- a/core/java/android/net/http/AndroidHttpClient.java
+++ b/core/java/android/net/http/AndroidHttpClient.java
@@ -63,6 +63,7 @@ import android.util.Log;
 import android.content.ContentResolver;
 import android.provider.Settings;
 import android.text.TextUtils;
+import android.os.SystemProperties;
 
 /**
  * Subclass of the Apache {@link DefaultHttpClient} that is configured with
@@ -387,10 +388,12 @@ public final class AndroidHttpClient implements HttpClient {
         }
 
         /**
-         * Returns true if auth logging is turned on for this configuration.
+         * Returns true if auth logging is turned on for this configuration.  Can only be set on
+         * insecure devices.
          */
         private boolean isAuthLoggable() {
-            return Log.isLoggable(tag + "-auth", level);
+            String secure = SystemProperties.get("ro.secure");
+            return "0".equals(secure) && Log.isLoggable(tag + "-auth", level);
         }
 
         /**
diff --git a/core/java/android/os/ResultReceiver.aidl b/core/java/android/os/ResultReceiver.aidl
new file mode 100644
index 0000000..28ce6d5
--- /dev/null
+++ b/core/java/android/os/ResultReceiver.aidl
@@ -0,0 +1,20 @@
+/* //device/java/android/android/os/ParcelFileDescriptor.aidl
+**
+** Copyright 2007, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License"); 
+** you may not use this file except in compliance with the License. 
+** You may obtain a copy of the License at 
+**
+**     http://www.apache.org/licenses/LICENSE-2.0 
+**
+** Unless required by applicable law or agreed to in writing, software 
+** distributed under the License is distributed on an "AS IS" BASIS, 
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+** See the License for the specific language governing permissions and 
+** limitations under the License.
+*/
+
+package android.os;
+
+parcelable ResultReceiver;
diff --git a/core/java/android/os/ResultReceiver.java b/core/java/android/os/ResultReceiver.java
new file mode 100644
index 0000000..711d4d9
--- /dev/null
+++ b/core/java/android/os/ResultReceiver.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.os;
+
+import com.android.internal.os.IResultReceiver;
+
+/**
+ * Generic interface for receiving a callback result from someone.  Use this
+ * by creating a subclass and implement {@link #onReceiveResult}, which you can
+ * then pass to others and send through IPC, and receive results they
+ * supply with {@link #send}.
+ */
+public class ResultReceiver implements Parcelable {
+    final boolean mLocal;
+    final Handler mHandler;
+    
+    IResultReceiver mReceiver;
+    
+    class MyRunnable implements Runnable {
+        final int mResultCode;
+        final Bundle mResultData;
+        
+        MyRunnable(int resultCode, Bundle resultData) {
+            mResultCode = resultCode;
+            mResultData = resultData;
+        }
+        
+        public void run() {
+            onReceiveResult(mResultCode, mResultData);
+        }
+    }
+    
+    class MyResultReceiver extends IResultReceiver.Stub {
+        public void send(int resultCode, Bundle resultData) {
+            if (mHandler != null) {
+                mHandler.post(new MyRunnable(resultCode, resultData));
+            } else {
+                onReceiveResult(resultCode, resultData);
+            }
+        }
+    }
+    
+    /**
+     * Create a new ResultReceive to receive results.  Your
+     * {@link #onReceiveResult} method will be called from the thread running
+     * <var>handler</var> if given, or from an arbitrary thread if null.
+     */
+    public ResultReceiver(Handler handler) {
+        mLocal = true;
+        mHandler = handler;
+    }
+    
+    /**
+     * Deliver a result to this receiver.  Will call {@link #onReceiveResult},
+     * always asynchronously if the receiver has supplied a Handler in which
+     * to dispatch the result.
+     * @param resultCode Arbitrary result code to deliver, as defined by you.
+     * @param resultData Any additional data provided by you.
+     */
+    public void send(int resultCode, Bundle resultData) {
+        if (mLocal) {
+            if (mHandler != null) {
+                mHandler.post(new MyRunnable(resultCode, resultData));
+            } else {
+                onReceiveResult(resultCode, resultData);
+            }
+            return;
+        }
+        
+        if (mReceiver != null) {
+            try {
+                mReceiver.send(resultCode, resultData);
+            } catch (RemoteException e) {
+            }
+        }
+    }
+    
+    /**
+     * Override to receive results delivered to this object.
+     * 
+     * @param resultCode Arbitrary result code delivered by the sender, as
+     * defined by the sender.
+     * @param resultData Any additional data provided by the sender.
+     */
+    protected void onReceiveResult(int resultCode, Bundle resultData) {
+    }
+    
+    public int describeContents() {
+        return 0;
+    }
+
+    public void writeToParcel(Parcel out, int flags) {
+        synchronized (this) {
+            if (mReceiver == null) {
+                mReceiver = new MyResultReceiver();
+            }
+            out.writeStrongBinder(mReceiver.asBinder());
+        }
+    }
+
+    ResultReceiver(Parcel in) {
+        mLocal = false;
+        mHandler = null;
+        mReceiver = IResultReceiver.Stub.asInterface(in.readStrongBinder());
+    }
+    
+    public static final Parcelable.Creator<ResultReceiver> CREATOR
+            = new Parcelable.Creator<ResultReceiver>() {
+        public ResultReceiver createFromParcel(Parcel in) {
+            return new ResultReceiver(in);
+        }
+        public ResultReceiver[] newArray(int size) {
+            return new ResultReceiver[size];
+        }
+    };
+}
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index b536b0d..b0ee479 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -2825,6 +2825,11 @@ public final class Settings {
         public static final String BATTERY_DISCHARGE_DURATION_THRESHOLD =
                 "battery_discharge_duration_threshold";
         public static final String BATTERY_DISCHARGE_THRESHOLD = "battery_discharge_threshold";
+        
+        /**
+         * An email address that anr bugreports should be sent to.
+         */
+        public static final String ANR_BUGREPORT_RECIPIENT = "anr_bugreport_recipient";
 
         /**
          * @deprecated
diff --git a/core/java/android/provider/Telephony.java b/core/java/android/provider/Telephony.java
index 18c64ed..d802c14 100644
--- a/core/java/android/provider/Telephony.java
+++ b/core/java/android/provider/Telephony.java
@@ -1023,6 +1023,11 @@ public final class Telephony {
          * <P>Type: INTEGER</P>
          */
         public static final String ERROR = "error";
+        /**
+         * Indicates whether this thread contains any attachments.
+         * <P>Type: INTEGER</P>
+         */
+        public static final String HAS_ATTACHMENT = "has_attachment";
     }
 
     /**
diff --git a/core/java/android/text/InputType.java b/core/java/android/text/InputType.java
index f643f92..d50684a 100644
--- a/core/java/android/text/InputType.java
+++ b/core/java/android/text/InputType.java
@@ -179,9 +179,27 @@ public interface InputType {
     public static final int TYPE_TEXT_VARIATION_PASSWORD = 0x00000080;
     
     /**
+     * Variation of {@link #TYPE_CLASS_TEXT}: entering a password, which should
+     * be visible to the user.
+     */
+    public static final int TYPE_TEXT_VARIATION_VISIBLE_PASSWORD = 0x00000090;
+    
+    /**
      * Variation of {@link #TYPE_CLASS_TEXT}: entering text inside of a web form.
      */
-    public static final int TYPE_TEXT_VARIATION_WEB_EDIT_TEXT = 0x00000090;
+    public static final int TYPE_TEXT_VARIATION_WEB_EDIT_TEXT = 0x000000a0;
+    
+    /**
+     * Variation of {@link #TYPE_CLASS_TEXT}: entering text to filter contents
+     * of a list etc.
+     */
+    public static final int TYPE_TEXT_VARIATION_FILTER = 0x000000b0;
+    
+    /**
+     * Variation of {@link #TYPE_CLASS_TEXT}: entering text for phonetic
+     * pronunciation, such as a phonetic name field in contacts.
+     */
+    public static final int TYPE_TEXT_VARIATION_PHONETIC = 0x000000c0;
     
     // ----------------------------------------------------------------------
     // ----------------------------------------------------------------------
diff --git a/core/java/android/text/method/ArrowKeyMovementMethod.java b/core/java/android/text/method/ArrowKeyMovementMethod.java
index 6df0b35..8aa49af 100644
--- a/core/java/android/text/method/ArrowKeyMovementMethod.java
+++ b/core/java/android/text/method/ArrowKeyMovementMethod.java
@@ -204,7 +204,7 @@ implements MovementMethod
                                 MotionEvent event) {
         boolean handled = Touch.onTouchEvent(widget, buffer, event);
 
-        if (widget.isFocused()) {
+        if (widget.isFocused() && !widget.didTouchFocusSelectAll()) {
             if (event.getAction() == MotionEvent.ACTION_UP) {
                 int x = (int) event.getX();
                 int y = (int) event.getY();
diff --git a/core/java/android/text/method/QwertyKeyListener.java b/core/java/android/text/method/QwertyKeyListener.java
index 0b39517..3f8288c 100644
--- a/core/java/android/text/method/QwertyKeyListener.java
+++ b/core/java/android/text/method/QwertyKeyListener.java
@@ -296,21 +296,28 @@ public class QwertyKeyListener extends BaseKeyListener {
                 String old = new String(repl[0].mText);
 
                 content.removeSpan(repl[0]);
-                content.setSpan(TextKeyListener.INHIBIT_REPLACEMENT,
-                                en, en, Spannable.SPAN_POINT_POINT);
-                content.replace(st, en, old);
 
-                en = content.getSpanStart(TextKeyListener.INHIBIT_REPLACEMENT);
-                if (en - 1 >= 0) {
+                // only cancel the autocomplete if the cursor is at the end of
+                // the replaced span
+                if (selStart == en) {
                     content.setSpan(TextKeyListener.INHIBIT_REPLACEMENT,
-                                    en - 1, en,
-                                    Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+                                    en, en, Spannable.SPAN_POINT_POINT);
+                    content.replace(st, en, old);
+
+                    en = content.getSpanStart(TextKeyListener.INHIBIT_REPLACEMENT);
+                    if (en - 1 >= 0) {
+                        content.setSpan(TextKeyListener.INHIBIT_REPLACEMENT,
+                                        en - 1, en,
+                                        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+                    } else {
+                        content.removeSpan(TextKeyListener.INHIBIT_REPLACEMENT);
+                    }
+                    adjustMetaAfterKeypress(content);
                 } else {
-                    content.removeSpan(TextKeyListener.INHIBIT_REPLACEMENT);
+                    adjustMetaAfterKeypress(content);
+                    return super.onKeyDown(view, content, keyCode, event);
                 }
 
-                adjustMetaAfterKeypress(content);
-
                 return true;
             }
         }
diff --git a/core/java/android/view/ViewGroup.java b/core/java/android/view/ViewGroup.java
index 70cc2a9..dc7b299 100644
--- a/core/java/android/view/ViewGroup.java
+++ b/core/java/android/view/ViewGroup.java
@@ -1387,14 +1387,10 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager
                     // The child need to draw an animation, potentially offscreen, so
                     // make sure we do not cancel invalidate requests
                     mPrivateFlags |= DRAW_ANIMATION;
-                    // Enlarge the invalidate region to account for rounding errors
-                    // in Animation#getInvalidateRegion(); Using 0.5f is unfortunately
-                    // not enough for some types of animations (e.g. scale down.)
-                    final int left = cl + (int) (region.left - 1.0f);
-                    final int top = ct + (int) (region.top - 1.0f);
-                    invalidate(left, top,
-                            left + (int) (region.width() + 1.0f),
-                            top + (int) (region.height() + 1.0f));
+
+                    final int left = cl + (int) region.left;
+                    final int top = ct + (int) region.top;
+                    invalidate(left, top, left + (int) region.width(), top + (int) region.height());
                 }
             }
         } else if ((flags & FLAG_SUPPORT_STATIC_TRANSFORMATIONS) ==
diff --git a/core/java/android/view/animation/Animation.java b/core/java/android/view/animation/Animation.java
index b9c8ec3..a662760 100644
--- a/core/java/android/view/animation/Animation.java
+++ b/core/java/android/view/animation/Animation.java
@@ -340,6 +340,7 @@ public abstract class Animation implements Cloneable {
      * to run.
      */
     public void restrictDuration(long durationMillis) {
+        // If we start after the duration, then we just won't run.
         if (mStartOffset > durationMillis) {
             mStartOffset = durationMillis;
             mDuration = 0;
@@ -349,11 +350,26 @@ public abstract class Animation implements Cloneable {
         
         long dur = mDuration + mStartOffset;
         if (dur > durationMillis) {
-            mDuration = dur = durationMillis-mStartOffset;
+            mDuration = durationMillis-mStartOffset;
+            dur = durationMillis;
         }
+        // If the duration is 0 or less, then we won't run.
+        if (mDuration <= 0) {
+            mDuration = 0;
+            mRepeatCount = 0;
+            return;
+        }
+        // Reduce the number of repeats to keep below the maximum duration.
+        // The comparison between mRepeatCount and duration is to catch
+        // overflows after multiplying them.
         if (mRepeatCount < 0 || mRepeatCount > durationMillis
                 || (dur*mRepeatCount) > durationMillis) {
-            mRepeatCount = (int)(durationMillis/dur);
+            // Figure out how many times to do the animation.  Subtract 1 since
+            // repeat count is the number of times to repeat so 0 runs once.
+            mRepeatCount = (int)(durationMillis/dur) - 1;
+            if (mRepeatCount < 0) {
+                mRepeatCount = 0;
+            }
         }
     }
     
@@ -416,7 +432,7 @@ public abstract class Animation implements Cloneable {
      * Sets how many times the animation should be repeated. If the repeat
      * count is 0, the animation is never repeated. If the repeat count is
      * greater than 0 or {@link #INFINITE}, the repeat mode will be taken
-     * into account. The repeat count if 0 by default.
+     * into account. The repeat count is 0 by default.
      *
      * @param repeatCount the number of times the animation should be repeated
      * @attr ref android.R.styleable#Animation_repeatCount
@@ -806,6 +822,8 @@ public abstract class Animation implements Cloneable {
 
         invalidate.set(left, top, right, bottom);
         transformation.getMatrix().mapRect(invalidate);
+        // Enlarge the invalidate region to account for rounding errors
+        invalidate.inset(-1.0f, -1.0f);
         tempRegion.set(invalidate);
         invalidate.union(previousRegion);
 
@@ -830,6 +848,8 @@ public abstract class Animation implements Cloneable {
     public void initializeInvalidateRegion(int left, int top, int right, int bottom) {
         final RectF region = mPreviousRegion;
         region.set(left, top, right, bottom);
+        // Enlarge the invalidate region to account for rounding errors
+        region.inset(-1.0f, -1.0f);
         if (mFillBefore) {
             final Transformation previousTransformation = mPreviousTransformation;
             applyTransformation(0.0f, previousTransformation);
diff --git a/core/java/android/view/animation/AnimationSet.java b/core/java/android/view/animation/AnimationSet.java
index 590ce06..98b2594 100644
--- a/core/java/android/view/animation/AnimationSet.java
+++ b/core/java/android/view/animation/AnimationSet.java
@@ -266,32 +266,10 @@ public class AnimationSet extends Animation {
     /**
      * @hide
      */
-    public void getInvalidateRegion(int left, int top, int right, int bottom,
-            RectF invalidate, Transformation transformation) {
-
-        final RectF previousRegion = mPreviousRegion;
-
-        invalidate.set(left, top, right, bottom);
-        transformation.getMatrix().mapRect(invalidate);
-        invalidate.union(previousRegion);
-
-        previousRegion.set(left, top, right, bottom);
-        transformation.getMatrix().mapRect(previousRegion);
-
-        final Transformation tempTransformation = mTransformation;
-        final Transformation previousTransformation = mPreviousTransformation;
-
-        tempTransformation.set(transformation);
-        transformation.set(previousTransformation);
-        previousTransformation.set(tempTransformation);
-    }
-
-    /**
-     * @hide
-     */
     public void initializeInvalidateRegion(int left, int top, int right, int bottom) {
         final RectF region = mPreviousRegion;
         region.set(left, top, right, bottom);
+        region.inset(-1.0f, -1.0f);
 
         if (mFillBefore) {
             final int count = mAnimations.size();
@@ -400,8 +378,12 @@ public class AnimationSet extends Animation {
 
 
         long[] storedOffsets = mStoredOffsets;
-        if (storedOffsets == null || storedOffsets.length != count) {
-            storedOffsets = mStoredOffsets = new long[count];
+        if (startOffsetSet) {
+            if (storedOffsets == null || storedOffsets.length != count) {
+                storedOffsets = mStoredOffsets = new long[count];
+            }
+        } else if (storedOffsets != null) {
+            storedOffsets = mStoredOffsets = null;
         }
 
         for (int i = 0; i < count; i++) {
@@ -446,7 +428,6 @@ public class AnimationSet extends Animation {
         final ArrayList<Animation> children = mAnimations;
         final int count = children.size();
 
-
         for (int i = 0; i < count; i++) {
             children.get(i).setStartOffset(offsets[i]);
         }
diff --git a/core/java/android/view/inputmethod/EditorInfo.java b/core/java/android/view/inputmethod/EditorInfo.java
index 0405371..1c0d42a 100644
--- a/core/java/android/view/inputmethod/EditorInfo.java
+++ b/core/java/android/view/inputmethod/EditorInfo.java
@@ -66,6 +66,12 @@ public class EditorInfo implements InputType, Parcelable {
     public static final int IME_ACTION_NEXT = 0x00000004;
     
     /**
+     * Bits of {@link #IME_MASK_ACTION}: the action key performs a "done"
+     * operation, typically meaning the IME will be closed.
+     */
+    public static final int IME_ACTION_DONE = 0x00000005;
+    
+    /**
      * Flag of {@link #imeOptions}: used in conjunction with
      * {@link #IME_MASK_ACTION}, this indicates that the action should not
      * be available in-line as the same as a "enter" key.  Typically this is
diff --git a/core/java/android/view/inputmethod/InputMethod.java b/core/java/android/view/inputmethod/InputMethod.java
index 740dca8..a5e0e94 100644
--- a/core/java/android/view/inputmethod/InputMethod.java
+++ b/core/java/android/view/inputmethod/InputMethod.java
@@ -18,6 +18,7 @@ package android.view.inputmethod;
 
 import android.inputmethodservice.InputMethodService;
 import android.os.IBinder;
+import android.os.ResultReceiver;
 
 /**
  * The InputMethod interface represents an input method which can generate key
@@ -171,7 +172,7 @@ public interface InputMethod {
     public void revokeSession(InputMethodSession session);
     
     /**
-     * Flag for {@link #showSoftInput(int)}: this show has been explicitly
+     * Flag for {@link #showSoftInput}: this show has been explicitly
      * requested by the user.  If not set, the system has decided it may be
      * a good idea to show the input method based on a navigation operation
      * in the UI.
@@ -179,7 +180,7 @@ public interface InputMethod {
     public static final int SHOW_EXPLICIT = 0x00001;
     
     /**
-     * Flag for {@link #showSoftInput(int)}: this show has been forced to
+     * Flag for {@link #showSoftInput}: this show has been forced to
      * happen by the user.  If set, the input method should remain visible
      * until deliberated dismissed by the user in its UI.
      */
@@ -188,13 +189,29 @@ public interface InputMethod {
     /**
      * Request that any soft input part of the input method be shown to the user.
      * 
-     * @param flags Provide additional information about the show request.
+     * @param flags Provides additional information about the show request.
      * Currently may be 0 or have the bit {@link #SHOW_EXPLICIT} set.
+     * @param resultReceiver The client requesting the show may wish to
+     * be told the impact of their request, which should be supplied here.
+     * The result code should be
+     * {@link InputMethodManager#RESULT_UNCHANGED_SHOWN InputMethodManager.RESULT_UNCHANGED_SHOWN},
+     * {@link InputMethodManager#RESULT_UNCHANGED_HIDDEN InputMethodManager.RESULT_UNCHANGED_HIDDEN},
+     * {@link InputMethodManager#RESULT_SHOWN InputMethodManager.RESULT_SHOWN}, or
+     * {@link InputMethodManager#RESULT_HIDDEN InputMethodManager.RESULT_HIDDEN}.
      */
-    public void showSoftInput(int flags);
+    public void showSoftInput(int flags, ResultReceiver resultReceiver);
     
     /**
      * Request that any soft input part of the input method be hidden from the user.
+     * @param flags Provides additional information about the show request.
+     * Currently always 0.
+     * @param resultReceiver The client requesting the show may wish to
+     * be told the impact of their request, which should be supplied here.
+     * The result code should be
+     * {@link InputMethodManager#RESULT_UNCHANGED_SHOWN InputMethodManager.RESULT_UNCHANGED_SHOWN},
+     * {@link InputMethodManager#RESULT_UNCHANGED_HIDDEN InputMethodManager.RESULT_UNCHANGED_HIDDEN},
+     * {@link InputMethodManager#RESULT_SHOWN InputMethodManager.RESULT_SHOWN}, or
+     * {@link InputMethodManager#RESULT_HIDDEN InputMethodManager.RESULT_HIDDEN}.
      */
-    public void hideSoftInput();
+    public void hideSoftInput(int flags, ResultReceiver resultReceiver);
 }
diff --git a/core/java/android/view/inputmethod/InputMethodManager.java b/core/java/android/view/inputmethod/InputMethodManager.java
index 0aa1d6c..916ffea 100644
--- a/core/java/android/view/inputmethod/InputMethodManager.java
+++ b/core/java/android/view/inputmethod/InputMethodManager.java
@@ -24,6 +24,7 @@ import android.os.IBinder;
 import android.os.Looper;
 import android.os.Message;
 import android.os.RemoteException;
+import android.os.ResultReceiver;
 import android.os.ServiceManager;
 import android.util.Log;
 import android.util.PrintWriterPrinter;
@@ -287,6 +288,9 @@ public final class InputMethodManager {
     // -----------------------------------------------------------
     
     static final int MSG_DUMP = 1;
+    static final int MSG_BIND = 2;
+    static final int MSG_UNBIND = 3;
+    static final int MSG_SET_ACTIVE = 4;
     
     class H extends Handler {
         H(Looper looper) {
@@ -309,6 +313,68 @@ public final class InputMethodManager {
                     }
                     return;
                 }
+                case MSG_BIND: {
+                    final InputBindResult res = (InputBindResult)msg.obj;
+                    synchronized (mH) {
+                        if (mBindSequence < 0 || mBindSequence != res.sequence) {
+                            Log.w(TAG, "Ignoring onBind: cur seq=" + mBindSequence
+                                    + ", given seq=" + res.sequence);
+                            return;
+                        }
+                        
+                        mCurMethod = res.method;
+                        mCurId = res.id;
+                        mBindSequence = res.sequence;
+                    }
+                    startInputInner();
+                    return;
+                }
+                case MSG_UNBIND: {
+                    final int sequence = msg.arg1;
+                    synchronized (mH) {
+                        if (mBindSequence == sequence) {
+                            if (false) {
+                                // XXX the server has already unbound!
+                                if (mCurMethod != null && mCurrentTextBoxAttribute != null) {
+                                    try {
+                                        mCurMethod.finishInput();
+                                    } catch (RemoteException e) {
+                                        Log.w(TAG, "IME died: " + mCurId, e);
+                                    }
+                                }
+                            }
+                            clearBindingLocked();
+                            
+                            // If we were actively using the last input method, then
+                            // we would like to re-connect to the next input method.
+                            if (mServedView != null && mServedView.isFocused()) {
+                                mServedConnecting = true;
+                            }
+                        }
+                        startInputInner();
+                    }
+                    return;
+                }
+                case MSG_SET_ACTIVE: {
+                    final boolean active = msg.arg1 != 0;
+                    synchronized (mH) {
+                        mActive = active;
+                        mFullscreenMode = false;
+                        if (!active) {
+                            // Some other client has starting using the IME, so note
+                            // that this happened and make sure our own editor's
+                            // state is reset.
+                            mHasBeenInactive = true;
+                            try {
+                                // Note that finishComposingText() is allowed to run
+                                // even when we are not active.
+                                mIInputContext.finishComposingText();
+                            } catch (RemoteException e) {
+                            }
+                        }
+                    }
+                    return;
+                }
             }
         }
     }
@@ -348,62 +414,15 @@ public final class InputMethodManager {
         }
         
         public void onBindMethod(InputBindResult res) {
-            synchronized (mH) {
-                if (mBindSequence < 0 || mBindSequence != res.sequence) {
-                    Log.w(TAG, "Ignoring onBind: cur seq=" + mBindSequence
-                            + ", given seq=" + res.sequence);
-                    return;
-                }
-                
-                mCurMethod = res.method;
-                mCurId = res.id;
-                mBindSequence = res.sequence;
-            }
-            startInputInner();
+            mH.sendMessage(mH.obtainMessage(MSG_BIND, res));
         }
         
         public void onUnbindMethod(int sequence) {
-            synchronized (mH) {
-                if (mBindSequence == sequence) {
-                    if (false) {
-                        // XXX the server has already unbound!
-                        if (mCurMethod != null && mCurrentTextBoxAttribute != null) {
-                            try {
-                                mCurMethod.finishInput();
-                            } catch (RemoteException e) {
-                                Log.w(TAG, "IME died: " + mCurId, e);
-                            }
-                        }
-                    }
-                    clearBindingLocked();
-                    
-                    // If we were actively using the last input method, then
-                    // we would like to re-connect to the next input method.
-                    if (mServedView != null && mServedView.isFocused()) {
-                        mServedConnecting = true;
-                    }
-                }
-                startInputInner();
-            }
+            mH.sendMessage(mH.obtainMessage(MSG_UNBIND, sequence, 0));
         }
         
         public void setActive(boolean active) {
-            synchronized (mH) {
-                mActive = active;
-                mFullscreenMode = false;
-                if (!active) {
-                    // Some other client has starting using the IME, so note
-                    // that this happened and make sure our own editor's
-                    // state is reset.
-                    mHasBeenInactive = true;
-                    try {
-                        // Note that finishComposingText() is allowed to run
-                        // even when we are not active.
-                        mIInputContext.finishComposingText();
-                    } catch (RemoteException e) {
-                    }
-                }
-            }
+            mH.sendMessage(mH.obtainMessage(MSG_SET_ACTIVE, active ? 1 : 0, 0));
         }
     };    
     
@@ -646,6 +665,52 @@ public final class InputMethodManager {
     public static final int SHOW_FORCED = 0x0002;
     
     /**
+     * Synonym for {@link #showSoftInput(View, int, ResultReceiver)} without
+     * a result receiver: explicitly request that the current input method's
+     * soft input area be shown to the user, if needed.
+     * 
+     * @param view The currently focused view, which would like to receive
+     * soft keyboard input.
+     * @param flags Provides additional operating flags.  Currently may be
+     * 0 or have the {@link #SHOW_IMPLICIT} bit set.
+     */
+    public boolean showSoftInput(View view, int flags) {
+        return showSoftInput(view, flags, null);
+    }
+    
+    /**
+     * Flag for the {@link ResultReceiver} result code from
+     * {@link #showSoftInput(View, int, ResultReceiver)} and
+     * {@link #hideSoftInputFromWindow(IBinder, int, ResultReceiver)}: the
+     * state of the soft input window was unchanged and remains shown.
+     */
+    public static final int RESULT_UNCHANGED_SHOWN = 0;
+    
+    /**
+     * Flag for the {@link ResultReceiver} result code from
+     * {@link #showSoftInput(View, int, ResultReceiver)} and
+     * {@link #hideSoftInputFromWindow(IBinder, int, ResultReceiver)}: the
+     * state of the soft input window was unchanged and remains hidden.
+     */
+    public static final int RESULT_UNCHANGED_HIDDEN = 1;
+    
+    /**
+     * Flag for the {@link ResultReceiver} result code from
+     * {@link #showSoftInput(View, int, ResultReceiver)} and
+     * {@link #hideSoftInputFromWindow(IBinder, int, ResultReceiver)}: the
+     * state of the soft input window changed from hidden to shown.
+     */
+    public static final int RESULT_SHOWN = 2;
+    
+    /**
+     * Flag for the {@link ResultReceiver} result code from
+     * {@link #showSoftInput(View, int, ResultReceiver)} and
+     * {@link #hideSoftInputFromWindow(IBinder, int, ResultReceiver)}: the
+     * state of the soft input window changed from shown to hidden.
+     */
+    public static final int RESULT_HIDDEN = 3;
+    
+    /**
      * Explicitly request that the current input method's soft input area be
      * shown to the user, if needed.  Call this if the user interacts with
      * your view in such a way that they have expressed they would like to
@@ -655,25 +720,33 @@ public final class InputMethodManager {
      * soft keyboard input.
      * @param flags Provides additional operating flags.  Currently may be
      * 0 or have the {@link #SHOW_IMPLICIT} bit set.
+     * @param resultReceiver If non-null, this will be called by the IME when
+     * it has processed your request to tell you what it has done.  The result
+     * code you receive may be either {@link #RESULT_UNCHANGED_SHOWN},
+     * {@link #RESULT_UNCHANGED_HIDDEN}, {@link #RESULT_SHOWN}, or
+     * {@link #RESULT_HIDDEN}.
      */
-    public void showSoftInput(View view, int flags) {
+    public boolean showSoftInput(View view, int flags,
+            ResultReceiver resultReceiver) {
         checkFocus();
         synchronized (mH) {
             if (mServedView != view) {
-                return;
+                return false;
             }
 
             try {
-                mService.showSoftInput(mClient, flags);
+                return mService.showSoftInput(mClient, flags, resultReceiver);
             } catch (RemoteException e) {
             }
+            
+            return false;
         }
     }
     
     /** @hide */
-    public void showSoftInputUnchecked(int flags) {
+    public void showSoftInputUnchecked(int flags, ResultReceiver resultReceiver) {
         try {
-            mService.showSoftInput(mClient, flags);
+            mService.showSoftInput(mClient, flags, resultReceiver);
         } catch (RemoteException e) {
         }
     }
@@ -693,6 +766,20 @@ public final class InputMethodManager {
     public static final int HIDE_NOT_ALWAYS = 0x0002;
     
     /**
+     * Synonym for {@link #hideSoftInputFromWindow(IBinder, int, ResultReceiver)
+     * without a result: request to hide the soft input window from the
+     * context of the window that is currently accepting input.
+     * 
+     * @param windowToken The token of the window that is making the request,
+     * as returned by {@link View#getWindowToken() View.getWindowToken()}.
+     * @param flags Provides additional operating flags.  Currently may be
+     * 0 or have the {@link #HIDE_IMPLICIT_ONLY} bit set.
+     */
+    public boolean hideSoftInputFromWindow(IBinder windowToken, int flags) {
+        return hideSoftInputFromWindow(windowToken, flags, null);
+    }
+    
+    /**
      * Request to hide the soft input window from the context of the window
      * that is currently accepting input.  This should be called as a result
      * of the user doing some actually than fairly explicitly requests to
@@ -702,21 +789,77 @@ public final class InputMethodManager {
      * as returned by {@link View#getWindowToken() View.getWindowToken()}.
      * @param flags Provides additional operating flags.  Currently may be
      * 0 or have the {@link #HIDE_IMPLICIT_ONLY} bit set.
+     * @param resultReceiver If non-null, this will be called by the IME when
+     * it has processed your request to tell you what it has done.  The result
+     * code you receive may be either {@link #RESULT_UNCHANGED_SHOWN},
+     * {@link #RESULT_UNCHANGED_HIDDEN}, {@link #RESULT_SHOWN}, or
+     * {@link #RESULT_HIDDEN}.
      */
-    public void hideSoftInputFromWindow(IBinder windowToken, int flags) {
+    public boolean hideSoftInputFromWindow(IBinder windowToken, int flags,
+            ResultReceiver resultReceiver) {
         checkFocus();
         synchronized (mH) {
             if (mServedView == null || mServedView.getWindowToken() != windowToken) {
-                return;
+                return false;
             }
 
             try {
-                mService.hideSoftInput(mClient, flags);
+                return mService.hideSoftInput(mClient, flags, resultReceiver);
             } catch (RemoteException e) {
             }
+            return false;
         }
     }
     
+
+    /**
+     * This method toggles the input method window display.
+     * If the input window is already displayed, it gets hidden. 
+     * If not the input window will be displayed.
+     * @param windowToken The token of the window that is making the request,
+     * as returned by {@link View#getWindowToken() View.getWindowToken()}.
+     * @param showFlags Provides additional operating flags.  May be
+     * 0 or have the {@link #SHOW_IMPLICIT},
+     * {@link #SHOW_FORCED} bit set.
+     * @param hideFlags Provides additional operating flags.  May be
+     * 0 or have the {@link #HIDE_IMPLICIT_ONLY},
+     * {@link #HIDE_NOT_ALWAYS} bit set.
+     **/
+    public void toggleSoftInputFromWindow(IBinder windowToken, int showFlags, int hideFlags) {
+        synchronized (mH) {
+            if (mServedView == null || mServedView.getWindowToken() != windowToken) {
+                return;
+            }
+            if (mCurMethod != null) {
+                try {
+                    mCurMethod.toggleSoftInput(showFlags, hideFlags);
+                } catch (RemoteException e) {
+                }
+            }
+        }
+    }
+
+    /*
+     * This method toggles the input method window display.
+     * If the input window is already displayed, it gets hidden. 
+     * If not the input window will be displayed.
+     * @param showFlags Provides additional operating flags.  May be
+     * 0 or have the {@link #SHOW_IMPLICIT},
+     * {@link #SHOW_FORCED} bit set.
+     * @param hideFlags Provides additional operating flags.  May be
+     * 0 or have the {@link #HIDE_IMPLICIT_ONLY},
+     * {@link #HIDE_NOT_ALWAYS} bit set.
+     * @hide
+     */
+    public void toggleSoftInput(int showFlags, int hideFlags) {
+        if (mCurMethod != null) {
+            try {
+                mCurMethod.toggleSoftInput(showFlags, hideFlags);
+            } catch (RemoteException e) {
+            }
+        }
+    }
+
     /**
      * If the input method is currently connected to the given view,
      * restart it with its new contents.  You should call this when the text
@@ -956,7 +1099,7 @@ public final class InputMethodManager {
     
     void closeCurrentInput() {
         try {
-            mService.hideSoftInput(mClient, HIDE_NOT_ALWAYS);
+            mService.hideSoftInput(mClient, HIDE_NOT_ALWAYS, null);
         } catch (RemoteException e) {
         }
     }
@@ -1118,7 +1261,8 @@ public final class InputMethodManager {
      * when it was started, which allows it to perform this operation on
      * itself.
      * @param flags Provides additional operating flags.  Currently may be
-     * 0 or have the {@link #HIDE_IMPLICIT_ONLY} bit set.
+     * 0 or have the {@link #HIDE_IMPLICIT_ONLY},
+     * {@link #HIDE_NOT_ALWAYS} bit set.
      */
     public void hideSoftInputFromInputMethod(IBinder token, int flags) {
         try {
@@ -1129,6 +1273,27 @@ public final class InputMethodManager {
     }
     
     /**
+     * Show the input method's soft input area, so the user 
+     * sees the input method window and can interact with it.
+     * This can only be called from the currently active input method,
+     * as validated by the given token.
+     * 
+     * @param token Supplies the identifying token given to an input method
+     * when it was started, which allows it to perform this operation on
+     * itself.
+     * @param flags Provides additional operating flags.  Currently may be
+     * 0 or have the {@link #SHOW_IMPLICIT} or
+     * {@link #SHOW_FORCED} bit set.
+     */
+    public void showSoftInputFromInputMethod(IBinder token, int flags) {
+        try {
+            mService.showMySoftInput(token, flags);
+        } catch (RemoteException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    /**
      * @hide
      */
     public void dispatchKeyEvent(Context context, int seq, KeyEvent key,
@@ -1204,7 +1369,7 @@ public final class InputMethodManager {
             }
         }
     }
-    
+
     void doDump(FileDescriptor fd, PrintWriter fout, String[] args) {
         final Printer p = new PrintWriterPrinter(fout);
         p.println("Input method client state for " + this + ":");
diff --git a/core/java/android/view/inputmethod/InputMethodSession.java b/core/java/android/view/inputmethod/InputMethodSession.java
index b5bbaff..bb03afa 100644
--- a/core/java/android/view/inputmethod/InputMethodSession.java
+++ b/core/java/android/view/inputmethod/InputMethodSession.java
@@ -139,4 +139,16 @@ public interface InputMethodSession {
      * @param data Any data to include with the command.
      */
     public void appPrivateCommand(String action, Bundle data);
+    
+    /**
+     * Toggle the soft input window. 
+     * Applications can toggle the state of the soft input window.
+     * @param showFlags Provides additional operating flags.  May be
+     * 0 or have the {@link InputMethodManager#SHOW_IMPLICIT},
+     * {@link InputMethodManager#SHOW_FORCED} bit set.
+     * @param hideFlags Provides additional operating flags.  May be
+     * 0 or have the {@link  InputMethodManager#HIDE_IMPLICIT_ONLY},
+     * {@link  InputMethodManager#HIDE_NOT_ALWAYS} bit set.
+     */
+    public void toggleSoftInput(int showFlags, int hideFlags);
 }
diff --git a/core/java/android/webkit/BrowserFrame.java b/core/java/android/webkit/BrowserFrame.java
index 451af6d..5401a6e 100644
--- a/core/java/android/webkit/BrowserFrame.java
+++ b/core/java/android/webkit/BrowserFrame.java
@@ -201,10 +201,14 @@ class BrowserFrame extends Handler {
             final String failingUrl) {
         // As this is called for the main resource and loading will be stopped
         // after, reset the state variables.
+        resetLoadingStates();
+        mCallbackProxy.onReceivedError(errorCode, description, failingUrl);
+    }
+
+    private void resetLoadingStates() {
         mCommitted = true;
         mWebViewCore.mEndScaleZoom = mFirstLayoutDone == false;
         mFirstLayoutDone = true;
-        mCallbackProxy.onReceivedError(errorCode, description, failingUrl);
     }
 
     /* package */boolean committed() {
@@ -290,6 +294,7 @@ class BrowserFrame extends Handler {
 
         if (isMainFrame || loadType == FRAME_LOADTYPE_STANDARD) {
             if (isMainFrame) {
+                resetLoadingStates();
                 mCallbackProxy.switchOutDrawHistory();
                 mCallbackProxy.onPageFinished(url);
             }
@@ -555,8 +560,11 @@ class BrowserFrame extends Handler {
                 method, isHighPriority);
         loader.setHeaders(headers);
         loader.setPostData(postData);
-        loader.setCacheMode(cacheMode); // Set the load mode to the mode used
-                                        // for the current page.
+        // Set the load mode to the mode used for the current page.
+        // If WebKit wants validation, go to network directly.
+        loader.setCacheMode(headers.containsKey("If-Modified-Since")
+                || headers.containsKey("If-None-Match") ? 
+                        WebSettings.LOAD_NO_CACHE : cacheMode);
         // Set referrer to current URL?
         if (!loader.executeLoad()) {
             checker.responseAlert("startLoadingResource fail");
@@ -751,7 +759,14 @@ class BrowserFrame extends Handler {
     /**
      * Stop loading the current page.
      */
-    public native void stopLoading();
+    public void stopLoading() {
+        if (mIsMainFrame) {
+            resetLoadingStates();
+        }
+        nativeStopLoading();
+    }
+
+    private native void nativeStopLoading();
 
     /**
      * Return true if the document has images.
diff --git a/core/java/android/webkit/FrameLoader.java b/core/java/android/webkit/FrameLoader.java
index 5e323eb..42d03f0 100644
--- a/core/java/android/webkit/FrameLoader.java
+++ b/core/java/android/webkit/FrameLoader.java
@@ -21,7 +21,6 @@ import android.net.http.RequestHandle;
 import android.util.Config;
 import android.util.Log;
 import android.webkit.CacheManager.CacheResult;
-import android.webkit.UrlInterceptRegistry;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -234,12 +233,14 @@ class FrameLoader {
     private boolean handleUrlIntercept() {
         // Check if the URL can be served from UrlIntercept. If
         // successful, return the data just like a cache hit.
-        CacheResult result = UrlInterceptRegistry.getSurrogate(
+
+        PluginData data = UrlInterceptRegistry.getPluginData(
                 mListener.url(), mHeaders);
-        if(result != null) {
-            // Intercepted. The data is stored in result.stream. Setup
-            // a load from the CacheResult.
-            startCacheLoad(result);
+
+        if(data != null) {
+            PluginContentLoader loader =
+                    new PluginContentLoader(mListener, data);
+            loader.load();
             return true;
         }
         // Not intercepted. Carry on as normal.
diff --git a/core/java/android/webkit/LoadListener.java b/core/java/android/webkit/LoadListener.java
index dfae17d..8d4b220 100644
--- a/core/java/android/webkit/LoadListener.java
+++ b/core/java/android/webkit/LoadListener.java
@@ -1126,6 +1126,7 @@ class LoadListener extends Handler implements EventHandler {
                 mCacheResult = null;
             }
 
+            // This will strip the anchor
             setUrl(redirectTo);
 
             // Redirect may be in the cache
@@ -1143,7 +1144,7 @@ class LoadListener extends Handler implements EventHandler {
                 // mRequestHandle can be null when the request was satisfied
                 // by the cache, and the cache returned a redirect
                 if (mRequestHandle != null) {
-                    mRequestHandle.setupRedirect(redirectTo, mStatusCode,
+                    mRequestHandle.setupRedirect(mUrl, mStatusCode,
                             mRequestHeaders);
                 } else {
                     // If the original request came from the cache, there is no
@@ -1336,19 +1337,16 @@ class LoadListener extends Handler implements EventHandler {
      */
     void setUrl(String url) {
         if (url != null) {
-            if (URLUtil.isDataUrl(url)) {
-             // Don't strip anchor as that is a valid part of the URL
-                mUrl = url;
-            } else {
-                mUrl = URLUtil.stripAnchor(url);
-            }
             mUri = null;
-            if (URLUtil.isNetworkUrl(mUrl)) {
+            if (URLUtil.isNetworkUrl(url)) {
+                mUrl = URLUtil.stripAnchor(url);
                 try {
                     mUri = new WebAddress(mUrl);
                 } catch (ParseException e) {
                     e.printStackTrace();
                 }
+            } else {
+                mUrl = url;
             }
         }
     }
diff --git a/core/java/android/webkit/PluginContentLoader.java b/core/java/android/webkit/PluginContentLoader.java
new file mode 100644
index 0000000..2069599
--- /dev/null
+++ b/core/java/android/webkit/PluginContentLoader.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.webkit;
+
+import android.net.http.Headers;
+
+import java.io.InputStream;
+import java.util.*;
+
+import org.apache.http.util.CharArrayBuffer;
+
+/**
+ * This class is a concrete implementation of StreamLoader that uses a
+ * PluginData object as the source for the stream.
+ */
+class PluginContentLoader extends StreamLoader {
+
+    private PluginData mData;  // Content source
+
+    /**
+     * Constructs a PluginDataLoader for use when loading content from
+     * a plugin.
+     *
+     * @param loadListener LoadListener to pass the content to
+     * @param data PluginData used as the source for the content.
+     */
+    PluginContentLoader(LoadListener loadListener, PluginData data) {
+        super(loadListener);
+        mData = data;
+    }
+
+    @Override
+    protected boolean setupStreamAndSendStatus() {
+        mDataStream = mData.getInputStream();
+        mContentLength = mData.getContentLength();
+        mHandler.status(1, 1, mData.getStatusCode(), "OK");
+        return true;
+    }
+
+    @Override
+    protected void buildHeaders(Headers headers) {
+        // Crate a CharArrayBuffer with an arbitrary initial capacity.
+        CharArrayBuffer buffer = new CharArrayBuffer(100);
+        Iterator<Map.Entry<String, String[]>> responseHeadersIt =
+                mData.getHeaders().entrySet().iterator();
+        while (responseHeadersIt.hasNext()) {
+            Map.Entry<String, String[]> entry = responseHeadersIt.next();
+            // Headers.parseHeader() expects lowercase keys, so keys
+            // such as "Accept-Ranges" will fail to parse.
+            //
+            // UrlInterceptHandler instances supply a mapping of
+            // lowercase key to [ unmodified key, value ], so for
+            // Headers.parseHeader() to succeed, we need to construct
+            // a string using the key (i.e. entry.getKey()) and the
+            // element denoting the header value in the
+            // [ unmodified key, value ] pair (i.e. entry.getValue()[1).
+            //
+            // The reason why UrlInterceptHandler instances supply such a
+            // mapping in the first place is historical. Early versions of
+            // the Gears plugin used java.net.HttpURLConnection, which always
+            // returned headers names as capitalized strings. When these were
+            // fed back into webkit, they failed to parse.
+            //
+            // Mewanwhile, Gears was modified to use Apache HTTP library
+            // instead, so this design is now obsolete. Changing it however,
+            // would require changes to the Gears C++ codebase and QA-ing and
+            // submitting a new binary to the Android tree. Given the
+            // timelines for the next Android release, we will not do this
+            // for now.
+            //
+            // TODO: fix C++ Gears to remove the need for this
+            // design.
+            String keyValue = entry.getKey() + ": " + entry.getValue()[1];
+            buffer.ensureCapacity(keyValue.length());
+            buffer.append(keyValue);
+            // Parse it into the header container.
+            headers.parseHeader(buffer);
+            // Clear the buffer
+            buffer.clear();
+        }
+    }
+}
diff --git a/core/java/android/webkit/PluginData.java b/core/java/android/webkit/PluginData.java
new file mode 100644
index 0000000..2b539fe
--- /dev/null
+++ b/core/java/android/webkit/PluginData.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.webkit;
+
+import java.io.InputStream;
+import java.util.Map;
+
+/**
+ * This class encapsulates the content generated by a plugin.  The
+ * data itself is meant to be loaded into webkit via the
+ * PluginContentLoader class, which needs to be able to construct an
+ * HTTP response. For this, it needs a stream with the response body,
+ * the length of the body, the response headers, and the response
+ * status code. The PluginData class is the container for all these
+ * parts.
+ *
+ */
+public final class PluginData {
+    /**
+     * The content stream.
+     */
+    private InputStream mStream;
+    /**
+     * The content length.
+     */
+    private long mContentLength;
+    /**
+     * The associated HTTP response headers stored as a map of
+     * lowercase header name to [ unmodified header name, header value].
+     * TODO: This design was always a hack. Remove (involves updating
+     * the Gears C++ side).
+     */
+    private Map<String, String[]> mHeaders;
+
+    /**
+     * The index of the header value in the above mapping.
+     */
+    private int mHeaderValueIndex;
+    /**
+     * The associated HTTP response code.
+     */
+    private int mStatusCode;
+
+    /**
+     * Creates a PluginData instance.
+     *
+     * @param stream The stream that supplies content for the plugin.
+     * @param length The length of the plugin content.
+     * @param headers The response headers. Map of
+     * lowercase header name to [ unmodified header name, header value]
+     * @param length The HTTP response status code.
+     */
+    public PluginData(
+            InputStream stream,
+            long length,
+            Map<String, String[]> headers,
+            int code) {
+        mStream = stream;
+        mContentLength = length;
+        mHeaders = headers;
+        mStatusCode = code;
+    }
+
+    /**
+     * Returns the input stream that contains the plugin content.
+     *
+     * @return An InputStream instance with the plugin content.
+     */
+    public InputStream getInputStream() {
+        return mStream;
+    }
+
+    /**
+     * Returns the length of the plugin content.
+     *
+     * @return the length of the plugin content.
+     */
+    public long getContentLength() {
+        return mContentLength;
+    }
+
+    /**
+     * Returns the HTTP response headers associated with the plugin
+     * content.
+     *
+     * @return A Map<String, String[]> containing all headers. The
+     * mapping is 'lowercase header name' to ['unmodified header
+     * name', header value].
+     */
+    public Map<String, String[]> getHeaders() {
+        return mHeaders;
+    }
+
+    /**
+     * Returns the HTTP status code for the response.
+     *
+     * @return The HTTP statue code, e.g 200.
+     */
+    public int getStatusCode() {
+        return mStatusCode;
+    }
+}
diff --git a/core/java/android/webkit/TextDialog.java b/core/java/android/webkit/TextDialog.java
index 8a82411..39806dc 100644
--- a/core/java/android/webkit/TextDialog.java
+++ b/core/java/android/webkit/TextDialog.java
@@ -113,13 +113,7 @@ import java.util.ArrayList;
         // that other applications that use embedded WebViews will properly
         // display the text in textfields.
         setTextColor(Color.BLACK);
-    }
-
-    @Override
-    protected boolean shouldAdvanceFocusOnEnter() {
-        // In the browser, single line textfields use enter as a form submit,
-        // so we never want to advance the focus on enter.
-        return false;
+        setImeOptions(EditorInfo.IME_ACTION_NONE);
     }
 
     @Override
diff --git a/core/java/android/webkit/UrlInterceptHandler.java b/core/java/android/webkit/UrlInterceptHandler.java
index e1c9d61..9216413 100644
--- a/core/java/android/webkit/UrlInterceptHandler.java
+++ b/core/java/android/webkit/UrlInterceptHandler.java
@@ -17,6 +17,7 @@
 package android.webkit;
 
 import android.webkit.CacheManager.CacheResult;
+import android.webkit.PluginData;
 import java.util.Map;
 
 public interface UrlInterceptHandler {
@@ -29,6 +30,20 @@ public interface UrlInterceptHandler {
      * @param url URL string.
      * @param headers The headers associated with the request. May be null.
      * @return The CacheResult containing the surrogate response.
+     * @Deprecated Use PluginData getPluginData(String url,
+     * Map<String, String> headers); instead
      */
+    @Deprecated
     public CacheResult service(String url, Map<String, String> headers);
+
+    /**
+     * Given an URL, returns the PluginData which contains the
+     * surrogate response for the request, or null if the handler is
+     * not interested.
+     *
+     * @param url URL string.
+     * @param headers The headers associated with the request. May be null.
+     * @return The PluginData containing the surrogate response.
+     */
+    public PluginData getPluginData(String url, Map<String, String> headers);
 }
diff --git a/core/java/android/webkit/UrlInterceptRegistry.java b/core/java/android/webkit/UrlInterceptRegistry.java
index a218191..6051f29 100644
--- a/core/java/android/webkit/UrlInterceptRegistry.java
+++ b/core/java/android/webkit/UrlInterceptRegistry.java
@@ -17,6 +17,7 @@
 package android.webkit;
 
 import android.webkit.CacheManager.CacheResult;
+import android.webkit.PluginData;
 import android.webkit.UrlInterceptHandler;
 
 import java.util.Iterator;
@@ -82,17 +83,21 @@ public final class UrlInterceptRegistry {
             UrlInterceptHandler handler) {
         return getHandlers().remove(handler);
     }
-    
+
     /**
      * Given an url, returns the CacheResult of the first
      * UrlInterceptHandler interested, or null if none are.
-     * 
+     *
      * @return A CacheResult containing surrogate content.
+     * @Deprecated Use PluginData getPluginData( String url,
+     * Map<String, String> headers) instead.
      */
+    @Deprecated
     public static synchronized CacheResult getSurrogate(
             String url, Map<String, String> headers) {
-        if (urlInterceptDisabled())
+        if (urlInterceptDisabled()) {
             return null;
+        }
         Iterator iter = getHandlers().listIterator();
         while (iter.hasNext()) {
             UrlInterceptHandler handler = (UrlInterceptHandler) iter.next();
@@ -103,4 +108,27 @@ public final class UrlInterceptRegistry {
         }
         return null;
     }
+
+    /**
+     * Given an url, returns the PluginData of the first
+     * UrlInterceptHandler interested, or null if none are or if
+     * intercepts are disabled.
+     *
+     * @return A PluginData instance containing surrogate content.
+     */
+    public static synchronized PluginData getPluginData(
+            String url, Map<String, String> headers) {
+        if (urlInterceptDisabled()) {
+            return null;
+        }
+        Iterator iter = getHandlers().listIterator();
+        while (iter.hasNext()) {
+            UrlInterceptHandler handler = (UrlInterceptHandler) iter.next();
+            PluginData data = handler.getPluginData(url, headers);
+            if (data != null) {
+                return data;
+            }
+        }
+        return null;
+    }
 }
diff --git a/core/java/android/webkit/WebView.java b/core/java/android/webkit/WebView.java
index 5126ef0..91795a3 100644
--- a/core/java/android/webkit/WebView.java
+++ b/core/java/android/webkit/WebView.java
@@ -689,7 +689,10 @@ public class WebView extends AbsoluteLayout
             return true;
         }
 
-        public void onSimpleZoom(boolean zoomIn) {
+        public void onSimpleZoom(boolean zoomIn, int centerX, int centerY) {
+            mZoomCenterX = (float) centerX;
+            mZoomCenterY = (float) centerY;
+            
             if (zoomIn) {
                 zoomIn();
             } else {
@@ -736,12 +739,12 @@ public class WebView extends AbsoluteLayout
         mFocusData.mY = 0;
         mScroller = new Scroller(context);
         mZoomRingController = new ZoomRingController(context, this);
-        mZoomRingController.setResetThumbAutomatically(false);
         mZoomRingController.setCallback(mZoomListener);
-        mZoomRingController.setZoomRingTrack(
+        mZoomRingController.setTrackDrawable(
                 com.android.internal.R.drawable.zoom_ring_track_absolute);
-        mZoomRingController.setPannerAcceleration(160);
-        mZoomRingController.setPannerStartAcceleratingDuration(700);
+        float density = context.getResources().getDisplayMetrics().density;
+        mZoomRingController.setPannerAcceleration((int) (160 * density));
+        mZoomRingController.setPannerStartAcceleratingDuration((int) (700 * density));
         createZoomRingOverviewTab();
         mZoomButtonsController = new ZoomButtonsController(context, this);
         mZoomButtonsController.setOverviewVisible(true);
@@ -760,7 +763,7 @@ public class WebView extends AbsoluteLayout
             }
 
             public void onZoom(boolean zoomIn) {
-                mZoomListener.onSimpleZoom(zoomIn);
+                mZoomListener.onSimpleZoom(zoomIn, getWidth() / 2, getHeight() / 2);
             }
         });
     }
@@ -4491,6 +4494,14 @@ public class WebView extends AbsoluteLayout
         return zoomControls;
     }
 
+    // This used to be the value returned by ViewConfiguration.getTouchSlop().
+    // We pass this to the navigation cache to find where the user clicked.
+    // TouchSlop has been increased for other purposes, but for the
+    // navigation cache it is too big, and may result in clicking the wrong
+    // spot.  This is a concern when the cache is out of date, and clicking
+    // finds a node which is wrong but nearby.
+    private static final int NAV_SLOP = 12;
+
     private void updateSelection() {
         if (mNativeClass == 0) {
             return;
@@ -4498,7 +4509,7 @@ public class WebView extends AbsoluteLayout
         // mLastTouchX and mLastTouchY are the point in the current viewport
         int contentX = viewToContent((int) mLastTouchX + mScrollX);
         int contentY = viewToContent((int) mLastTouchY + mScrollY);
-        int contentSize = ViewConfiguration.getTouchSlop();
+        int contentSize = NAV_SLOP;
         Rect rect = new Rect(contentX - contentSize, contentY - contentSize,
                 contentX + contentSize, contentY + contentSize);
         // If we were already focused on a textfield, update its cache.
@@ -4513,7 +4524,7 @@ public class WebView extends AbsoluteLayout
             View v = mTextEntry;
             int x = viewToContent((v.getLeft() + v.getRight()) >> 1);
             int y = viewToContent((v.getTop() + v.getBottom()) >> 1);
-            int contentSize = ViewConfiguration.get(getContext()).getScaledTouchSlop();
+            int contentSize = NAV_SLOP;
             nativeMotionUp(x, y, contentSize, true);
         }
     }
@@ -4526,7 +4537,7 @@ public class WebView extends AbsoluteLayout
         // mLastTouchX and mLastTouchY are the point in the current viewport
         int contentX = viewToContent((int) mLastTouchX + mScrollX);
         int contentY = viewToContent((int) mLastTouchY + mScrollY);
-        int contentSize = ViewConfiguration.get(getContext()).getScaledTouchSlop();
+        int contentSize = NAV_SLOP;
         if (nativeMotionUp(contentX, contentY, contentSize, true)) {
             if (mLogEvent) {
                 Checkin.updateStats(mContext.getContentResolver(),
diff --git a/core/java/android/webkit/gears/UrlInterceptHandlerGears.java b/core/java/android/webkit/gears/UrlInterceptHandlerGears.java
index 2a5cbe9..43104bf 100644
--- a/core/java/android/webkit/gears/UrlInterceptHandlerGears.java
+++ b/core/java/android/webkit/gears/UrlInterceptHandlerGears.java
@@ -25,16 +25,14 @@
 
 package android.webkit.gears;
 
-import android.net.http.Headers;
 import android.util.Log;
-import android.webkit.CacheManager;
 import android.webkit.CacheManager.CacheResult;
 import android.webkit.Plugin;
+import android.webkit.PluginData;
 import android.webkit.UrlInterceptRegistry;
 import android.webkit.UrlInterceptHandler;
 import android.webkit.WebView;
 
-import org.apache.http.impl.cookie.DateUtils;
 import org.apache.http.util.CharArrayBuffer;
 
 import java.io.*;
@@ -53,12 +51,6 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler {
   private static final String LOG_TAG = "Gears-J";
   /** Buffer size for reading/writing streams. */
   private static final int BUFFER_SIZE = 4096;
-  /**
-   * Number of milliseconds to expire LocalServer temporary entries in
-   * the browser's cache. Somewhat arbitrarily chosen as a compromise
-   * between being a) long enough not to expire during page load and
-   * b) short enough to evict entries during a session. */
-  private static final int CACHE_EXPIRY_MS = 60000; // 1 minute.
   /** Enable/disable all logging in this class. */
   private static boolean logEnabled = false;
   /** The unmodified (case-sensitive) key in the headers map is the
@@ -140,6 +132,8 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler {
     private String encoding;
     // The stream which contains the body when read().
     private InputStream inputStream;
+    // The length of the content body.
+    private long contentLength;
 
     /**
      * Initialize members using an in-memory array to return the body.
@@ -160,6 +154,7 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler {
       this.mimeType = mimeType;
       this.encoding = encoding;
       // Setup a stream to read out of the byte array.
+      this.contentLength = body.length;
       this.inputStream = new ByteArrayInputStream(body);
     }
     
@@ -185,7 +180,9 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler {
       this.encoding = encoding;
       try {
         // Setup a stream to read out of a file on disk.
-        this.inputStream = new FileInputStream(new File(path));
+        File file = new File(path);
+        this.contentLength = file.length();
+        this.inputStream = new FileInputStream(file);
         return true;
       } catch (java.io.FileNotFoundException ex) {
         log("File not found: " + path);
@@ -274,6 +271,13 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler {
     public InputStream getInputStream() {
       return inputStream;
     }
+
+    /**
+     * @return The length of the response body.
+     */
+    public long getContentLength() {
+      return contentLength;
+    }
   }
 
   /**
@@ -319,44 +323,32 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler {
     UrlInterceptRegistry.unregisterHandler(this);
   }
 
-  /**
-   * Copy the entire InputStream to OutputStream.
-   * @param inputStream The stream to read from.
-   * @param outputStream The stream to write to.
-   * @return True if the entire stream copied successfully, false on error.
-   */
-  private boolean copyStream(InputStream inputStream,
-      OutputStream outputStream) {
-    try {
-      // Temporary buffer to copy stream through.
-      byte[] buf = new byte[BUFFER_SIZE];
-      for (;;) {
-        // Read up to BUFFER_SIZE bytes.
-        int bytes = inputStream.read(buf);
-        if (bytes < 0) {
-          break;
-        }
-        // Write the number of bytes we just read.
-        outputStream.write(buf, 0, bytes);
-      }
-    } catch (IOException ex) {
-      log("Got IOException copying stream: " + ex);
-      return false;
+    /**
+     * Given an URL, returns the CacheResult which contains the
+     * surrogate response for the request, or null if the handler is
+     * not interested.
+     *
+     * @param url URL string.
+     * @param headers The headers associated with the request. May be null.
+     * @return The CacheResult containing the surrogate response.
+     * @Deprecated Use PluginData getPluginData(String url,
+     * Map<String, String> headers); instead
+     */
+    @Deprecated
+    public CacheResult service(String url, Map<String, String> headers) {
+      throw new UnsupportedOperationException("unimplemented");
     }
-    return true;
-  }
 
   /**
-   * Given an URL, returns a CacheResult which contains the response
-   * for the request. This implements the UrlInterceptHandler interface.
+   * Given an URL, returns a PluginData instance which contains the
+   * response for the request. This implements the UrlInterceptHandler
+   * interface.
    *
-   * @param url            The fully qualified URL being requested.
+   * @param url The fully qualified URL being requested.
    * @param requestHeaders The request headers for this URL.
-   * @return If a response can be crafted, a CacheResult initialized
-   *         to return the surrogate response. If this URL cannot
-   *         be serviced, returns null.
+   * @return a PluginData object.
    */
-  public CacheResult service(String url, Map<String, String> requestHeaders) {
+  public PluginData getPluginData(String url, Map<String, String> requestHeaders) {
     // Thankfully the browser does call us with case-sensitive
     // headers. We just need to map it case-insensitive.
     Map<String, String[]> lowercaseRequestHeaders =
@@ -374,86 +366,10 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler {
       // No result for this URL.
       return null;
     }
-    // Translate the ServiceResponse to a CacheResult.
-    // Translate http -> gears, https -> gearss, so we don't overwrite
-    // existing entries.
-    String gearsUrl = "gears" + url.substring("http".length());
-    // Set the result to expire, so that entries don't pollute the
-    // browser's cache for too long.
-    long now_ms = System.currentTimeMillis();
-    String expires = DateUtils.formatDate(new Date(now_ms + CACHE_EXPIRY_MS));
-    response.setResponseHeader(ApacheHttpRequestAndroid.KEY_EXPIRES, expires);
-    // The browser is only interested in a small subset of headers,
-    // contained in a Headers object. Iterate the map of all headers
-    // and add them to Headers.
-    Headers headers = new Headers();
-    Iterator<Map.Entry<String, String[]>> responseHeadersIt =
-        response.getResponseHeaders().entrySet().iterator();
-    while (responseHeadersIt.hasNext()) {
-      Map.Entry<String, String[]> entry = responseHeadersIt.next();
-      // Headers.parseHeader() expects lowercase keys.
-      String keyValue = entry.getKey() + ": "
-          + entry.getValue()[HEADERS_MAP_INDEX_VALUE];
-      CharArrayBuffer buffer = new CharArrayBuffer(keyValue.length());
-      buffer.append(keyValue);
-      // Parse it into the header container.
-      headers.parseHeader(buffer);
-    }
-    CacheResult cacheResult = CacheManager.createCacheFile(
-        gearsUrl,
-        response.getStatusCode(),
-        headers,
-        response.getMimeType(),
-        true); // forceCache
-
-    if (cacheResult == null) {
-      // With the no-cache policy we could end up
-      // with a null result
-      return null;
-    }
-
-    // Set encoding if specified.
-    String encoding = response.getEncoding();
-    if (encoding != null) {
-      cacheResult.setEncoding(encoding);
-    }
-    // Copy the response body to the CacheResult. This handles all
-    // combinations of memory vs on-disk on both sides.
-    InputStream inputStream = response.getInputStream();
-    OutputStream outputStream = cacheResult.getOutputStream();
-    boolean copied = copyStream(inputStream, outputStream);
-    // Close the input and output streams to relinquish their
-    // resources earlier.
-    try {
-      inputStream.close();
-    } catch (IOException ex) {
-      log("IOException closing InputStream: " + ex);
-      copied = false;
-    }
-    try {
-      outputStream.close();
-    } catch (IOException ex) {
-      log("IOException closing OutputStream: " + ex);
-      copied = false;
-    }
-    if (!copied) {
-      log("copyStream of local result failed");
-      return null;
-    }
-    // Save the entry into the browser's cache.
-    CacheManager.saveCacheFile(gearsUrl, cacheResult);
-    // Get it back from the cache, this time properly initialized to
-    // be used for input.
-    cacheResult = CacheManager.getCacheFile(gearsUrl, null);
-    if (cacheResult != null) {
-      log("Returning surrogate result");
-      return cacheResult;
-    } else {
-      // Not an expected condition, but handle gracefully. Perhaps out
-      // of memory or disk?
-      Log.e(LOG_TAG, "Lost CacheResult between save and get. Can't serve.\n");
-      return null;
-    }
+    return new PluginData(response.getInputStream(),
+                          response.getContentLength(),
+                          response.getResponseHeaders(),
+                          response.getStatusCode());
   }
 
   /**
diff --git a/core/java/android/widget/AbsListView.java b/core/java/android/widget/AbsListView.java
index 9da78d0..d72570a 100644
--- a/core/java/android/widget/AbsListView.java
+++ b/core/java/android/widget/AbsListView.java
@@ -2766,6 +2766,7 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te
     private void showPopup() {
         // Make sure we have a window before showing the popup
         if (getWindowVisibility() == View.VISIBLE) {
+            createTextFilter(true);
             positionPopup(false);
             // Make sure we get focus if we are showing the popup
             checkFocus();
@@ -2913,8 +2914,8 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te
         if (mPopup == null) {
             Context c = getContext();
             PopupWindow p = new PopupWindow(c);
-            LayoutInflater layoutInflater = (LayoutInflater) c
-                    .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+            LayoutInflater layoutInflater = (LayoutInflater)
+                    c.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
             mTextFilter = (EditText) layoutInflater.inflate(
                     com.android.internal.R.layout.typing_filter, null);
             mTextFilter.addTextChangedListener(this);
@@ -3136,6 +3137,14 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te
          */
         int viewType;
 
+        /**
+         * When this boolean is set, the view has been added to the AbsListView
+         * at least once. It is used to know whether headers/footers have already
+         * been added to the list view and whether they should be treated as
+         * recycled views or not.
+         */
+        boolean recycledHeaderFooter;
+
         public LayoutParams(Context c, AttributeSet attrs) {
             super(c, attrs);
         }
@@ -3269,7 +3278,7 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te
                 if (lp != null && lp.viewType != AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
                     // Note:  We do place AdapterView.ITEM_VIEW_TYPE_IGNORE in active views.
                     //        However, we will NOT place them into scrap views.
-                    activeViews[i] = getChildAt(i);
+                    activeViews[i] = child;
                 }
             }
         }
diff --git a/core/java/android/widget/FastScroller.java b/core/java/android/widget/FastScroller.java
index 57e21e4..0a552e8 100644
--- a/core/java/android/widget/FastScroller.java
+++ b/core/java/android/widget/FastScroller.java
@@ -62,6 +62,8 @@ class FastScroller {
     private int mVisibleItem;
     private Paint mPaint;
     private int mListOffset;
+    private int mItemCount = -1;
+    private boolean mLongList;
     
     private Object [] mSections;
     private String mSectionText;
@@ -219,8 +221,12 @@ class FastScroller {
     
     void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, 
             int totalItemCount) {
-        // Are there enough pages to require fast scroll?
-        if (visibleItemCount > 0 && totalItemCount / visibleItemCount < MIN_PAGES) {
+        // Are there enough pages to require fast scroll? Recompute only if total count changes
+        if (mItemCount != totalItemCount && visibleItemCount > 0) {
+            mItemCount = totalItemCount;
+            mLongList = mItemCount / visibleItemCount >= MIN_PAGES;
+        }
+        if (!mLongList) {
             if (mState != STATE_NONE) {
                 setState(STATE_NONE);
             }
diff --git a/core/java/android/widget/GridView.java b/core/java/android/widget/GridView.java
index 6bbf062..11fab8f 100644
--- a/core/java/android/widget/GridView.java
+++ b/core/java/android/widget/GridView.java
@@ -929,6 +929,7 @@ public class GridView extends AbsListView {
             if (p == null) {
                 p = new AbsListView.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT,
                         ViewGroup.LayoutParams.WRAP_CONTENT, 0);
+                child.setLayoutParams(p);
             }
             p.viewType = mAdapter.getItemViewType(0);
 
@@ -1328,11 +1329,8 @@ public class GridView extends AbsListView {
      */
     @Override
     void setSelectionInt(int position) {
-        mBlockLayoutRequests = true;
         setNextSelectedPositionInt(position);
         layoutChildren();
-
-        mBlockLayoutRequests = false;
     }
 
     @Override
diff --git a/core/java/android/widget/ImageView.java b/core/java/android/widget/ImageView.java
index a4523b9..480b0b8 100644
--- a/core/java/android/widget/ImageView.java
+++ b/core/java/android/widget/ImageView.java
@@ -333,6 +333,12 @@ public class ImageView extends View {
         resizeFromDrawable();
     }
 
+    /**
+     * Sets the image level, when it is constructed from a 
+     * {@link android.graphics.drawable.LevelListDrawable}.
+     *
+     * @param level The new level for the image.
+     */
     @android.view.RemotableViewMethod
     public void setImageLevel(int level) {
         mLevel = level;
diff --git a/core/java/android/widget/ListView.java b/core/java/android/widget/ListView.java
index 404a4ee..c2f3a85 100644
--- a/core/java/android/widget/ListView.java
+++ b/core/java/android/widget/ListView.java
@@ -26,7 +26,6 @@ import android.os.Parcel;
 import android.os.Parcelable;
 import android.util.AttributeSet;
 import android.util.SparseBooleanArray;
-import android.util.SparseArray;
 import android.view.FocusFinder;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
@@ -1040,6 +1039,7 @@ public class ListView extends AbsListView {
         if (p == null) {
             p = new LayoutParams(ViewGroup.LayoutParams.FILL_PARENT,
                     ViewGroup.LayoutParams.WRAP_CONTENT, 0);
+            child.setLayoutParams(p);
         }
         p.viewType = mAdapter.getItemViewType(position);
 
@@ -1320,6 +1320,8 @@ public class ListView extends AbsListView {
         final boolean blockLayoutRequests = mBlockLayoutRequests;
         if (!blockLayoutRequests) {
             mBlockLayoutRequests = true;
+        } else {
+            return;
         }
 
         try {
@@ -1429,15 +1431,12 @@ public class ListView extends AbsListView {
                 // we can remember the focused view to restore after relayout if the
                 // data hasn't changed, or if the focused position is a header or footer
                 if (!dataChanged || isDirectChildHeaderOrFooter(focusedChild)) {
-                    focusLayoutRestoreDirectChild = getFocusedChild();
-                    if (focusLayoutRestoreDirectChild != null) {
-
-                        // remember the specific view that had focus
-                        focusLayoutRestoreView = findFocus();
-                        if (focusLayoutRestoreView != null) {
-                            // tell it we are going to mess with it
-                            focusLayoutRestoreView.onStartTemporaryDetach();
-                        }
+                    focusLayoutRestoreDirectChild = focusedChild;
+                    // remember the specific view that had focus
+                    focusLayoutRestoreView = findFocus();
+                    if (focusLayoutRestoreView != null) {
+                        // tell it we are going to mess with it
+                        focusLayoutRestoreView.onStartTemporaryDetach();
                     }
                 }
                 requestFocus();
@@ -1657,9 +1656,12 @@ public class ListView extends AbsListView {
         }
         p.viewType = mAdapter.getItemViewType(position);
 
-        if (recycled) {
+        if (recycled || (p.recycledHeaderFooter && p.viewType == AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER)) {
             attachViewToParent(child, flowDown ? -1 : 0, p);
         } else {
+            if (p.viewType == AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
+                p.recycledHeaderFooter = true;
+            }
             addViewInLayout(child, flowDown ? -1 : 0, p, true);
         }
 
@@ -1766,10 +1768,8 @@ public class ListView extends AbsListView {
      */
     @Override
     void setSelectionInt(int position) {
-        mBlockLayoutRequests = true;
         setNextSelectedPositionInt(position);
         layoutChildren();
-        mBlockLayoutRequests = false;
     }
 
     /**
diff --git a/core/java/android/widget/TextView.java b/core/java/android/widget/TextView.java
index 080f3de..3f4912f 100644
--- a/core/java/android/widget/TextView.java
+++ b/core/java/android/widget/TextView.java
@@ -33,6 +33,7 @@ import android.os.Bundle;
 import android.os.Handler;
 import android.os.Parcel;
 import android.os.Parcelable;
+import android.os.ResultReceiver;
 import android.os.SystemClock;
 import android.os.Message;
 import android.text.BoringLayout;
@@ -234,6 +235,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
     private CharWrapper mCharWrapper = null;
 
     private boolean mSelectionMoved = false;
+    private boolean mTouchFocusSelectedAll = false;
 
     private Marquee mMarquee;
     private boolean mRestartMarquee;
@@ -837,6 +839,11 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
         if (password) {
             setTransformationMethod(PasswordTransformationMethod.getInstance());
             typefaceIndex = MONOSPACE;
+        } else if ((mInputType&(EditorInfo.TYPE_MASK_CLASS
+                |EditorInfo.TYPE_MASK_VARIATION))
+                == (EditorInfo.TYPE_CLASS_TEXT
+                        |EditorInfo.TYPE_TEXT_VARIATION_PASSWORD)) {
+            typefaceIndex = MONOSPACE;
         }
 
         setTypefaceByIndex(typefaceIndex, styleIndex);
@@ -2244,6 +2251,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
         int selEnd;
         CharSequence text;
         boolean frozenWithFocus;
+        CharSequence error;
 
         SavedState(Parcelable superState) {
             super(superState);
@@ -2256,6 +2264,13 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
             out.writeInt(selEnd);
             out.writeInt(frozenWithFocus ? 1 : 0);
             TextUtils.writeToParcel(text, out, flags);
+
+            if (error == null) {
+                out.writeInt(0);
+            } else {
+                out.writeInt(1);
+                TextUtils.writeToParcel(error, out, flags);
+            }
         }
 
         @Override
@@ -2286,6 +2301,10 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
             selEnd = in.readInt();
             frozenWithFocus = (in.readInt() != 0);
             text = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
+
+            if (in.readInt() != 0) {
+                error = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
+            }
         }
     }
 
@@ -2338,6 +2357,8 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
                 ss.frozenWithFocus = true;
             }
 
+            ss.error = mError;
+
             return ss;
         }
 
@@ -2383,6 +2404,10 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
                 }
             }
         }
+
+        if (ss.error != null) {
+            setError(ss.error);
+        }
     }
 
     /**
@@ -2799,8 +2824,9 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
      */
     public void setInputType(int type) {
         setInputType(type, false);
-        final boolean isPassword = (type&(EditorInfo.TYPE_MASK_CLASS
-                |EditorInfo.TYPE_MASK_VARIATION))
+        final int variation = type&(EditorInfo.TYPE_MASK_CLASS
+                |EditorInfo.TYPE_MASK_VARIATION);
+        final boolean isPassword = variation
                 == (EditorInfo.TYPE_CLASS_TEXT
                         |EditorInfo.TYPE_TEXT_VARIATION_PASSWORD);
         boolean forceUpdate = false;
@@ -2809,8 +2835,14 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
             setTypefaceByIndex(MONOSPACE, 0);
         } else if (mTransformation == PasswordTransformationMethod.getInstance()) {
             // We need to clean up if we were previously in password mode.
-            setTypefaceByIndex(-1, -1);
+            if (variation != (EditorInfo.TYPE_CLASS_TEXT
+                        |EditorInfo.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD)) {
+                setTypefaceByIndex(-1, -1);
+            }
             forceUpdate = true;
+        } else if (variation == (EditorInfo.TYPE_CLASS_TEXT
+                        |EditorInfo.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD)) {
+            setTypefaceByIndex(MONOSPACE, 0);
         }
         
         boolean multiLine = (type&(EditorInfo.TYPE_MASK_CLASS
@@ -2999,23 +3031,28 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
                 }
             }
         }
-        
-        if (actionCode == EditorInfo.IME_ACTION_NEXT &&
-                (ict != null || !shouldAdvanceFocusOnEnter())) {
-            // This is the default handling for the NEXT action, to advance
-            // focus.  Note that for backwards compatibility we don't do this
+        if (ict != null || !shouldAdvanceFocusOnEnter()) {
+            // This is the handling for some default action.
+            // Note that for backwards compatibility we don't do this
             // default handling if explicit ime options have not been given,
-            // and we do not advance by default on an enter key -- in that
-            // case, we want to turn this into the normal enter key codes that
-            // an app may be expecting.
-            View v = focusSearch(FOCUS_DOWN);
-            if (v != null) {
-                if (!v.requestFocus(FOCUS_DOWN)) {
-                    throw new IllegalStateException("focus search returned a view " +
-                            "that wasn't able to take focus!");
+            // to instead turn this into the normal enter key codes that an
+            // app may be expecting.
+            if (actionCode == EditorInfo.IME_ACTION_NEXT) {
+                View v = focusSearch(FOCUS_DOWN);
+                if (v != null) {
+                    if (!v.requestFocus(FOCUS_DOWN)) {
+                        throw new IllegalStateException("focus search returned a view " +
+                                "that wasn't able to take focus!");
+                    }
+                }
+                return;
+                
+            } else if (actionCode == EditorInfo.IME_ACTION_DONE) {
+                InputMethodManager imm = InputMethodManager.peekInstance();
+                if (imm != null) {
+                    imm.hideSoftInputFromWindow(getWindowToken(), 0);
                 }
             }
-            return;
         }
         
         Handler h = getHandler();
@@ -3998,7 +4035,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
      * but also in mail addresses and subjects which will display on multiple
      * lines but where it doesn't make sense to insert newlines.
      */
-    protected boolean shouldAdvanceFocusOnEnter() {
+    private boolean shouldAdvanceFocusOnEnter() {
         if (mInput == null) {
             return false;
         }
@@ -4192,6 +4229,14 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
                              */
                             super.onKeyUp(keyCode, event);
                             return true;
+                        } else if ((event.getFlags()
+                                & KeyEvent.FLAG_SOFT_KEYBOARD) != 0) {
+                            // No target for next focus, but make sure the IME
+                            // if this came from it.
+                            InputMethodManager imm = InputMethodManager.peekInstance();
+                            if (imm != null) {
+                                imm.hideSoftInputFromWindow(getWindowToken(), 0);
+                            }
                         }
                     }
 
@@ -4234,9 +4279,13 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
                     // An action has not been set, but the enter key will move to
                     // the next focus, so set the action to that.
                     outAttrs.imeOptions = EditorInfo.IME_ACTION_NEXT;
-                    if (!shouldAdvanceFocusOnEnter()) {
-                        outAttrs.imeOptions |= EditorInfo.IME_FLAG_NO_ENTER_ACTION;
-                    }
+                } else {
+                    // An action has not been set, and there is no focus to move
+                    // to, so let's just supply a "done" action.
+                    outAttrs.imeOptions = EditorInfo.IME_ACTION_DONE;
+                }
+                if (!shouldAdvanceFocusOnEnter()) {
+                    outAttrs.imeOptions |= EditorInfo.IME_FLAG_NO_ENTER_ACTION;
                 }
             }
             outAttrs.hintText = mHint;
@@ -5977,6 +6026,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
 
                 if (mSelectAllOnFocus) {
                     Selection.setSelection((Spannable) mText, 0, mText.length());
+                    mTouchFocusSelectedAll = true;
                 }
 
                 if (selMoved && selStart >= 0 && selEnd >= 0) {
@@ -6078,12 +6128,32 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
         }
     }
 
+    class CommitSelectionReceiver extends ResultReceiver {
+        int mNewStart;
+        int mNewEnd;
+        
+        CommitSelectionReceiver() {
+            super(getHandler());
+        }
+        
+        protected void onReceiveResult(int resultCode, Bundle resultData) {
+            if (resultCode != InputMethodManager.RESULT_SHOWN) {
+                Selection.setSelection((Spannable)mText, mNewStart, mNewEnd);
+            }
+        }
+    }
+    
     @Override
     public boolean onTouchEvent(MotionEvent event) {
-        final boolean superResult = super.onTouchEvent(event);
-
         final int action = event.getAction();
+        if (action == MotionEvent.ACTION_DOWN) {
+            // Reset this state; it will be re-set if super.onTouchEvent
+            // causes focus to move to the view.
+            mTouchFocusSelectedAll = false;
+        }
         
+        final boolean superResult = super.onTouchEvent(event);
+
         /*
          * Don't handle the release after a long press, because it will
          * move the selection away from whatever the menu action was
@@ -6100,17 +6170,44 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
                 mScrolled = false;
             }
             
-            boolean moved = mMovement.onTouchEvent(this, (Spannable) mText, event);
+            boolean handled = false;
+            
+            int oldSelStart = Selection.getSelectionStart(mText);
+            int oldSelEnd = Selection.getSelectionEnd(mText);
+            
+            handled |= mMovement.onTouchEvent(this, (Spannable) mText, event);
 
             if (mText instanceof Editable && onCheckIsTextEditor()) {
                 if (action == MotionEvent.ACTION_UP && isFocused() && !mScrolled) {
                     InputMethodManager imm = (InputMethodManager)
                             getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
-                    imm.showSoftInput(this, 0);
+                    
+                    // This is going to be gross...  if tapping on the text view
+                    // causes the IME to be displayed, we don't want the selection
+                    // to change.  But the selection has already changed, and
+                    // we won't know right away whether the IME is getting
+                    // displayed, so...
+                    
+                    int newSelStart = Selection.getSelectionStart(mText);
+                    int newSelEnd = Selection.getSelectionEnd(mText);
+                    CommitSelectionReceiver csr = null;
+                    if (newSelStart != oldSelStart || newSelEnd != oldSelEnd) {
+                        csr = new CommitSelectionReceiver();
+                        csr.mNewStart = newSelStart;
+                        csr.mNewEnd = newSelEnd;
+                    }
+                    
+                    if (imm.showSoftInput(this, 0, csr) && csr != null) {
+                        // The IME might get shown -- revert to the old
+                        // selection, and change to the new when we finally
+                        // find out of it is okay.
+                        Selection.setSelection((Spannable)mText, oldSelStart, oldSelEnd);
+                        handled = true;
+                    }
                 }
             }
 
-            if (moved) {
+            if (handled) {
                 return true;
             }
         }
@@ -6118,6 +6215,15 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
         return superResult;
     }
 
+    /**
+     * Returns true, only while processing a touch gesture, if the initial
+     * touch down event caused focus to move to the text view and as a result
+     * it selected all of its text.
+     */
+    public boolean didTouchFocusSelectAll() {
+        return mTouchFocusSelectedAll;
+    }
+    
     @Override
     public void cancelLongPress() {
         super.cancelLongPress();
diff --git a/core/java/android/widget/ZoomRing.java b/core/java/android/widget/ZoomRing.java
index a5a867b..83a1225 100644
--- a/core/java/android/widget/ZoomRing.java
+++ b/core/java/android/widget/ZoomRing.java
@@ -1,9 +1,26 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package android.widget;
 
 import com.android.internal.R;
 
 import android.content.Context;
 import android.content.res.Resources;
+import android.content.res.TypedArray;
 import android.graphics.Canvas;
 import android.graphics.drawable.Drawable;
 import android.graphics.drawable.RotateDrawable;
@@ -18,36 +35,47 @@ import android.view.View;
 import android.view.ViewConfiguration;
 
 /**
+ * A view that has a draggable thumb on a circle.
+ * 
  * @hide
  */
 public class ZoomRing extends View {
-
-    // TODO: move to ViewConfiguration?
-    static final int DOUBLE_TAP_DISMISS_TIMEOUT = ViewConfiguration.getDoubleTapTimeout();
-    // TODO: get from theme
     private static final String TAG = "ZoomRing";
 
     // TODO: Temporary until the trail is done
     private static final boolean DRAW_TRAIL = false;
 
-    // TODO: xml
-    private static final int THUMB_DISTANCE = 63;
-
-    /** To avoid floating point calculations, we multiply radians by this value. */
+    /**
+     * To avoid floating point calculations and int round-offs, we multiply
+     * radians by this value.
+     */
     public static final int RADIAN_INT_MULTIPLIER = 10000;
+    /** The allowable margin of error when comparing two angles. */
     public static final int RADIAN_INT_ERROR = 100;
-    /** PI using our multiplier. */
     public static final int PI_INT_MULTIPLIED = (int) (Math.PI * RADIAN_INT_MULTIPLIER);
     public static final int TWO_PI_INT_MULTIPLIED = PI_INT_MULTIPLIED * 2;
-    /** PI/2 using our multiplier. */
     private static final int HALF_PI_INT_MULTIPLIED = PI_INT_MULTIPLIED / 2;
 
-    private int mZeroAngle = HALF_PI_INT_MULTIPLIED * 3;
-    
+    private static final int DOUBLE_TAP_DISMISS_TIMEOUT = ViewConfiguration.getDoubleTapTimeout();
+    private final int mTouchSlop;
+
+    /** The slop when the user is grabbing the thumb. */
     private static final int THUMB_GRAB_SLOP = PI_INT_MULTIPLIED / 8;
+    /** The slop until a user starts dragging the thumb. */
     private static final int THUMB_DRAG_SLOP = PI_INT_MULTIPLIED / 12;
 
+    /** The distance (in px) from the center of the ring to the center of the thumb. */ 
+    private int mThumbDistance;
+
+    /** The angle on a unit circle that is considered to be the zoom ring's 0 degree. */
+    private int mZeroAngle = HALF_PI_INT_MULTIPLIED * 3;
+
     /**
+     * The maximum delta angle that the thumb can move. The primary use is to
+     * ensure that when a user taps on the ring, the movement to reach that
+     * target angle is not ambiguous (for example, if the thumb is at 0 and he
+     * taps 180, should the thumb go clockwise or counterclockwise?
+     * <p>
      * Includes error because we compare this to the result of
      * getDelta(getClosestTickeAngle(..), oldAngle) which ends up having some
      * rounding error.
@@ -55,58 +83,93 @@ public class ZoomRing extends View {
     private static final int MAX_ABS_JUMP_DELTA_ANGLE = (2 * PI_INT_MULTIPLIED / 3) +
             RADIAN_INT_ERROR; 
 
-    /** The cached X of our center. */
+    /** The cached X of the zoom ring's center (in zoom ring coordinates). */
     private int mCenterX;
-    /** The cached Y of our center. */
+    /** The cached Y of the zoom ring's center (in zoom ring coordinates). */
     private int mCenterY;
 
     /** The angle of the thumb (in int radians) */
     private int mThumbAngle;
+    /** The cached width/2 of the zoom ring. */
     private int mThumbHalfWidth;
+    /** The cached height/2 of the zoom ring. */
     private int mThumbHalfHeight;
     
+    /**
+     * The bound for the thumb's movement when it is being dragged clockwise.
+     * Can be Integer.MIN_VALUE if there is no bound in this direction.
+     */
     private int mThumbCwBound = Integer.MIN_VALUE;
+    /**
+     * The bound for the thumb's movement when it is being dragged
+     * counterclockwise. Can be Integer.MIN_VALUE if there is no bound in this
+     * direction.
+     */
     private int mThumbCcwBound = Integer.MIN_VALUE;
+    
+    /**
+     * Whether to enforce the maximum absolute jump delta. See
+     * {@link #MAX_ABS_JUMP_DELTA_ANGLE}.
+     */
     private boolean mEnforceMaxAbsJump = true;
     
     /** The inner radius of the track. */
-    private int mBoundInnerRadiusSquared = 0;
+    private int mTrackInnerRadius;
+    /** Cached square of the inner radius of the track. */
+    private int mTrackInnerRadiusSquared;
     /** The outer radius of the track. */
-    private int mBoundOuterRadiusSquared = Integer.MAX_VALUE;
+    private int mTrackOuterRadius;
+    /** Cached square of the outer radius of the track. */
+    private int mTrackOuterRadiusSquared;
 
+    /** The raw X of where the widget previously was located. */
     private int mPreviousWidgetDragX;
+    /** The raw Y of where the widget previously was located. */
     private int mPreviousWidgetDragY;
 
+    /** Whether the thumb should be visible. */
     private boolean mThumbVisible = true;
+    
+    /** The drawable for the thumb. */
     private Drawable mThumbDrawable;
     
     /** Shown beneath the thumb if we can still zoom in. */
-    private Drawable mThumbPlusArrowDrawable;
+    private Drawable mZoomInArrowDrawable;
     /** Shown beneath the thumb if we can still zoom out. */
-    private Drawable mThumbMinusArrowDrawable;
+    private Drawable mZoomOutArrowDrawable;
+    
+    /** @see #mThumbArrowsToDraw */
     private static final int THUMB_ARROW_PLUS = 1 << 0;
+    /** @see #mThumbArrowsToDraw */
     private static final int THUMB_ARROW_MINUS = 1 << 1;
     /** Bitwise-OR of {@link #THUMB_ARROW_MINUS} and {@link #THUMB_ARROW_PLUS} */
     private int mThumbArrowsToDraw;
+    
+    /** The duration for the thumb arrows fading out */
     private static final int THUMB_ARROWS_FADE_DURATION = 300;
+    /** The time when the fade out started. */
     private long mThumbArrowsFadeStartTime;
+    /** The current alpha for the thumb arrows. */
     private int mThumbArrowsAlpha = 255;
 
-    private static final int THUMB_PLUS_MINUS_DISTANCE = 69;
-    private static final int THUMB_PLUS_MINUS_OFFSET_ANGLE = TWO_PI_INT_MULTIPLIED / 11;
+    /** The distance from the center to the zoom arrow hints (usually plus and minus). */
+    private int mZoomArrowHintDistance;
+    /** The offset angle from the thumb angle to draw the zoom arrow hints. */
+    private int mZoomArrowHintOffsetAngle = TWO_PI_INT_MULTIPLIED / 11;
     /** Drawn (without rotation) on top of the arrow. */
-    private Drawable mThumbPlusDrawable;
+    private Drawable mZoomInArrowHintDrawable;
     /** Drawn (without rotation) on top of the arrow. */
-    private Drawable mThumbMinusDrawable;
+    private Drawable mZoomOutArrowHintDrawable;
     
+    /** Zoom ring is just chillin' */
     private static final int MODE_IDLE = 0;
-
     /**
      * User has his finger down somewhere on the ring (besides the thumb) and we
      * are waiting for him to move the slop amount before considering him in the
      * drag thumb state.
      */
     private static final int MODE_WAITING_FOR_DRAG_THUMB_AFTER_JUMP = 5;
+    /** User is dragging the thumb. */
     private static final int MODE_DRAG_THUMB = 1;
     /**
      * User has his finger down, but we are waiting for him to pass the touch
@@ -114,51 +177,65 @@ public class ZoomRing extends View {
      * show the movable hint.
      */
     private static final int MODE_WAITING_FOR_MOVE_ZOOM_RING = 4;
+    /** User is moving the zoom ring. */
     private static final int MODE_MOVE_ZOOM_RING = 2;
+    /** User is dragging the thumb via tap-drag. */
     private static final int MODE_TAP_DRAG = 3;
     /** Ignore the touch interaction until the user touches the thumb again. */
     private static final int MODE_IGNORE_UNTIL_TOUCHES_THUMB = 6;
+    /** The current mode of interaction. */
     private int mMode;
-    
     /** Records the last mode the user was in. */
     private int mPreviousMode;
-    
+
+    /** The previous time of the up-touch on the center. */
     private long mPreviousCenterUpTime;
+    /** The previous X of down-touch. */
     private int mPreviousDownX;
+    /** The previous Y of down-touch. */
     private int mPreviousDownY;
 
-    private int mWaitingForDragThumbDownAngle;
+    /** The angle where the user first grabbed the thumb. */
+    private int mInitialGrabThumbAngle;
     
+    /** The callback. */
     private OnZoomRingCallback mCallback;
-    private int mPreviousCallbackAngle;
-    private int mCallbackThreshold = Integer.MAX_VALUE;
+    /** The tick angle that we previously called back with. */
+    private int mPreviousCallbackTickAngle;
+    /** The delta angle between ticks.  A tick is a callback point. */
+    private int mTickDelta = Integer.MAX_VALUE;
     /** If the user drags to within __% of a tick, snap to that tick. */
-    private int mFuzzyCallbackThreshold = Integer.MAX_VALUE;
+    private int mFuzzyTickDelta = Integer.MAX_VALUE;
     
-    private boolean mResetThumbAutomatically = true;
+    /** The angle where the thumb is officially starting to be dragged. */
     private int mThumbDragStartAngle;
 
-    private final int mTouchSlop;
-
+    /** The drawable for the zoom trail. */
     private Drawable mTrail;
+    /** The accumulated angle for the trail. */
     private double mAcculumalatedTrailAngle;
     
+    /** The animation-step tracker for scrolling the thumb to a particular position. */
     private Scroller mThumbScroller;
 
+    /** Whether to ever vibrate when passing a tick. */
     private boolean mVibration = true;
     
-    private static final int MSG_THUMB_SCROLLER_TICK = 1;
-    private static final int MSG_THUMB_ARROWS_FADE_TICK = 2;
+    /** The drawable used to hint that this can pan its owner. */
+    private Drawable mPanningArrowsDrawable;
+    
+    private static final int MSG_THUMB_SCROLLER_STEP = 1;
+    private static final int MSG_THUMB_ARROWS_FADE_STEP = 2;
     private Handler mHandler = new Handler() {
         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
-                case MSG_THUMB_SCROLLER_TICK:
-                    onThumbScrollerTick();
+                case MSG_THUMB_SCROLLER_STEP:
+                    onThumbScrollerStep();
                     break;
                     
-                case MSG_THUMB_ARROWS_FADE_TICK:
-                    onThumbArrowsFadeTick();
+                case MSG_THUMB_ARROWS_FADE_STEP:
+                    onThumbArrowsFadeStep();
                     break;
             }
         }
@@ -170,50 +247,64 @@ public class ZoomRing extends View {
         ViewConfiguration viewConfiguration = ViewConfiguration.get(context);
         mTouchSlop = viewConfiguration.getScaledTouchSlop();
 
-        // TODO get drawables from style instead
+        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.ZoomRing, defStyle, 0);
+        mThumbDistance = (int) a.getDimension(R.styleable.ZoomRing_thumbDistance, 0);
+        setTrackRadii(
+                (int) a.getDimension(R.styleable.ZoomRing_trackInnerRadius, 0),
+                (int) a.getDimension(R.styleable.ZoomRing_trackOuterRadius, Integer.MAX_VALUE));
+        mThumbDrawable = a.getDrawable(R.styleable.ZoomRing_thumbDrawable);
+        mZoomInArrowDrawable = a.getDrawable(R.styleable.ZoomRing_zoomInArrowDrawable);
+        mZoomOutArrowDrawable = a.getDrawable(R.styleable.ZoomRing_zoomOutArrowDrawable);
+        mZoomInArrowHintDrawable = a.getDrawable(R.styleable.ZoomRing_zoomInArrowHintDrawable);
+        mZoomOutArrowHintDrawable = a.getDrawable(R.styleable.ZoomRing_zoomOutArrowHintDrawable);
+        mZoomArrowHintDistance =
+                (int) a.getDimension(R.styleable.ZoomRing_zoomArrowHintDistance, 0);
+        mZoomArrowHintOffsetAngle =
+                (int) (a.getInteger(R.styleable.ZoomRing_zoomArrowHintOffsetAngle, 0)
+                        * TWO_PI_INT_MULTIPLIED / 360);
+        mPanningArrowsDrawable = a.getDrawable(R.styleable.ZoomRing_panningArrowsDrawable);
+        a.recycle();
+        
         Resources res = context.getResources();
-        mThumbDrawable = res.getDrawable(R.drawable.zoom_ring_thumb);
-        mThumbPlusArrowDrawable = res.getDrawable(R.drawable.zoom_ring_thumb_plus_arrow_rotatable).
-                mutate();
-        mThumbMinusArrowDrawable = res.getDrawable(R.drawable.zoom_ring_thumb_minus_arrow_rotatable).
-                mutate();
-        mThumbPlusDrawable = res.getDrawable(R.drawable.zoom_ring_thumb_plus);
-        mThumbMinusDrawable = res.getDrawable(R.drawable.zoom_ring_thumb_minus);
         if (DRAW_TRAIL) {
+            // TODO get drawables from style instead
             mTrail = res.getDrawable(R.drawable.zoom_ring_trail).mutate();
         }
 
-        // TODO: add padding to drawable
-        setBackgroundResource(R.drawable.zoom_ring_track);
-        // TODO get from style
-        setRingBounds(43, Integer.MAX_VALUE);
-
         mThumbHalfHeight = mThumbDrawable.getIntrinsicHeight() / 2;
         mThumbHalfWidth = mThumbDrawable.getIntrinsicWidth() / 2;
 
-        setCallbackThreshold(PI_INT_MULTIPLIED / 6);
+        setTickDelta(PI_INT_MULTIPLIED / 6);
     }
 
     public ZoomRing(Context context, AttributeSet attrs) {
-        this(context, attrs, 0);
+        this(context, attrs, com.android.internal.R.attr.zoomRingStyle);
     }
 
     public ZoomRing(Context context) {
         this(context, null);
     }
 
+    public void setTrackDrawable(Drawable drawable) {
+        setBackgroundDrawable(drawable);
+    }
+    
     public void setCallback(OnZoomRingCallback callback) {
         mCallback = callback;
     }
 
-    // TODO: rename
-    public void setCallbackThreshold(int callbackThreshold) {
-        mCallbackThreshold = callbackThreshold;
-        mFuzzyCallbackThreshold = (int) (callbackThreshold * 0.65f);
+    /**
+     * Sets the distance between ticks.  This will be used as a callback threshold.
+     * 
+     * @param angle The angle between ticks.
+     */
+    public void setTickDelta(int angle) {
+        mTickDelta = angle;
+        mFuzzyTickDelta = (int) (angle * 0.65f);
     }
 
-    public void setVibration(boolean vibrate) {
-        mVibration = vibrate;
+    public void setVibration(boolean vibration) {
+        mVibration = vibration;
     }
     
     public void setThumbVisible(boolean thumbVisible) {
@@ -223,28 +314,42 @@ public class ZoomRing extends View {
         }
     }
     
-    // TODO: from XML too
-    public void setRingBounds(int innerRadius, int outerRadius) {
-        mBoundInnerRadiusSquared = innerRadius * innerRadius;
-        if (mBoundInnerRadiusSquared < innerRadius) {
+    public Drawable getPanningArrowsDrawable() {
+        return mPanningArrowsDrawable;
+    }
+    
+    public void setTrackRadii(int innerRadius, int outerRadius) {
+        mTrackInnerRadius = innerRadius;
+        mTrackOuterRadius = outerRadius;
+        
+        mTrackInnerRadiusSquared = innerRadius * innerRadius;
+        if (mTrackInnerRadiusSquared < innerRadius) {
             // Prevent overflow
-            mBoundInnerRadiusSquared = Integer.MAX_VALUE;
+            mTrackInnerRadiusSquared = Integer.MAX_VALUE;
         }
 
-        mBoundOuterRadiusSquared = outerRadius * outerRadius;
-        if (mBoundOuterRadiusSquared < outerRadius) {
+        mTrackOuterRadiusSquared = outerRadius * outerRadius;
+        if (mTrackOuterRadiusSquared < outerRadius) {
             // Prevent overflow
-            mBoundOuterRadiusSquared = Integer.MAX_VALUE;
+            mTrackOuterRadiusSquared = Integer.MAX_VALUE;
         }
     }
 
+    public int getTrackInnerRadius() {
+        return mTrackInnerRadius;
+    }
+    
+    public int getTrackOuterRadius() {
+        return mTrackOuterRadius;
+    }
+    
     public void setThumbClockwiseBound(int angle) {
         if (angle < 0) {
             mThumbCwBound = Integer.MIN_VALUE;
         } else {
             mThumbCwBound = getClosestTickAngle(angle);
         }
-        setEnforceMaxAbsJump();
+        updateEnforceMaxAbsJump();
     }
     
     public void setThumbCounterclockwiseBound(int angle) {
@@ -253,14 +358,14 @@ public class ZoomRing extends View {
         } else {
             mThumbCcwBound = getClosestTickAngle(angle);
         }
-        setEnforceMaxAbsJump();
+        updateEnforceMaxAbsJump();
     }
     
-    private void setEnforceMaxAbsJump() {
+    private void updateEnforceMaxAbsJump() {
         // If there are bounds in both direction, there is no reason to restrict
         // the amount that a user can absolute jump to
         mEnforceMaxAbsJump =
-            mThumbCcwBound == Integer.MIN_VALUE || mThumbCwBound == Integer.MIN_VALUE;
+                mThumbCcwBound == Integer.MIN_VALUE || mThumbCwBound == Integer.MIN_VALUE;
     }
     
     public int getThumbAngle() {
@@ -269,7 +374,7 @@ public class ZoomRing extends View {
     
     public void setThumbAngle(int angle) {
         angle = getValidAngle(angle);
-        mPreviousCallbackAngle = getClosestTickAngle(angle);
+        mPreviousCallbackTickAngle = getClosestTickAngle(angle);
         setThumbAngleAuto(angle, false, false);
     }
     
@@ -299,9 +404,9 @@ public class ZoomRing extends View {
         mThumbAngle = angle;
         int unoffsetAngle = angle + mZeroAngle;
         int thumbCenterX = (int) (Math.cos(1f * unoffsetAngle / RADIAN_INT_MULTIPLIER) *
-                THUMB_DISTANCE) + mCenterX;
+                mThumbDistance) + mCenterX;
         int thumbCenterY = (int) (Math.sin(1f * unoffsetAngle / RADIAN_INT_MULTIPLIER) *
-                THUMB_DISTANCE) * -1 + mCenterY;
+                mThumbDistance) * -1 + mCenterY;
 
         mThumbDrawable.setBounds(thumbCenterX - mThumbHalfWidth,
                 thumbCenterY - mThumbHalfHeight,
@@ -356,7 +461,7 @@ public class ZoomRing extends View {
             duration = getAnimationDuration(deltaAngle);
         }
         mThumbScroller.startScroll(startAngle, 0, deltaAngle, 0, duration);
-        onThumbScrollerTick();
+        onThumbScrollerStep();
     }
     
     private int getAnimationDuration(int deltaAngle) {
@@ -364,10 +469,10 @@ public class ZoomRing extends View {
         return 300 + deltaAngle * 300 / RADIAN_INT_MULTIPLIER; 
     }
     
-    private void onThumbScrollerTick() {
+    private void onThumbScrollerStep() {
         if (!mThumbScroller.computeScrollOffset()) return;
         setThumbAngleInt(getThumbScrollerAngle());        
-        mHandler.sendEmptyMessage(MSG_THUMB_SCROLLER_TICK);
+        mHandler.sendEmptyMessage(MSG_THUMB_SCROLLER_STEP);
     }
 
     private int getThumbScrollerAngle() {
@@ -375,16 +480,10 @@ public class ZoomRing extends View {
     }
     
     public void resetThumbAngle() {
-        if (mResetThumbAutomatically) {
-            mPreviousCallbackAngle = 0;
-            setThumbAngleInt(0);
-        }
+        mPreviousCallbackTickAngle = 0;
+        setThumbAngleInt(0);
     }
     
-    public void setResetThumbAutomatically(boolean resetThumbAutomatically) {
-        mResetThumbAutomatically = resetThumbAutomatically;
-    }
-
     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         setMeasuredDimension(resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec),
@@ -411,14 +510,12 @@ public class ZoomRing extends View {
         }
         
         // These drawables are the same size as the track
-        mThumbPlusArrowDrawable.setBounds(0, 0, right - left, bottom - top);
-        mThumbMinusArrowDrawable.setBounds(0, 0, right - left, bottom - top);
+        mZoomInArrowDrawable.setBounds(0, 0, right - left, bottom - top);
+        mZoomOutArrowDrawable.setBounds(0, 0, right - left, bottom - top);
     }
 
     @Override
     public boolean onTouchEvent(MotionEvent event) {
-//        Log.d(TAG, "History size: " + event.getHistorySize());
-        
         return handleTouch(event.getAction(), event.getEventTime(),
                 (int) event.getX(), (int) event.getY(), (int) event.getRawX(),
                 (int) event.getRawY());
@@ -457,15 +554,10 @@ public class ZoomRing extends View {
         boolean isTouchingRing = mThumbVisible;
         
         int touchAngle = getAngle(localX, localY);
-//        printAngle("touchAngle", touchAngle);
-//        printAngle("mThumbAngle", mThumbAngle);
-//        printAngle("mPreviousCallbackAngle", mPreviousCallbackAngle);
-//        Log.d(TAG, "");
-        		
         
         int radiusSquared = localX * localX + localY * localY;
-        if (radiusSquared < mBoundInnerRadiusSquared ||
-                radiusSquared > mBoundOuterRadiusSquared) {
+        if (radiusSquared < mTrackInnerRadiusSquared ||
+                radiusSquared > mTrackOuterRadiusSquared) {
             // Out-of-bounds
             isTouchingThumb = false;
             isTouchingRing = false;
@@ -486,7 +578,7 @@ public class ZoomRing extends View {
                 if (!isTouchingRing &&
                         (time - mPreviousCenterUpTime <= DOUBLE_TAP_DISMISS_TIMEOUT)) {
                     // Make sure the double-tap is in the center of the widget (and not on the ring)
-                    mCallback.onZoomRingDismissed(true);
+                    mCallback.onZoomRingDismissed();
                     onTouchUp(time, isTouchingRing);
                     
                     // Dismissing, so halt here
@@ -557,7 +649,7 @@ public class ZoomRing extends View {
                 }
 
                 setMode(MODE_WAITING_FOR_DRAG_THUMB_AFTER_JUMP);
-                mWaitingForDragThumbDownAngle = touchAngle;
+                mInitialGrabThumbAngle = touchAngle;
                 boolean ccw = deltaThumbAndTick > 0;
                 setThumbAngleAnimated(tickAngle, 0, ccw);
                 
@@ -577,9 +669,9 @@ public class ZoomRing extends View {
             }
 
         } else if (mMode == MODE_WAITING_FOR_DRAG_THUMB_AFTER_JUMP) {
-            int deltaDownAngle = getDelta(mWaitingForDragThumbDownAngle, touchAngle);
+            int deltaDownAngle = getDelta(mInitialGrabThumbAngle, touchAngle);
             if ((deltaDownAngle < -THUMB_DRAG_SLOP || deltaDownAngle > THUMB_DRAG_SLOP) &&
-                    isDeltaInBounds(mWaitingForDragThumbDownAngle, deltaDownAngle)) {
+                    isDeltaInBounds(mInitialGrabThumbAngle, deltaDownAngle)) {
                 setMode(MODE_DRAG_THUMB);
                 
                 // No need to call onThumbDragStarted, since that was done when they tapped-to-jump
@@ -591,6 +683,8 @@ public class ZoomRing extends View {
                 /* Make sure the user has moved the slop amount before going into that mode. */
                 setMode(MODE_MOVE_ZOOM_RING);
                 mCallback.onZoomRingMovingStarted();
+                // Move the zoom ring so it is under the finger where the user first touched
+                mCallback.onZoomRingMoved(x - mPreviousDownX, y - mPreviousDownY, rawX, rawY);
             }
         } else if (mMode == MODE_IGNORE_UNTIL_TOUCHES_THUMB) {
             if (isTouchingThumb) {
@@ -629,7 +723,7 @@ public class ZoomRing extends View {
             
             if (mode == MODE_DRAG_THUMB || mode == MODE_TAP_DRAG) {
                 // Animate back to a tick
-                setThumbAngleAnimated(mPreviousCallbackAngle, 0);
+                setThumbAngleAnimated(mPreviousCallbackTickAngle, 0);
             }
         }
         mCallback.onUserInteractionStopped();
@@ -741,9 +835,9 @@ public class ZoomRing extends View {
         boolean animateThumbToNewAngle = false;
         
         int totalDeltaAngle;
-        totalDeltaAngle = getDelta(mPreviousCallbackAngle, touchAngle, useDirection, ccw);
-        if (totalDeltaAngle >= mFuzzyCallbackThreshold
-                || totalDeltaAngle <= -mFuzzyCallbackThreshold) {
+        totalDeltaAngle = getDelta(mPreviousCallbackTickAngle, touchAngle, useDirection, ccw);
+        if (totalDeltaAngle >= mFuzzyTickDelta
+                || totalDeltaAngle <= -mFuzzyTickDelta) {
 
             if (!useDirection) {
                 // Set ccw to match the direction found by getDelta
@@ -763,9 +857,9 @@ public class ZoomRing extends View {
             if (ccw && mThumbCcwBound != Integer.MIN_VALUE) {
                 int deltaCcwBoundAndTouch =
                         getDelta(mThumbCcwBound, touchAngle, useDirection, true);
-                if (deltaCcwBoundAndTouch >= mCallbackThreshold / 2) {
+                if (deltaCcwBoundAndTouch >= mTickDelta / 2) {
                     // The touch has past a bound
-                    int deltaPreviousCbAndTouch = getDelta(mPreviousCallbackAngle,
+                    int deltaPreviousCbAndTouch = getDelta(mPreviousCallbackTickAngle,
                             touchAngle, useDirection, true);
                     if (deltaPreviousCbAndTouch >= deltaCcwBoundAndTouch) {
                         // The bound is between the previous callback angle and the touch
@@ -778,8 +872,8 @@ public class ZoomRing extends View {
                 // See block above for general comments
                 int deltaCwBoundAndTouch =
                         getDelta(mThumbCwBound, touchAngle, useDirection, false);
-                if (deltaCwBoundAndTouch <= -mCallbackThreshold / 2) {
-                    int deltaPreviousCbAndTouch = getDelta(mPreviousCallbackAngle,
+                if (deltaCwBoundAndTouch <= -mTickDelta / 2) {
+                    int deltaPreviousCbAndTouch = getDelta(mPreviousCallbackTickAngle,
                             touchAngle, useDirection, false);
                     /*
                      * Both of these will be negative since we got delta in
@@ -795,7 +889,7 @@ public class ZoomRing extends View {
             }
             if (touchAngle != oldTouchAngle) {
                 // We bounded the touch angle
-                totalDeltaAngle = getDelta(mPreviousCallbackAngle, touchAngle, useDirection, ccw);
+                totalDeltaAngle = getDelta(mPreviousCallbackTickAngle, touchAngle, useDirection, ccw);
                 animateThumbToNewAngle = true;
                 setMode(MODE_IGNORE_UNTIL_TOUCHES_THUMB);
             }
@@ -819,7 +913,7 @@ public class ZoomRing extends View {
              * hit. If we do int division, we'll end up with one level lower
              * than the one he was going for.
              */
-            int deltaLevels = Math.round((float) totalDeltaAngle / mCallbackThreshold); 
+            int deltaLevels = Math.round((float) totalDeltaAngle / mTickDelta); 
             if (deltaLevels != 0) {
                 boolean canStillZoom = mCallback.onZoomRingThumbDragged(
                         deltaLevels, mThumbDragStartAngle, touchAngle);
@@ -833,8 +927,8 @@ public class ZoomRing extends View {
                 }
                 
                 // Set the callback angle to the actual angle based on how many delta levels we gave
-                mPreviousCallbackAngle = getValidAngle(
-                        mPreviousCallbackAngle + (deltaLevels * mCallbackThreshold));
+                mPreviousCallbackTickAngle = getValidAngle(
+                        mPreviousCallbackTickAngle + (deltaLevels * mTickDelta));
             }
         }
 
@@ -993,14 +1087,14 @@ public class ZoomRing extends View {
     }
 
     private int getClosestTickAngle(int angle) {
-        int smallerAngleDistance = angle % mCallbackThreshold;
+        int smallerAngleDistance = angle % mTickDelta;
         int smallerAngle = angle - smallerAngleDistance;
-        if (smallerAngleDistance < mCallbackThreshold / 2) {
+        if (smallerAngleDistance < mTickDelta / 2) {
             // Closer to the smaller angle
             return smallerAngle;
         } else {
             // Closer to the bigger angle (premodding)
-            return (smallerAngle + mCallbackThreshold) % TWO_PI_INT_MULTIPLIED; 
+            return (smallerAngle + mTickDelta) % TWO_PI_INT_MULTIPLIED; 
         }
     }
 
@@ -1025,7 +1119,7 @@ public class ZoomRing extends View {
         super.onWindowFocusChanged(hasWindowFocus);
 
         if (!hasWindowFocus) {
-            mCallback.onZoomRingDismissed(true);
+            mCallback.onZoomRingDismissed();
         }
     }
     
@@ -1054,12 +1148,12 @@ public class ZoomRing extends View {
                 mTrail.draw(canvas);
             }
             if ((mThumbArrowsToDraw & THUMB_ARROW_PLUS) != 0) {
-                mThumbPlusArrowDrawable.draw(canvas);
-                mThumbPlusDrawable.draw(canvas);
+                mZoomInArrowDrawable.draw(canvas);
+                mZoomInArrowHintDrawable.draw(canvas);
             }
             if ((mThumbArrowsToDraw & THUMB_ARROW_MINUS) != 0) {
-                mThumbMinusArrowDrawable.draw(canvas);
-                mThumbMinusDrawable.draw(canvas);
+                mZoomOutArrowDrawable.draw(canvas);
+                mZoomOutArrowHintDrawable.draw(canvas);
             }
             mThumbDrawable.draw(canvas);
         }
@@ -1067,48 +1161,48 @@ public class ZoomRing extends View {
     
     private void setThumbArrowsAngle(int angle) {
         int level = -angle * 10000 / ZoomRing.TWO_PI_INT_MULTIPLIED;
-        mThumbPlusArrowDrawable.setLevel(level);
-        mThumbMinusArrowDrawable.setLevel(level);
+        mZoomInArrowDrawable.setLevel(level);
+        mZoomOutArrowDrawable.setLevel(level);
         
         // Assume it is a square
-        int halfSideLength = mThumbPlusDrawable.getIntrinsicHeight() / 2;
+        int halfSideLength = mZoomInArrowHintDrawable.getIntrinsicHeight() / 2;
         int unoffsetAngle = angle + mZeroAngle;
         
-        int plusCenterX = (int) (Math.cos(1f * (unoffsetAngle - THUMB_PLUS_MINUS_OFFSET_ANGLE)
-                / RADIAN_INT_MULTIPLIER) * THUMB_PLUS_MINUS_DISTANCE) + mCenterX;
-        int plusCenterY = (int) (Math.sin(1f * (unoffsetAngle - THUMB_PLUS_MINUS_OFFSET_ANGLE)
-                / RADIAN_INT_MULTIPLIER) * THUMB_PLUS_MINUS_DISTANCE) * -1 + mCenterY;
-        mThumbPlusDrawable.setBounds(plusCenterX - halfSideLength,
+        int plusCenterX = (int) (Math.cos(1f * (unoffsetAngle - mZoomArrowHintOffsetAngle)
+                / RADIAN_INT_MULTIPLIER) * mZoomArrowHintDistance) + mCenterX;
+        int plusCenterY = (int) (Math.sin(1f * (unoffsetAngle - mZoomArrowHintOffsetAngle)
+                / RADIAN_INT_MULTIPLIER) * mZoomArrowHintDistance) * -1 + mCenterY;
+        mZoomInArrowHintDrawable.setBounds(plusCenterX - halfSideLength,
                 plusCenterY - halfSideLength,
                 plusCenterX + halfSideLength,
                 plusCenterY + halfSideLength);
         
-        int minusCenterX = (int) (Math.cos(1f * (unoffsetAngle + THUMB_PLUS_MINUS_OFFSET_ANGLE)
-                / RADIAN_INT_MULTIPLIER) * THUMB_PLUS_MINUS_DISTANCE) + mCenterX;
-        int minusCenterY = (int) (Math.sin(1f * (unoffsetAngle + THUMB_PLUS_MINUS_OFFSET_ANGLE)
-                / RADIAN_INT_MULTIPLIER) * THUMB_PLUS_MINUS_DISTANCE) * -1 + mCenterY;
-        mThumbMinusDrawable.setBounds(minusCenterX - halfSideLength,
+        int minusCenterX = (int) (Math.cos(1f * (unoffsetAngle + mZoomArrowHintOffsetAngle)
+                / RADIAN_INT_MULTIPLIER) * mZoomArrowHintDistance) + mCenterX;
+        int minusCenterY = (int) (Math.sin(1f * (unoffsetAngle + mZoomArrowHintOffsetAngle)
+                / RADIAN_INT_MULTIPLIER) * mZoomArrowHintDistance) * -1 + mCenterY;
+        mZoomOutArrowHintDrawable.setBounds(minusCenterX - halfSideLength,
                 minusCenterY - halfSideLength,
                 minusCenterX + halfSideLength,
                 minusCenterY + halfSideLength);
     }
     
-    public void setThumbArrowsVisible(boolean visible) {
+    void setThumbArrowsVisible(boolean visible) {
         if (visible) {
             mThumbArrowsAlpha = 255;
-            int callbackAngle = mPreviousCallbackAngle;
+            int callbackAngle = mPreviousCallbackTickAngle;
             if (callbackAngle < mThumbCwBound - RADIAN_INT_ERROR ||
                     callbackAngle > mThumbCwBound + RADIAN_INT_ERROR) {
-                mThumbPlusArrowDrawable.setAlpha(255);
-                mThumbPlusDrawable.setAlpha(255);
+                mZoomInArrowDrawable.setAlpha(255);
+                mZoomInArrowHintDrawable.setAlpha(255);
                 mThumbArrowsToDraw |= THUMB_ARROW_PLUS;                
             } else {
                 mThumbArrowsToDraw &= ~THUMB_ARROW_PLUS;
             }
             if (callbackAngle < mThumbCcwBound - RADIAN_INT_ERROR ||
                     callbackAngle > mThumbCcwBound + RADIAN_INT_ERROR) {
-                mThumbMinusArrowDrawable.setAlpha(255);
-                mThumbMinusDrawable.setAlpha(255);
+                mZoomOutArrowDrawable.setAlpha(255);
+                mZoomOutArrowHintDrawable.setAlpha(255);
                 mThumbArrowsToDraw |= THUMB_ARROW_MINUS;
             } else {
                 mThumbArrowsToDraw &= ~THUMB_ARROW_MINUS;
@@ -1117,11 +1211,11 @@ public class ZoomRing extends View {
         } else if (mThumbArrowsAlpha == 255) {
             // Only start fade if we're fully visible (otherwise another fade is happening already)
             mThumbArrowsFadeStartTime = SystemClock.elapsedRealtime();
-            onThumbArrowsFadeTick();
+            onThumbArrowsFadeStep();
         }
     }
     
-    private void onThumbArrowsFadeTick() {
+    private void onThumbArrowsFadeStep() {
         if (mThumbArrowsAlpha <= 0) {
             mThumbArrowsToDraw = 0;
             return;
@@ -1132,20 +1226,20 @@ public class ZoomRing extends View {
                         / THUMB_ARROWS_FADE_DURATION));
         if (mThumbArrowsAlpha < 0) mThumbArrowsAlpha = 0;
         if ((mThumbArrowsToDraw & THUMB_ARROW_PLUS) != 0) {
-            mThumbPlusArrowDrawable.setAlpha(mThumbArrowsAlpha);
-            mThumbPlusDrawable.setAlpha(mThumbArrowsAlpha);
-            invalidateDrawable(mThumbPlusDrawable);
-            invalidateDrawable(mThumbPlusArrowDrawable);
+            mZoomInArrowDrawable.setAlpha(mThumbArrowsAlpha);
+            mZoomInArrowHintDrawable.setAlpha(mThumbArrowsAlpha);
+            invalidateDrawable(mZoomInArrowHintDrawable);
+            invalidateDrawable(mZoomInArrowDrawable);
         }
         if ((mThumbArrowsToDraw & THUMB_ARROW_MINUS) != 0) {
-            mThumbMinusArrowDrawable.setAlpha(mThumbArrowsAlpha);
-            mThumbMinusDrawable.setAlpha(mThumbArrowsAlpha);
-            invalidateDrawable(mThumbMinusDrawable);
-            invalidateDrawable(mThumbMinusArrowDrawable);
+            mZoomOutArrowDrawable.setAlpha(mThumbArrowsAlpha);
+            mZoomOutArrowHintDrawable.setAlpha(mThumbArrowsAlpha);
+            invalidateDrawable(mZoomOutArrowHintDrawable);
+            invalidateDrawable(mZoomOutArrowDrawable);
         }
             
-        if (!mHandler.hasMessages(MSG_THUMB_ARROWS_FADE_TICK)) {
-            mHandler.sendEmptyMessage(MSG_THUMB_ARROWS_FADE_TICK);
+        if (!mHandler.hasMessages(MSG_THUMB_ARROWS_FADE_STEP)) {
+            mHandler.sendEmptyMessage(MSG_THUMB_ARROWS_FADE_STEP);
         }
     }
     
@@ -1168,7 +1262,7 @@ public class ZoomRing extends View {
         boolean onZoomRingThumbDragged(int numLevels, int startAngle, int curAngle);
         void onZoomRingThumbDraggingStopped();
         
-        void onZoomRingDismissed(boolean dismissImmediately);
+        void onZoomRingDismissed();
         
         void onUserInteractionStarted();
         void onUserInteractionStopped();
diff --git a/core/java/android/widget/ZoomRingController.java b/core/java/android/widget/ZoomRingController.java
index 19f66a0..3bf3b22 100644
--- a/core/java/android/widget/ZoomRingController.java
+++ b/core/java/android/widget/ZoomRingController.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008 The Android Open Source Project
+ * Copyright (C) 2009 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.
@@ -30,7 +30,8 @@ import android.os.Handler;
 import android.os.Message;
 import android.os.SystemClock;
 import android.provider.Settings;
-import android.util.Log;
+import android.util.DisplayMetrics;
+import android.view.GestureDetector;
 import android.view.Gravity;
 import android.view.KeyEvent;
 import android.view.LayoutInflater;
@@ -44,11 +45,9 @@ import android.view.animation.Animation;
 import android.view.animation.AnimationUtils;
 import android.view.animation.DecelerateInterpolator;
 
-// TODO: make sure no px values exist, only dip (scale if necessary from Viewconfiguration)
-
 /**
- * TODO: Docs
- *
+ * A controller to simplify the use of the zoom ring widget.   
+ * <p>
  * If you are using this with a custom View, please call
  * {@link #setVisible(boolean) setVisible(false)} from the
  * {@link View#onDetachedFromWindow}.
@@ -58,13 +57,7 @@ import android.view.animation.DecelerateInterpolator;
 public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         View.OnTouchListener, View.OnKeyListener {
 
-    private static final int ZOOM_RING_RADIUS_INSET = 24;
-
-    private static final int ZOOM_RING_RECENTERING_DURATION = 500;
-
-    private static final String TAG = "ZoomRing";
-
-    public static final boolean USE_OLD_ZOOM = false;
+    // Temporary methods for different zoom types
     static int getZoomType(Context context) {
         return Settings.System.getInt(context.getContentResolver(), "zoom", 1);
     }
@@ -75,19 +68,43 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         return getZoomType(context) == 1;
     }
 
-    private static final int ZOOM_CONTROLS_TIMEOUT =
-            (int) ViewConfiguration.getZoomControlsTimeout();
+    /** The duration for the animation to re-center the zoom ring. */
+    private static final int RECENTERING_DURATION = 500;
 
-    // TODO: move these to ViewConfiguration or re-use existing ones
-    // TODO: scale px values based on latest from ViewConfiguration
-    private static final int SECOND_TAP_TIMEOUT = 500;
-    private static final int ZOOM_RING_DISMISS_DELAY = SECOND_TAP_TIMEOUT / 2;
-    // TODO: view config?  at least scaled
-    private static final int MAX_PAN_GAP = 20;
-    private static final int MAX_INITIATE_PAN_GAP = 10;
-    // TODO view config
+    /** The inactivity timeout for the zoom ring. */
+    private static final int INACTIVITY_TIMEOUT =
+            (int) ViewConfiguration.getZoomControlsTimeout();
+    
+    /**
+     * The delay when the user taps outside to dismiss the zoom ring. This is
+     * because the user can do a second-tap to recenter the owner view instead
+     * of dismissing the zoom ring.
+     */
+    private static final int OUTSIDE_TAP_DISMISS_DELAY =
+            ViewConfiguration.getDoubleTapTimeout() / 2;
+    
+    /**
+     * When the zoom ring is on the edge, this is the delay before we actually
+     * start panning the owner.
+     * @see #mInitiatePanGap
+     */
     private static final int INITIATE_PAN_DELAY = 300;
 
+    /**
+     * While already panning, if the zoom ring remains this close to an edge,
+     * the owner will continue to be panned.
+     */
+    private int mPanGap;
+    
+    /** To begin a pan, the zoom ring must be this close to an edge. */
+    private int mInitiatePanGap;
+
+    /** Initialized from ViewConfiguration. */
+    private int mScaledTouchSlop;
+
+    /**
+     * The setting name that tracks whether we've shown the zoom ring toast.
+     */
     private static final String SETTING_NAME_SHOWN_TOAST = "shown_zoom_ring_toast";
 
     private Context mContext;
@@ -137,25 +154,37 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
      * screen once (for the first tap down) instead of twice (for the first tap
      * down and then to grab the thumb).
      */
+    /** The X where the tap-drag started. */
     private int mTapDragStartX;
+    /** The Y where the tap-drag started. */
     private int mTapDragStartY;
 
+    /** The controller is idle */
     private static final int TOUCH_MODE_IDLE = 0;
-    private static final int TOUCH_MODE_WAITING_FOR_SECOND_TAP = 1;
+    /**
+     * In the middle of a second-tap interaction, waiting for either an up-touch
+     * or the user to start dragging to go into tap-drag mode.
+     */
     private static final int TOUCH_MODE_WAITING_FOR_TAP_DRAG_MOVEMENT = 2;
+    /** In the middle of a tap-drag. */
     private static final int TOUCH_MODE_FORWARDING_FOR_TAP_DRAG = 3;
     private int mTouchMode;
 
+    /** Whether the zoom ring is visible. */
     private boolean mIsZoomRingVisible;
 
     private ZoomRing mZoomRing;
+    /** Cached width of the zoom ring. */
     private int mZoomRingWidth;
+    /** Cached height of the zoom ring. */
     private int mZoomRingHeight;
 
     /** Invokes panning of owner view if the zoom ring is touching an edge. */
     private Panner mPanner;
+    /** The time when the zoom ring first touched the edge. */
     private long mTouchingEdgeStartTime;
-    private boolean mPanningEnabledForThisInteraction;
+    /** Whether the user has already initiated the panning. */
+    private boolean mPanningInitiated;
 
     /**
      * When the finger moves the zoom ring to an edge, this is the horizontal
@@ -167,16 +196,21 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
     /** Vertical accumulator, see {@link #mMovingZoomRingOobX} */
     private int mMovingZoomRingOobY;
 
+    /** Arrows that hint that the zoom ring is movable. */
     private ImageView mPanningArrows;
+    /** The animation shown when the panning arrows are being shown. */
     private Animation mPanningArrowsEnterAnimation;
+    /** The animation shown when the panning arrows are being hidden. */
     private Animation mPanningArrowsExitAnimation;
 
+    /**
+     * Temporary rectangle, only use from the UI thread (and ideally don't rely
+     * on it being unused across many method calls.)
+     */
     private Rect mTempRect = new Rect();
 
     private OnZoomListener mCallback;
 
-    private ViewConfiguration mViewConfig;
-
     /**
      * When the zoom ring is centered on screen, this will be the x value used
      * for the container's layout params.
@@ -217,6 +251,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
     private IntentFilter mConfigurationChangedFilter =
             new IntentFilter(Intent.ACTION_CONFIGURATION_CHANGED);
 
+    /** Listens for configuration changes so we can make sure we're still in a reasonable state. */
     private BroadcastReceiver mConfigurationChangedReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
@@ -228,7 +263,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
     };
 
     /** Keeps the scroller going (or starts it). */
-    private static final int MSG_SCROLLER_TICK = 1;
+    private static final int MSG_SCROLLER_STEP = 1;
     /** When configuration changes, this is called after the UI thread is idle. */
     private static final int MSG_POST_CONFIGURATION_CHANGED = 2;
     /** Used to delay the zoom ring dismissal. */
@@ -244,8 +279,8 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
-                case MSG_SCROLLER_TICK:
-                    onScrollerTick();
+                case MSG_SCROLLER_STEP:
+                    onScrollerStep();
                     break;
 
                 case MSG_POST_CONFIGURATION_CHANGED:
@@ -296,8 +331,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         mContainerLayoutParams.width = LayoutParams.WRAP_CONTENT;
         mContainerLayoutParams.type = LayoutParams.TYPE_APPLICATION_PANEL;
         mContainerLayoutParams.format = PixelFormat.TRANSPARENT;
-        // TODO: make a new animation for this
-        mContainerLayoutParams.windowAnimations = com.android.internal.R.style.Animation_Dialog;
+        mContainerLayoutParams.windowAnimations = com.android.internal.R.style.Animation_ZoomRing;
 
         mContainer = new FrameLayout(context);
         mContainer.setLayoutParams(mContainerLayoutParams);
@@ -308,13 +342,17 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
 
         mScroller = new Scroller(context, new DecelerateInterpolator());
 
-        mViewConfig = ViewConfiguration.get(context);
+        ViewConfiguration vc = ViewConfiguration.get(context);
+        mScaledTouchSlop = vc.getScaledTouchSlop();
+        
+        float density = context.getResources().getDisplayMetrics().density;
+        mPanGap = (int) (20 * density);
+        mInitiatePanGap = (int) (10 * density);
     }
 
     private void createPanningArrows() {
-        // TODO: style
         mPanningArrows = new ImageView(mContext);
-        mPanningArrows.setImageResource(com.android.internal.R.drawable.zoom_ring_arrows);
+        mPanningArrows.setImageDrawable(mZoomRing.getPanningArrowsDrawable());
         mPanningArrows.setLayoutParams(new FrameLayout.LayoutParams(
                 FrameLayout.LayoutParams.WRAP_CONTENT,
                 FrameLayout.LayoutParams.WRAP_CONTENT,
@@ -328,15 +366,16 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
     }
 
     /**
-     * Sets the angle (in radians) a user must travel in order for the client to
-     * get a callback. Once there is a callback, the accumulator resets. For
-     * example, if you set this to PI/6, it will give a callback every time the
-     * user moves PI/6 amount on the ring.
-     *
-     * @param callbackThreshold The angle for the callback threshold, in radians
+     * Sets the angle (in radians) between ticks. This is also the angle a user
+     * must move the thumb in order for the client to get a callback. Once there
+     * is a callback, the accumulator resets. For example, if you set this to
+     * PI/6, it will give a callback every time the user moves PI/6 amount on
+     * the ring.
+     * 
+     * @param angle The angle for the callback threshold, in radians
      */
-    public void setZoomCallbackThreshold(float callbackThreshold) {
-        mZoomRing.setCallbackThreshold((int) (callbackThreshold * ZoomRing.RADIAN_INT_MULTIPLIER));
+    public void setTickDelta(float angle) {
+        mZoomRing.setTickDelta((int) (angle * ZoomRing.RADIAN_INT_MULTIPLIER));
     }
 
     /**
@@ -346,14 +385,23 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
      * @hide Need a better way of doing this, but this one-off for browser so it
      *       can have its final look for the usability study
      */
-    public void setZoomRingTrack(int drawable) {
+    public void setTrackDrawable(int drawable) {
         mZoomRing.setBackgroundResource(drawable);
     }
-
+    
+    /**
+     * Sets the callback for the zoom ring controller.
+     * 
+     * @param callback The callback.
+     */
     public void setCallback(OnZoomListener callback) {
         mCallback = callback;
     }
 
+    public void setVibration(boolean vibrate) {
+        mZoomRing.setVibration(vibrate);
+    }
+    
     public void setThumbAngle(float angle) {
         mZoomRing.setThumbAngle((int) (angle * ZoomRing.RADIAN_INT_MULTIPLIER));
     }
@@ -362,14 +410,6 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         mZoomRing.setThumbAngleAnimated((int) (angle * ZoomRing.RADIAN_INT_MULTIPLIER), 0);
     }
 
-    public void setResetThumbAutomatically(boolean resetThumbAutomatically) {
-        mZoomRing.setResetThumbAutomatically(resetThumbAutomatically);
-    }
-
-    public void setVibration(boolean vibrate) {
-        mZoomRing.setVibration(vibrate);
-    }
-    
     public void setThumbVisible(boolean thumbVisible) {
         mZoomRing.setThumbVisible(thumbVisible);
     }
@@ -407,7 +447,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
                 return;
             }
             
-            dismissZoomRingDelayed(ZOOM_CONTROLS_TIMEOUT);
+            dismissZoomRingDelayed(INACTIVITY_TIMEOUT);
         } else {
             mPanner.stop();
         }
@@ -429,12 +469,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
                     public void run() {
                         refreshPositioningVariables();
                         resetZoomRing();
-
-                        // TODO: remove this 'update' and just center zoom ring before the
-                        // 'add', but need to make sure we have the width and height (which
-                        // probably can only be retrieved after it's measured, which happens
-                        // after it's added).
-                        mWindowManager.updateViewLayout(mContainer, mContainerLayoutParams);
+                        refreshContainerLayout();
 
                         if (mCallback != null) {
                             mCallback.onVisibilityChanged(true);
@@ -479,19 +514,34 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
 
     }
 
+    private void refreshContainerLayout() {
+        if (mIsZoomRingVisible) {
+            mWindowManager.updateViewLayout(mContainer, mContainerLayoutParams);
+        }
+    }
+
     /**
-     * TODO: docs
-     *
+     * Returns the container of the zoom ring widget. The client can add views
+     * here to be shown alongside the zoom ring.  See {@link #getZoomRingId()}.
+     * <p>
      * Notes:
-     * - Touch dispatching is different.  Only direct children who are clickable are eligble for touch events.
-     * - Please ensure you set your View to INVISIBLE not GONE when hiding it.
-     *
-     * @return
+     * <ul>
+     * <li> The controller dispatches touch events differently than the regular view
+     * framework.
+     * <li> Please ensure you set your view to INVISIBLE not GONE when hiding it.
+     * </ul>
+     * 
+     * @return The layout used by the container.
      */
     public FrameLayout getContainer() {
         return mContainer;
     }
 
+    /**
+     * Returns the id of the zoom ring widget.
+     * 
+     * @return The id of the zoom ring widget.
+     */
     public int getZoomRingId() {
         return mZoomRing.getId();
     }
@@ -514,7 +564,10 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
     /**
      * Should be called by the client for each event belonging to the second tap
      * (the down, move, up, and cancel events).
-     *
+     * <p>
+     * In most cases, the client can use a {@link GestureDetector} and forward events from
+     * {@link GestureDetector.OnDoubleTapListener#onDoubleTapEvent(MotionEvent)}.
+     * 
      * @param event The event belonging to the second tap.
      * @return Whether the event was consumed.
      */
@@ -550,9 +603,9 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
                         case MotionEvent.ACTION_MOVE:
                             int x = (int) event.getX();
                             int y = (int) event.getY();
-                            if (Math.abs(x - mTapDragStartX) > mViewConfig.getScaledTouchSlop() ||
+                            if (Math.abs(x - mTapDragStartX) > mScaledTouchSlop ||
                                     Math.abs(y - mTapDragStartY) >
-                                    mViewConfig.getScaledTouchSlop()) {
+                                    mScaledTouchSlop) {
                                 mZoomRing.setTapDragMode(true, x, y);
                                 mTouchMode = TOUCH_MODE_FORWARDING_FOR_TAP_DRAG;
                                 setTouchTargetView(mZoomRing);
@@ -600,8 +653,8 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
             int width = mContainer.getWidth();
             int height = mContainer.getHeight();
             mScroller.startScroll(lp.x, lp.y, mCenteredContainerX - lp.x,
-                    mCenteredContainerY - lp.y, ZOOM_RING_RECENTERING_DURATION);
-            mHandler.sendEmptyMessage(MSG_SCROLLER_TICK);
+                    mCenteredContainerY - lp.y, RECENTERING_DURATION);
+            mHandler.sendEmptyMessage(MSG_SCROLLER_STEP);
         }
     }
 
@@ -636,18 +689,22 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         mZoomRing.handleTouch(event.getAction(), event.getEventTime(), x, y, rawX, rawY);
     }
 
+    /** @hide */
     public void onZoomRingSetMovableHintVisible(boolean visible) {
         setPanningArrowsVisible(visible);
     }
 
+    /** @hide */
     public void onUserInteractionStarted() {
         mHandler.removeMessages(MSG_DISMISS_ZOOM_RING);
     }
 
+    /** @hide */
     public void onUserInteractionStopped() {
-        dismissZoomRingDelayed(ZOOM_CONTROLS_TIMEOUT);
+        dismissZoomRingDelayed(INACTIVITY_TIMEOUT);
     }
 
+    /** @hide */
     public void onZoomRingMovingStarted() {
         mScroller.abortAnimation();
         mTouchingEdgeStartTime = 0;
@@ -664,6 +721,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         mPanningArrows.setVisibility(visible ? View.VISIBLE : View.INVISIBLE);
     }
 
+    /** @hide */
     public boolean onZoomRingMoved(int deltaX, int deltaY, int rawX, int rawY) {
 
         if (mMovingZoomRingOobX != 0) {
@@ -721,12 +779,12 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
                     ownerBounds.bottom - mZoomRingHeight : newZoomRingY;
         lp.y = newZoomRingY - zoomRingTop;
 
-        mWindowManager.updateViewLayout(mContainer, lp);
-
+        refreshContainerLayout();
+        
         // Check for pan
         boolean horizontalPanning = true;
         int leftGap = newZoomRingX - ownerBounds.left;
-        if (leftGap < MAX_PAN_GAP) {
+        if (leftGap < mPanGap) {
             if (leftGap == 0 && deltaX != 0 && mMovingZoomRingOobX == 0) {
                 // Future moves in this direction should be accumulated in mMovingZoomRingOobX
                 mMovingZoomRingOobX = deltaX / Math.abs(deltaX);
@@ -736,7 +794,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
             }
         } else {
             int rightGap = ownerBounds.right - (lp.x + mZoomRingWidth + zoomRingLeft);
-            if (rightGap < MAX_PAN_GAP) {
+            if (rightGap < mPanGap) {
                 if (rightGap == 0 && deltaX != 0 && mMovingZoomRingOobX == 0) {
                     mMovingZoomRingOobX = deltaX / Math.abs(deltaX);
                 }
@@ -750,7 +808,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         }
 
         int topGap = newZoomRingY - ownerBounds.top;
-        if (topGap < MAX_PAN_GAP) {
+        if (topGap < mPanGap) {
             if (topGap == 0 && deltaY != 0 && mMovingZoomRingOobY == 0) {
                 mMovingZoomRingOobY = deltaY / Math.abs(deltaY);
             }
@@ -759,7 +817,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
             }
         } else {
             int bottomGap = ownerBounds.bottom - (lp.y + mZoomRingHeight + zoomRingTop);
-            if (bottomGap < MAX_PAN_GAP) {
+            if (bottomGap < mPanGap) {
                 if (bottomGap == 0 && deltaY != 0 && mMovingZoomRingOobY == 0) {
                     mMovingZoomRingOobY = deltaY / Math.abs(deltaY);
                 }
@@ -771,7 +829,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
                 if (!horizontalPanning) {
                     // Neither are panning, reset any timer to start pan mode
                     mTouchingEdgeStartTime = 0;
-                    mPanningEnabledForThisInteraction = false;
+                    mPanningInitiated = false;
                     mPanner.stop();
                 }
             }
@@ -781,13 +839,13 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
     }
 
     private boolean shouldPan(int gap) {
-        if (mPanningEnabledForThisInteraction) return true;
+        if (mPanningInitiated) return true;
 
-        if (gap < MAX_INITIATE_PAN_GAP) {
+        if (gap < mInitiatePanGap) {
             long time = SystemClock.elapsedRealtime();
             if (mTouchingEdgeStartTime != 0 &&
                     mTouchingEdgeStartTime + INITIATE_PAN_DELAY < time) {
-                mPanningEnabledForThisInteraction = true;
+                mPanningInitiated = true;
                 return true;
             } else if (mTouchingEdgeStartTime == 0) {
                 mTouchingEdgeStartTime = time;
@@ -800,6 +858,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         return false;
     }
 
+    /** @hide */
     public void onZoomRingMovingStopped() {
         mPanner.stop();
         setPanningArrowsVisible(false);
@@ -809,27 +868,25 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
     }
 
     private int getStrengthFromGap(int gap) {
-        return gap > MAX_PAN_GAP ? 0 :
-            (MAX_PAN_GAP - gap) * 100 / MAX_PAN_GAP;
+        return gap > mPanGap ? 0 :
+            (mPanGap - gap) * 100 / mPanGap;
     }
 
+    /** @hide */
     public void onZoomRingThumbDraggingStarted() {
         if (mCallback != null) {
             mCallback.onBeginDrag();
         }
     }
 
+    /** @hide */
     public boolean onZoomRingThumbDragged(int numLevels, int startAngle, int curAngle) {
         if (mCallback != null) {
             int deltaZoomLevel = -numLevels;
-            int globalZoomCenterX = mContainerLayoutParams.x + mZoomRing.getLeft() +
-                    mZoomRingWidth / 2;
-            int globalZoomCenterY = mContainerLayoutParams.y + mZoomRing.getTop() +
-                    mZoomRingHeight / 2;
 
             return mCallback.onDragZoom(deltaZoomLevel,
-                    globalZoomCenterX - mOwnerViewBounds.left,
-                    globalZoomCenterY - mOwnerViewBounds.top,
+                    getZoomRingCenterXInOwnerCoordinates(),
+                    getZoomRingCenterYInOwnerCoordinates(),
                     (float) startAngle / ZoomRing.RADIAN_INT_MULTIPLIER,
                     (float) curAngle / ZoomRing.RADIAN_INT_MULTIPLIER);
         }
@@ -837,24 +894,36 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         return false;
     }
 
+    private int getZoomRingCenterXInOwnerCoordinates() {
+        int globalZoomCenterX = mContainerLayoutParams.x + mZoomRing.getLeft() +
+                mZoomRingWidth / 2;
+        return globalZoomCenterX - mOwnerViewBounds.left;
+    }
+
+    private int getZoomRingCenterYInOwnerCoordinates() {
+        int globalZoomCenterY = mContainerLayoutParams.y + mZoomRing.getTop() +
+                mZoomRingHeight / 2;
+        return globalZoomCenterY - mOwnerViewBounds.top;
+    }
+
+    /** @hide */
     public void onZoomRingThumbDraggingStopped() {
         if (mCallback != null) {
             mCallback.onEndDrag();
         }
     }
 
-    public void onZoomRingDismissed(boolean dismissImmediately) {
-        if (dismissImmediately) {
-            mHandler.removeMessages(MSG_DISMISS_ZOOM_RING);
-            setVisible(false);
-        } else {
-            dismissZoomRingDelayed(ZOOM_RING_DISMISS_DELAY);
-        }
+    /** @hide */
+    public void onZoomRingDismissed() {
+        mHandler.removeMessages(MSG_DISMISS_ZOOM_RING);
+        setVisible(false);
     }
 
+    /** @hide */
     public void onRingDown(int tickAngle, int touchAngle) {
     }
 
+    /** @hide */
     public boolean onTouch(View v, MotionEvent event) {
         if (sTutorialDialog != null && sTutorialDialog.isShowing() &&
                 SystemClock.elapsedRealtime() - sTutorialShowTime >= TUTORIAL_MIN_DISPLAY_TIME) {
@@ -904,8 +973,9 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
             return retValue;
 
         } else {
+//            dismissZoomRingDelayed(ZOOM_CONTROLS_TIMEOUT);
             if (action == MotionEvent.ACTION_DOWN) {
-                dismissZoomRingDelayed(ZOOM_RING_DISMISS_DELAY);
+                dismissZoomRingDelayed(OUTSIDE_TAP_DISMISS_DELAY);
             }
 
             return false;
@@ -932,7 +1002,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         int containerCenterY = mContainerLayoutParams.y + mContainer.getHeight() / 2;
         int distanceFromCenterX = rawX - containerCenterX;
         int distanceFromCenterY = rawY - containerCenterY;
-        int zoomRingRadius = mZoomRingWidth / 2 - ZOOM_RING_RADIUS_INSET;
+        int zoomRingRadius = mZoomRing.getTrackOuterRadius();
         if (distanceFromCenterX * distanceFromCenterX +
                 distanceFromCenterY * distanceFromCenterY <=
                 zoomRingRadius * zoomRingRadius) {
@@ -960,7 +1030,11 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         return null;
     }
 
-    /** Steals key events from the owner view. */
+    /**
+     * Steals key events from the owner view.
+     * 
+     * @hide
+     */
     public boolean onKey(View v, int keyCode, KeyEvent event) {
         switch (keyCode) {
             case KeyEvent.KEYCODE_DPAD_LEFT:
@@ -971,12 +1045,14 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
             case KeyEvent.KEYCODE_DPAD_UP:
             case KeyEvent.KEYCODE_DPAD_DOWN:
                 // Keep the zoom alive a little longer
-                dismissZoomRingDelayed(ZOOM_CONTROLS_TIMEOUT);
+                dismissZoomRingDelayed(INACTIVITY_TIMEOUT);
                 // They started zooming, hide the thumb arrows
                 mZoomRing.setThumbArrowsVisible(false);
 
                 if (mCallback != null && event.getAction() == KeyEvent.ACTION_DOWN) {
-                    mCallback.onSimpleZoom(keyCode == KeyEvent.KEYCODE_DPAD_UP);
+                    mCallback.onSimpleZoom(keyCode == KeyEvent.KEYCODE_DPAD_UP,
+                            getZoomRingCenterXInOwnerCoordinates(),
+                            getZoomRingCenterYInOwnerCoordinates());
                 }
 
                 return true;
@@ -985,18 +1061,18 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         return false;
     }
 
-    private void onScrollerTick() {
+    private void onScrollerStep() {
         if (!mScroller.computeScrollOffset() || !mIsZoomRingVisible) return;
 
         mContainerLayoutParams.x = mScroller.getCurrX();
         mContainerLayoutParams.y = mScroller.getCurrY();
-        mWindowManager.updateViewLayout(mContainer, mContainerLayoutParams);
+        refreshContainerLayout();
 
-        mHandler.sendEmptyMessage(MSG_SCROLLER_TICK);
+        mHandler.sendEmptyMessage(MSG_SCROLLER_STEP);
     }
 
     private void onPostConfigurationChanged() {
-        dismissZoomRingDelayed(ZOOM_CONTROLS_TIMEOUT);
+        dismissZoomRingDelayed(INACTIVITY_TIMEOUT);
         refreshPositioningVariables();
         ensureZoomRingIsCentered();
     }
@@ -1056,6 +1132,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         sTutorialShowTime = SystemClock.elapsedRealtime();
     }
 
+    /** @hide Should only be used by Android platform apps */
     public static void finishZoomTutorial(Context context, boolean userNotified) {
         if (sTutorialDialog == null) return;
 
@@ -1078,22 +1155,45 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
         }
     }
 
+    /** @hide Should only be used by Android platform apps */
     public void finishZoomTutorial() {
         finishZoomTutorial(mContext, true);
     }
 
+    /**
+     * Sets the initial velocity of a pan.
+     * 
+     * @param startVelocity The initial velocity to move the owner view, in
+     *            pixels per second.
+     */
     public void setPannerStartVelocity(float startVelocity) {
         mPanner.mStartVelocity = startVelocity;
     }
 
+    /**
+     * Sets the accelartion of the pan.
+     *
+     * @param acceleration The acceleration, in pixels per second squared.
+     */
     public void setPannerAcceleration(float acceleration) {
         mPanner.mAcceleration = acceleration;
     }
 
+    /**
+     * Sets the maximum velocity of a pan.
+     * 
+     * @param maxVelocity The max velocity to move the owner view, in pixels per
+     *            second.
+     */
     public void setPannerMaxVelocity(float maxVelocity) {
         mPanner.mMaxVelocity = maxVelocity;
     }
 
+    /**
+     * Sets the duration before acceleration will be applied.
+     * 
+     * @param duration The duration, in milliseconds.
+     */
     public void setPannerStartAcceleratingDuration(int duration) {
         mPanner.mStartAcceleratingDuration = duration;
     }
@@ -1201,16 +1301,83 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback,
 
     }
 
+    /**
+     * Interface used to inform the client of zoom events that the user
+     * triggers.
+     */
     public interface OnZoomListener {
+        /**
+         * Called when the user begins dragging the thumb on the zoom ring.
+         */
         void onBeginDrag();
+
+        /**
+         * Called when the user drags the thumb and passes a tick causing a
+         * zoom.
+         * 
+         * @param deltaZoomLevel The number of levels to be zoomed. Positive to
+         *            zoom in, negative to zoom out.
+         * @param centerX The point about which to zoom. The zoom should pin
+         *            this point, leaving it at the same coordinate. This is
+         *            relative to the owner view's upper-left.
+         * @param centerY The point about which to zoom. The zoom should pin
+         *            this point, leaving it at the same coordinate. This is
+         *            relative to the owner view's upper-left.
+         * @param startAngle The angle where the user started dragging the thumb.
+         * @param curAngle The current angle of the thumb.
+         * @return Whether the owner was zoomed.
+         */
         boolean onDragZoom(int deltaZoomLevel, int centerX, int centerY, float startAngle,
                 float curAngle);
+        
+        /**
+         * Called when the user releases the thumb.
+         */
         void onEndDrag();
-        void onSimpleZoom(boolean deltaZoomLevel);
+
+        /**
+         * Called when the user zooms via some other mechanism, for example
+         * arrow keys or a trackball.
+         * 
+         * @param zoomIn Whether to zoom in (true) or out (false).
+         * @param centerX See {@link #onDragZoom(int, int, int, float, float)}.
+         * @param centerY See {@link #onDragZoom(int, int, int, float, float)}.
+         */
+        void onSimpleZoom(boolean zoomIn, int centerX, int centerY);
+
+        /**
+         * Called when the user begins moving the zoom ring in order to pan the
+         * owner.
+         */
         void onBeginPan();
+        
+        /**
+         * Called when the owner should pan as a result of the user moving the zoom ring.
+         * 
+         * @param deltaX The amount to pan horizontally.
+         * @param deltaY The amount to pan vertically.
+         * @return Whether the owner was panned.
+         */
         boolean onPan(int deltaX, int deltaY);
+        
+        /**
+         * Called when the user releases the zoom ring.
+         */
         void onEndPan();
+        
+        /**
+         * Called when the client should center the owner on the given point.
+         * 
+         * @param x The x to center on, relative to the owner view's upper-left.
+         * @param y The y to center on, relative to the owner view's upper-left.
+         */
         void onCenter(int x, int y);
+        
+        /**
+         * Called when the zoom ring's visibility changes.
+         * 
+         * @param visible Whether the zoom ring is visible (true) or not (false).
+         */
         void onVisibilityChanged(boolean visible);
     }
 }
diff --git a/core/java/com/android/internal/os/HandlerCaller.java b/core/java/com/android/internal/os/HandlerCaller.java
index bab1e21..932555d 100644
--- a/core/java/com/android/internal/os/HandlerCaller.java
+++ b/core/java/com/android/internal/os/HandlerCaller.java
@@ -120,6 +120,10 @@ public class HandlerCaller {
         return mH.obtainMessage(what, arg1, 0);
     }
     
+    public Message obtainMessageII(int what, int arg1, int arg2) {
+        return mH.obtainMessage(what, arg1, arg2);
+    }
+    
     public Message obtainMessageIO(int what, int arg1, Object arg2) {
         return mH.obtainMessage(what, arg1, 0, arg2);
     }
diff --git a/core/java/com/android/internal/os/IResultReceiver.aidl b/core/java/com/android/internal/os/IResultReceiver.aidl
new file mode 100644
index 0000000..2b70f95
--- /dev/null
+++ b/core/java/com/android/internal/os/IResultReceiver.aidl
@@ -0,0 +1,25 @@
+/* //device/java/android/android/app/IActivityPendingResult.aidl
+**
+** Copyright 2009, 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.internal.os;
+
+import android.os.Bundle;
+
+/** @hide */
+oneway interface IResultReceiver {
+    void send(int resultCode, in Bundle resultData);
+}
diff --git a/core/java/com/android/internal/view/IInputMethod.aidl b/core/java/com/android/internal/view/IInputMethod.aidl
index 9b00402..8ff18ed 100644
--- a/core/java/com/android/internal/view/IInputMethod.aidl
+++ b/core/java/com/android/internal/view/IInputMethod.aidl
@@ -18,6 +18,7 @@ package com.android.internal.view;
 
 import android.graphics.Rect;
 import android.os.IBinder;
+import android.os.ResultReceiver;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.inputmethod.EditorInfo;
@@ -48,7 +49,7 @@ oneway interface IInputMethod {
     
     void revokeSession(IInputMethodSession session);
     
-    void showSoftInput(int flags);
+    void showSoftInput(int flags, in ResultReceiver resultReceiver);
     
-    void hideSoftInput();
+    void hideSoftInput(int flags, in ResultReceiver resultReceiver);
 }
diff --git a/core/java/com/android/internal/view/IInputMethodManager.aidl b/core/java/com/android/internal/view/IInputMethodManager.aidl
index 1b1c7f7..9030a3e 100644
--- a/core/java/com/android/internal/view/IInputMethodManager.aidl
+++ b/core/java/com/android/internal/view/IInputMethodManager.aidl
@@ -16,6 +16,7 @@
 
 package com.android.internal.view;
 
+import android.os.ResultReceiver;
 import android.view.inputmethod.InputMethodInfo;
 import android.view.inputmethod.EditorInfo;
 import com.android.internal.view.InputBindResult;
@@ -38,8 +39,10 @@ interface IInputMethodManager {
             IInputContext inputContext, in EditorInfo attribute,
             boolean initial, boolean needResult);
     void finishInput(in IInputMethodClient client);
-    void showSoftInput(in IInputMethodClient client, int flags);
-    void hideSoftInput(in IInputMethodClient client, int flags);
+    boolean showSoftInput(in IInputMethodClient client, int flags,
+            in ResultReceiver resultReceiver);
+    boolean hideSoftInput(in IInputMethodClient client, int flags,
+            in ResultReceiver resultReceiver);
     void windowGainedFocus(in IInputMethodClient client,
             boolean viewHasFocus, boolean isTextEditor,
             int softInputMode, boolean first, int windowFlags);
@@ -47,6 +50,7 @@ interface IInputMethodManager {
     void showInputMethodPickerFromClient(in IInputMethodClient client);
     void setInputMethod(in IBinder token, String id);
     void hideMySoftInput(in IBinder token, int flags);
+    void showMySoftInput(in IBinder token, int flags);
     void updateStatusIcon(in IBinder token, String packageName, int iconId);
     
     boolean setInputMethodEnabled(String id, boolean enabled);
diff --git a/core/java/com/android/internal/view/IInputMethodSession.aidl b/core/java/com/android/internal/view/IInputMethodSession.aidl
index 8a44976..a05ff14 100644
--- a/core/java/com/android/internal/view/IInputMethodSession.aidl
+++ b/core/java/com/android/internal/view/IInputMethodSession.aidl
@@ -46,4 +46,6 @@ oneway interface IInputMethodSession {
     void dispatchTrackballEvent(int seq, in MotionEvent event, IInputMethodCallback callback);
 
     void appPrivateCommand(String action, in Bundle data);
+
+    void toggleSoftInput(int showFlags, int hideFlags);
 }
diff --git a/core/java/com/android/internal/widget/EditStyledText.java b/core/java/com/android/internal/widget/EditStyledText.java
new file mode 100644
index 0000000..48b4780
--- /dev/null
+++ b/core/java/com/android/internal/widget/EditStyledText.java
@@ -0,0 +1,653 @@
+/*
+ * Copyright (C) 2009 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.internal.widget;
+
+import android.content.Context;
+import android.text.Editable;
+import android.text.Spannable;
+import android.text.style.AbsoluteSizeSpan;
+import android.text.style.ForegroundColorSpan;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.widget.EditText;
+
+/**
+ * EditStyledText extends EditText for managing the flow and status 
+ * to edit the styled text. This manages the states and flows of editing,
+ * supports inserting image, import/export HTML.
+ */
+public class EditStyledText extends EditText {
+
+    private static final String LOG_TAG = "EditStyledText";
+    private static final boolean DBG = true;
+
+    /**
+     * The modes of editing actions.
+     */
+    /** The mode that no editing action is done. */
+    public static final int MODE_NOTHING = 0;
+    /** The mode of copy. */
+    public static final int MODE_COPY = 1;
+    /** The mode of paste. */
+    public static final int MODE_PASTE = 2;
+    /** The mode of changing size. */
+    public static final int MODE_SIZE = 3;
+    /** The mode of changing color. */
+    public static final int MODE_COLOR = 4;
+    /** The mode of selection. */
+    public static final int MODE_SELECT = 5;
+
+    /**
+     * The state of selection.
+     */
+    /** The state that selection isn't started. */
+    public static final int STATE_SELECT_OFF = 0;
+    /** The state that selection is started. */
+    public static final int STATE_SELECT_ON = 1;
+    /** The state that selection is done, but not fixed. */
+    public static final int STATE_SELECTED = 2;
+    /** The state that selection is done and not fixed.*/
+    public static final int STATE_SELECT_FIX = 3;
+
+    /**
+     * The help message strings.
+     */
+    public static final int HINT_MSG_NULL = 0;
+    public static final int HINT_MSG_COPY_BUF_BLANK = 1;
+    public static final int HINT_MSG_SELECT_START = 2;
+    public static final int HINT_MSG_SELECT_END = 3;
+    public static final int HINT_MSG_PUSH_COMPETE = 4;
+
+
+    /**
+     * EditStyledTextInterface provides functions for notifying messages
+     * to calling class.
+     */
+    public interface EditStyledTextInterface {
+        public void notifyHintMsg(int msg_id);
+    }
+    private EditStyledTextInterface mESTInterface;
+
+    /**
+     * EditStyledTextEditorManager manages the flow and status of 
+     * each function for editing styled text.
+     */
+    private EditStyledTextEditorManager mManager;
+
+    /**
+      * EditStyledText extends EditText for managing flow of each editing
+      * action.
+      */
+    public EditStyledText(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        init();
+    }
+
+    public EditStyledText(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    public EditStyledText(Context context) {
+        super(context);
+        init();
+    }
+
+    /**
+     * Set View objects used in EditStyledText.
+     * @param helptext The view shows help messages.
+     */
+    public void setParts(EditStyledTextInterface est_interface) {
+        mESTInterface = est_interface;
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        final boolean superResult = super.onTouchEvent(event);
+        if (event.getAction() == MotionEvent.ACTION_UP) {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onTouchEvent");
+            }
+            mManager.onTouchScreen();
+        }
+        return superResult;
+    }
+
+    /**
+     * Start editing. This function have to be called before other
+     * editing actions.
+     */
+    public void onStartEdit() {
+        mManager.onStartEdit();
+    }
+
+    /**
+     * End editing.
+     */
+    public void onEndEdit() {
+        mManager.onEndEdit();
+    }
+
+    /**
+     * Start "Copy" action.
+     */
+    public void onStartCopy() {
+        mManager.onStartCopy();
+    }
+
+    /**
+     * Start "Paste" action.
+     */
+    public void onStartPaste() {
+        mManager.onStartPaste();
+    }
+
+    /**
+     * Start changing "Size" action.
+     */
+    public void onStartSize() {
+        mManager.onStartSize();
+    }
+
+    /**
+     * Start changing "Color" action.
+     */
+    public void onStartColor() {
+        mManager.onStartColor();
+    }
+
+    /**
+     * Start "Select" action.
+     */
+    public void onStartSelect() {
+        mManager.onStartSelect();
+    }
+
+    /**
+     * Start "SelectAll" action.
+     */
+    public void onStartSelectAll() {
+        mManager.onStartSelectAll();
+    }
+
+    /**
+     * Fix Selected Item.
+     */
+    public void fixSelectedItem() {
+        mManager.onFixSelectItem();
+    }
+
+    /**
+     * Set Size of the Item.
+     * @param size The size of the Item.
+     */
+    public void setItemSize(int size) {
+        mManager.setItemSize(size);
+    }
+
+    /**
+     * Set Color of the Item.
+     * @param color The color of the Item.
+     */
+    public void setItemColor(int color) {
+        mManager.setItemColor(color);
+    }
+
+    /**
+     * Check editing is started.
+     * @return Whether editing is started or not.
+     */
+    public boolean isEditting() {
+        return mManager.isEditting();
+    }
+
+    /**
+     * Get the mode of the action.
+     * @return The mode of the action.
+     */
+    public int getEditMode() {
+        return mManager.getEditMode();
+    }
+
+    /**
+     * Get the state of the selection.
+     * @return The state of the selection.
+     */
+    public int getSelectState() {
+        return mManager.getSelectState();
+    }
+
+    /**
+     * Initialize members.
+     */
+    private void init() {
+        if (DBG) {
+            Log.d(LOG_TAG, "--- init");
+            requestFocus();
+        }
+        mManager = new EditStyledTextEditorManager(this);
+    }
+
+    /**
+     * Notify hint messages what action is expected to calling class.
+     * @param msg
+     */
+    private void setHintMessage(int msg_id) {
+        if (mESTInterface != null) {
+            mESTInterface.notifyHintMsg(msg_id);
+        }
+    }
+
+    /**
+     * Object which manages the flow and status of editing actions.
+     */
+    private class EditStyledTextEditorManager {
+        private boolean mEditFlag = false;
+        private int mMode = 0;
+        private int mState = 0;
+        private int mCurStart = 0;
+        private int mCurEnd = 0;
+        private EditStyledText mEST;
+        private Editable mTextSelectBuffer;
+        private CharSequence mTextCopyBufer;
+
+        EditStyledTextEditorManager(EditStyledText est) {
+            mEST = est;
+        }
+
+        public void onStartEdit() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onEdit");
+            }
+            handleResetEdit();
+        }
+
+        public void onEndEdit() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onClickCancel");
+            }
+            handleCancel();
+        }
+
+        public void onStartCopy() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onClickCopy");
+            }
+            handleCopy();
+        }
+
+        public void onStartPaste() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onClickPaste");
+            }
+            handlePaste();
+        }
+
+        public void onStartSize() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onClickSize");
+            }
+            handleSize();
+        }
+
+        public void setItemSize(int size) {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onClickSizeItem");
+            }
+            if (mState == STATE_SELECTED || mState == STATE_SELECT_FIX) {
+                changeSizeSelectedText(size);
+                handleResetEdit();
+            }
+        }
+
+        public void setItemColor(int color) {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onClickColorItem");
+            }
+            if (mState == STATE_SELECTED || mState == STATE_SELECT_FIX) {
+                changeColorSelectedText(color);
+                handleResetEdit();
+            }
+        }
+
+        public void onStartColor() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onClickColor");
+            }
+            handleColor();
+        }
+
+        public void onStartSelect() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onClickSelect");
+            }
+            mMode = MODE_SELECT;
+            if (mState == STATE_SELECT_OFF) {
+                handleSelect();
+            } else {
+                offSelect();
+                handleSelect();
+            }
+        }
+
+        public void onStartSelectAll() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onClickSelectAll");
+            }
+            handleSelectAll();
+        }
+
+        public void onTouchScreen() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onClickView");
+            }
+            if (mState == STATE_SELECT_ON || mState == STATE_SELECTED) {
+                handleSelect();
+            }
+        }
+
+        public void onFixSelectItem() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onClickComplete");
+            }
+            handleComplete();
+        }
+
+        public boolean isEditting() {
+            return mEditFlag;
+        }
+
+        public int getEditMode() {
+            return mMode;
+        }
+
+        public int getSelectState() {
+            return mState;
+        }
+
+        private void handleCancel() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- handleCancel");
+            }
+            mMode = MODE_NOTHING;
+            mState = STATE_SELECT_OFF;
+            mEditFlag = false;
+            offSelect();
+        }
+
+        private void handleComplete() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- handleComplete");
+            }
+            if (!mEditFlag) {
+                return;
+            }
+            if (mState == STATE_SELECTED) {
+                mState = STATE_SELECT_FIX;
+            }
+            switch (mMode) {
+            case MODE_COPY:
+                handleCopy();
+                break;
+            default:
+                break;
+            }
+        }
+
+        private void handleCopy() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- handleCopy: " + mMode + "," + mState);
+            }
+            if (!mEditFlag) {
+                return;
+            }
+            if (mMode == MODE_NOTHING || mMode == MODE_SELECT) {
+                mMode = MODE_COPY;
+                if (mState == STATE_SELECTED) {
+                    mState = STATE_SELECT_FIX;
+                    storeSelectedText();
+                } else {
+                    handleSelect();
+                }
+            } else if (mMode != MODE_COPY) {
+                handleCancel();
+                mMode = MODE_COPY;
+                handleCopy();
+            } else if (mState == STATE_SELECT_FIX) {
+                mEST.setHintMessage(HINT_MSG_NULL);
+                storeSelectedText();
+                handleResetEdit();
+            }
+        }
+
+        private void handlePaste() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- handlePaste");
+            }
+            if (!mEditFlag) {
+                return;
+            }
+            if (mTextSelectBuffer != null && mTextCopyBufer.length() > 0) {
+                mTextSelectBuffer.insert(mEST.getSelectionStart(),
+                        mTextCopyBufer);
+            } else {
+                mEST.setHintMessage(HINT_MSG_COPY_BUF_BLANK);
+            }
+        }
+
+        private void handleSize() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- handleSize: " + mMode + "," + mState);
+            }
+            if (!mEditFlag) {
+                return;
+            }
+            if (mMode == MODE_NOTHING || mMode == MODE_SELECT) {
+                mMode = MODE_SIZE;
+                if (mState == STATE_SELECTED) {
+                    mState = STATE_SELECT_FIX;
+                } else {
+                    handleSelect();
+                }
+            } else if (mMode != MODE_SIZE) {
+                handleCancel();
+                mMode = MODE_SIZE;
+                handleSize();
+            } else if (mState == STATE_SELECT_FIX) {
+                mEST.setHintMessage(HINT_MSG_NULL);
+            }
+        }
+
+        private void handleColor() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- handleColor");
+            }
+            if (!mEditFlag) {
+                return;
+            }
+            if (mMode == MODE_NOTHING || mMode == MODE_SELECT) {
+                mMode = MODE_COLOR;
+                if (mState == STATE_SELECTED) {
+                    mState = STATE_SELECT_FIX;
+                } else {
+                    handleSelect();
+                }
+            } else if (mMode != MODE_COLOR) {
+                handleCancel();
+                mMode = MODE_COLOR;
+                handleSize();
+            } else if (mState == STATE_SELECT_FIX) {
+                mEST.setHintMessage(HINT_MSG_NULL);
+            }
+        }
+
+        private void handleSelect() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- handleSelect" + mEditFlag + "," + mState);
+            }
+            if (!mEditFlag) {
+                return;
+            }
+            if (mState == STATE_SELECT_OFF) {
+                if (isTextSelected()) {
+                    Log.e(LOG_TAG, "Selection state is off, but selected");
+                }
+                setSelectStartPos();
+                mEST.setHintMessage(HINT_MSG_SELECT_END);
+            } else if (mState == STATE_SELECT_ON) {
+                if (isTextSelected()) {
+                    Log.e(LOG_TAG, "Selection state now start, but selected");
+                }
+                setSelectEndPos();
+                mEST.setHintMessage(HINT_MSG_PUSH_COMPETE);
+                doNextHandle();
+            } else if (mState == STATE_SELECTED) {
+                if (!isTextSelected()) {
+                    Log.e(LOG_TAG,
+                            "Selection state is done, but not selected");
+                }
+                setSelectEndPos();
+                doNextHandle();
+            }
+        }
+
+        private void handleSelectAll() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- handleSelectAll");
+            }
+            if (!mEditFlag) {
+                return;
+            }
+            mEST.selectAll();
+        }
+
+        private void doNextHandle() {
+            switch (mMode) {
+            case MODE_COPY:
+                handleCopy();
+                break;
+            case MODE_PASTE:
+                handlePaste();
+                break;
+            case MODE_SIZE:
+                handleSize();
+                break;
+            case MODE_COLOR:
+                handleColor();
+                break;
+            default:
+                break;
+            }
+        }
+
+        private void handleResetEdit() {
+            handleCancel();
+            mEditFlag = true;
+            mEST.setHintMessage(HINT_MSG_SELECT_START);
+        }
+
+        // Methods of selection
+        private void onSelect() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- onSelect");
+            }
+            if (mCurStart >= 0 && mCurStart <= mEST.getText().length()
+                    && mCurEnd >= 0 && mCurEnd <= mEST.getText().length()) {
+                mEST.setSelection(mCurStart, mCurEnd);
+                mState = STATE_SELECTED;
+            } else {
+                Log.e(LOG_TAG,
+                        "Select is on, but cursor positions are illigal.:"
+                                + mEST.getText().length() + "," + mCurStart
+                                + "," + mCurEnd);
+            }
+        }
+
+        private void offSelect() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- offSelect");
+            }
+            int currpos = mEST.getSelectionStart();
+            mEST.setSelection(currpos, currpos);
+            mState = STATE_SELECT_OFF;
+        }
+
+        private void setSelectStartPos() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- setSelectStartPos");
+            }
+            mCurStart = mEST.getSelectionStart();
+            mState = STATE_SELECT_ON;
+        }
+
+        private void setSelectEndPos() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- setSelectEndPos:"
+                        + mEST.getSelectionStart());
+            }
+            int curpos = mEST.getSelectionStart();
+            if (curpos < mCurStart) {
+                if (DBG) {
+                    Log.d(LOG_TAG, "--- setSelectEndPos: swap is done.");
+                }
+                mCurEnd = mCurStart;
+                mCurStart = curpos;
+            } else {
+                mCurEnd = curpos;
+            }
+            onSelect();
+        }
+
+        private boolean isTextSelected() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- isTextSelected:" + mCurStart + ","
+                        + mCurEnd);
+            }
+            return (mCurStart != mCurEnd)
+                    && (mState == STATE_SELECTED ||
+                            mState == STATE_SELECT_FIX);
+        }
+
+        private void storeSelectedText() {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- storeSelectedText");
+            }
+            mTextSelectBuffer = mEST.getText();
+            mTextCopyBufer = mTextSelectBuffer.subSequence(mCurStart, mCurEnd);
+        }
+
+        private void changeSizeSelectedText(int size) {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- changeSizeSelectedText:" + size + ","
+                        + mCurStart + "," + mCurEnd);
+            }
+            mEST.getText().setSpan(new AbsoluteSizeSpan(size), mCurStart,
+                    mCurEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+        }
+
+        private void changeColorSelectedText(int color) {
+            if (DBG) {
+                Log.d(LOG_TAG, "--- changeCollorSelectedText:" + color + ","
+                        + mCurStart + "," + mCurEnd);
+            }
+            mEST.getText().setSpan(new ForegroundColorSpan(color), mCurStart,
+                    mCurEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+        }
+    }
+
+}
diff --git a/core/jni/android/graphics/Typeface.cpp b/core/jni/android/graphics/Typeface.cpp
index 32954ce..e951431 100644
--- a/core/jni/android/graphics/Typeface.cpp
+++ b/core/jni/android/graphics/Typeface.cpp
@@ -32,11 +32,11 @@ static SkTypeface* Typeface_create(JNIEnv* env, jobject, jstring name,
     SkTypeface* face;
 
     if (NULL == name) {
-        face = SkTypeface::Create(NULL, (SkTypeface::Style)style);
+        face = SkTypeface::CreateFromName(NULL, (SkTypeface::Style)style);
     }
     else {
         AutoJavaStringToUTF8    str(env, name);
-        face = SkTypeface::Create(str.c_str(), style);
+        face = SkTypeface::CreateFromName(str.c_str(), style);
     }
     return face;
 }
@@ -50,7 +50,7 @@ static void Typeface_unref(JNIEnv* env, jobject obj, SkTypeface* face) {
 }
 
 static int Typeface_getStyle(JNIEnv* env, jobject obj, SkTypeface* face) {
-    return face->getStyle();
+    return face->style();
 }
 
 class AssetStream : public SkStream {
diff --git a/core/jni/android_text_format_Time.cpp b/core/jni/android_text_format_Time.cpp
index 8e41ec7..923e1aa 100644
--- a/core/jni/android_text_format_Time.cpp
+++ b/core/jni/android_text_format_Time.cpp
@@ -52,6 +52,9 @@ static jfieldID g_dateTimeFormatField = 0;
 static jfieldID g_amField = 0;
 static jfieldID g_pmField = 0;
 static jfieldID g_dateCommandField = 0;
+static jfieldID g_localeField = 0;
+
+static jclass g_timeClass = NULL;
 
 static inline bool java2time(JNIEnv* env, Time* t, jobject o)
 {
@@ -183,56 +186,101 @@ static jstring android_text_format_Time_format2445(JNIEnv* env, jobject This)
 static jstring android_text_format_Time_format(JNIEnv* env, jobject This,
                             jstring formatObject)
 {
-    Time t;
-    struct strftime_locale locale;
-    jclass timeClass = env->FindClass("android/text/format/Time");
-    jstring js_mon[12], js_month[12], js_wday[7], js_weekday[7];
-    jstring js_X_fmt, js_x_fmt, js_c_fmt, js_am, js_pm, js_date_fmt;
-    jobjectArray ja;
+    // We only teardown and setup our 'locale' struct and other state
+    // when the Java-side locale changed.  This is safe to do here
+    // without locking because we're always called from Java code
+    // synchronized on the class instance.
+    static jobject js_locale_previous = NULL;
+    static struct strftime_locale locale;
+    static jstring js_mon[12], js_month[12], js_wday[7], js_weekday[7];
+    static jstring js_X_fmt, js_x_fmt, js_c_fmt, js_am, js_pm, js_date_fmt;
 
+    Time t;
     if (!java2time(env, &t, This)) return env->NewStringUTF("");
 
-    ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_shortMonthsField);
-    for (int i = 0; i < 12; i++) {
-        js_mon[i] = (jstring) env->GetObjectArrayElement(ja, i);
-        locale.mon[i] = env->GetStringUTFChars(js_mon[i], NULL);
-    }
+    jclass timeClass = g_timeClass;
+    jobject js_locale = (jobject) env->GetStaticObjectField(timeClass, g_localeField);
+    if (js_locale_previous != js_locale) {
+        if (js_locale_previous != NULL) {
+            // Free the old one.
+            for (int i = 0; i < 12; i++) {
+                env->ReleaseStringUTFChars(js_mon[i], locale.mon[i]);
+                env->ReleaseStringUTFChars(js_month[i], locale.month[i]);
+                env->DeleteGlobalRef(js_mon[i]);
+                env->DeleteGlobalRef(js_month[i]);
+            }
+
+            for (int i = 0; i < 7; i++) {
+                env->ReleaseStringUTFChars(js_wday[i], locale.wday[i]);
+                env->ReleaseStringUTFChars(js_weekday[i], locale.weekday[i]);
+                env->DeleteGlobalRef(js_wday[i]);
+                env->DeleteGlobalRef(js_weekday[i]);
+            }
+
+            env->ReleaseStringUTFChars(js_X_fmt, locale.X_fmt);
+            env->ReleaseStringUTFChars(js_x_fmt, locale.x_fmt);
+            env->ReleaseStringUTFChars(js_c_fmt, locale.c_fmt);
+            env->ReleaseStringUTFChars(js_am, locale.am);
+            env->ReleaseStringUTFChars(js_pm, locale.pm);
+            env->ReleaseStringUTFChars(js_date_fmt, locale.date_fmt);
+            env->DeleteGlobalRef(js_X_fmt);
+            env->DeleteGlobalRef(js_x_fmt);
+            env->DeleteGlobalRef(js_c_fmt);
+            env->DeleteGlobalRef(js_am);
+            env->DeleteGlobalRef(js_pm);
+            env->DeleteGlobalRef(js_date_fmt);
+        }
+        js_locale_previous = js_locale;
 
-    ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_longMonthsField);
-    for (int i = 0; i < 12; i++) {
-        js_month[i] = (jstring) env->GetObjectArrayElement(ja, i);
-        locale.month[i] = env->GetStringUTFChars(js_month[i], NULL);
-    }
+        jobjectArray ja;
+        ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_shortMonthsField);
+        for (int i = 0; i < 12; i++) {
+            js_mon[i] = (jstring) env->NewGlobalRef(env->GetObjectArrayElement(ja, i));
+            locale.mon[i] = env->GetStringUTFChars(js_mon[i], NULL);
+        }
 
-    ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_shortWeekdaysField);
-    for (int i = 0; i < 7; i++) {
-        js_wday[i] = (jstring) env->GetObjectArrayElement(ja, i);
-        locale.wday[i] = env->GetStringUTFChars(js_wday[i], NULL);
-    }
+        ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_longMonthsField);
+        for (int i = 0; i < 12; i++) {
+            js_month[i] = (jstring) env->NewGlobalRef(env->GetObjectArrayElement(ja, i));
+            locale.month[i] = env->GetStringUTFChars(js_month[i], NULL);
+        }
 
-    ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_longWeekdaysField);
-    for (int i = 0; i < 7; i++) {
-        js_weekday[i] = (jstring) env->GetObjectArrayElement(ja, i);
-        locale.weekday[i] = env->GetStringUTFChars(js_weekday[i], NULL);
-    }
+        ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_shortWeekdaysField);
+        for (int i = 0; i < 7; i++) {
+            js_wday[i] = (jstring) env->NewGlobalRef(env->GetObjectArrayElement(ja, i));
+            locale.wday[i] = env->GetStringUTFChars(js_wday[i], NULL);
+        }
 
-    js_X_fmt = (jstring) env->GetStaticObjectField(timeClass, g_timeOnlyFormatField);
-    locale.X_fmt = env->GetStringUTFChars(js_X_fmt, NULL);
+        ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_longWeekdaysField);
+        for (int i = 0; i < 7; i++) {
+            js_weekday[i] = (jstring) env->NewGlobalRef(env->GetObjectArrayElement(ja, i));
+            locale.weekday[i] = env->GetStringUTFChars(js_weekday[i], NULL);
+        }
+
+        js_X_fmt = (jstring) env->NewGlobalRef(env->GetStaticObjectField(
+                                                       timeClass, g_timeOnlyFormatField));
+        locale.X_fmt = env->GetStringUTFChars(js_X_fmt, NULL);
 
-    js_x_fmt = (jstring) env->GetStaticObjectField(timeClass, g_dateOnlyFormatField);
-    locale.x_fmt = env->GetStringUTFChars(js_x_fmt, NULL);
+        js_x_fmt = (jstring) env->NewGlobalRef(env->GetStaticObjectField(
+                                                       timeClass, g_dateOnlyFormatField));
+        locale.x_fmt = env->GetStringUTFChars(js_x_fmt, NULL);
 
-    js_c_fmt = (jstring) env->GetStaticObjectField(timeClass, g_dateTimeFormatField);
-    locale.c_fmt = env->GetStringUTFChars(js_c_fmt, NULL);
+        js_c_fmt = (jstring) env->NewGlobalRef(env->GetStaticObjectField(
+                                                       timeClass, g_dateTimeFormatField));
+        locale.c_fmt = env->GetStringUTFChars(js_c_fmt, NULL);
 
-    js_am = (jstring) env->GetStaticObjectField(timeClass, g_amField);
-    locale.am = env->GetStringUTFChars(js_am, NULL);
+        js_am = (jstring) env->NewGlobalRef(env->GetStaticObjectField(
+                                                    timeClass, g_amField));
+        locale.am = env->GetStringUTFChars(js_am, NULL);
 
-    js_pm = (jstring) env->GetStaticObjectField(timeClass, g_pmField);
-    locale.pm = env->GetStringUTFChars(js_pm, NULL);
+        js_pm = (jstring) env->NewGlobalRef(env->GetStaticObjectField(
+                                                    timeClass, g_pmField));
+        locale.pm = env->GetStringUTFChars(js_pm, NULL);
 
-    js_date_fmt = (jstring) env->GetStaticObjectField(timeClass, g_dateCommandField);
-    locale.date_fmt = env->GetStringUTFChars(js_date_fmt, NULL);
+        js_date_fmt = (jstring) env->NewGlobalRef(env->GetStaticObjectField(
+                                                          timeClass, g_dateCommandField));
+        locale.date_fmt = env->GetStringUTFChars(js_date_fmt, NULL);
+    }
 
     ACQUIRE_TIMEZONE(This, t)
 
@@ -243,23 +291,6 @@ static jstring android_text_format_Time_format(JNIEnv* env, jobject This,
     env->ReleaseStringUTFChars(formatObject, format);
     RELEASE_TIMEZONE(This, t)
 
-    for (int i = 0; i < 12; i++) {
-        env->ReleaseStringUTFChars(js_mon[i], locale.mon[i]);
-        env->ReleaseStringUTFChars(js_month[i], locale.month[i]);
-    }
-
-    for (int i = 0; i < 7; i++) {
-        env->ReleaseStringUTFChars(js_wday[i], locale.wday[i]);
-        env->ReleaseStringUTFChars(js_weekday[i], locale.weekday[i]);
-    }
-
-    env->ReleaseStringUTFChars(js_X_fmt, locale.X_fmt);
-    env->ReleaseStringUTFChars(js_x_fmt, locale.x_fmt);
-    env->ReleaseStringUTFChars(js_c_fmt, locale.c_fmt);
-    env->ReleaseStringUTFChars(js_am, locale.am);
-    env->ReleaseStringUTFChars(js_pm, locale.pm);
-    env->ReleaseStringUTFChars(js_date_fmt, locale.date_fmt);
-
     return env->NewStringUTF(r.string());
 }
 
@@ -307,7 +338,6 @@ static void android_text_format_Time_set(JNIEnv* env, jobject This, jlong millis
 {
     env->SetBooleanField(This, g_allDayField, JNI_FALSE);
     Time t;
-    if (!java2time(env, &t, This)) return;
     ACQUIRE_TIMEZONE(This, t)
 
     t.set(millis);
@@ -592,6 +622,8 @@ int register_android_text_format_Time(JNIEnv* env)
 {
     jclass timeClass = env->FindClass("android/text/format/Time");
 
+    g_timeClass = (jclass) env->NewGlobalRef(timeClass);
+
     g_allDayField = env->GetFieldID(timeClass, "allDay", "Z");
     g_secField = env->GetFieldID(timeClass, "second", "I");
     g_minField = env->GetFieldID(timeClass, "minute", "I");
@@ -615,9 +647,9 @@ int register_android_text_format_Time(JNIEnv* env)
     g_amField = env->GetStaticFieldID(timeClass, "sAm", "Ljava/lang/String;");
     g_pmField = env->GetStaticFieldID(timeClass, "sPm", "Ljava/lang/String;");
     g_dateCommandField = env->GetStaticFieldID(timeClass, "sDateCommand", "Ljava/lang/String;");
+    g_localeField = env->GetStaticFieldID(timeClass, "sLocale", "Ljava/util/Locale;");
 
     return AndroidRuntime::registerNativeMethods(env, "android/text/format/Time", gMethods, NELEM(gMethods));
 }
 
 }; // namespace android
-
diff --git a/core/res/assets/webkit/nullplugin.png b/core/res/assets/webkit/nullPlugin.png
index 96a52e3..96a52e3 100644
--- a/core/res/assets/webkit/nullplugin.png
+++ b/core/res/assets/webkit/nullPlugin.png
diff --git a/core/res/res/anim/zoom_ring_enter.xml b/core/res/res/anim/zoom_ring_enter.xml
new file mode 100644
index 0000000..13d89b2
--- /dev/null
+++ b/core/res/res/anim/zoom_ring_enter.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/* //device/apps/common/res/anim/fade_in.xml
+**
+** Copyright 2007, 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.
+*/
+-->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+        android:interpolator="@anim/decelerate_interpolator">
+    <scale android:fromXScale="0.75" android:toXScale="1.0"
+           android:fromYScale="0.75" android:toYScale="1.0"
+           android:pivotX="50%" android:pivotY="50%"
+           android:duration="75" />
+    <alpha android:fromAlpha="0.0" android:toAlpha="1.0"
+            android:duration="75" />
+</set>
diff --git a/core/res/res/anim/zoom_ring_exit.xml b/core/res/res/anim/zoom_ring_exit.xml
new file mode 100644
index 0000000..177a4c3
--- /dev/null
+++ b/core/res/res/anim/zoom_ring_exit.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/* //device/apps/common/res/anim/fade_out.xml
+**
+** Copyright 2007, 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.
+*/
+-->
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+        android:interpolator="@anim/accelerate_interpolator">
+    <scale android:fromXScale="1.0" android:toXScale="0.75"
+           android:fromYScale="1.0" android:toYScale="0.75"
+           android:pivotX="50%" android:pivotY="50%"
+           android:duration="75" />
+    <alpha android:fromAlpha="1.0" android:toAlpha="0.0"
+            android:duration="75"/>
+</set>
diff --git a/core/res/res/values/attrs.xml b/core/res/res/values/attrs.xml
index 44da1d5..30b26fa 100644
--- a/core/res/res/values/attrs.xml
+++ b/core/res/res/values/attrs.xml
@@ -371,6 +371,8 @@
         <attr name="spinnerItemStyle" format="reference" />
         <!-- Default MapView style. -->
         <attr name="mapViewStyle" format="reference" />
+        <!-- Default ZoomRing style. -->
+        <attr name="zoomRingStyle" format="reference" />
 
         <!-- =================== -->
         <!-- Preference styles   -->
@@ -529,10 +531,23 @@
              {@link android.text.InputType#TYPE_CLASS_TEXT} |
              {@link android.text.InputType#TYPE_TEXT_VARIATION_PASSWORD}. -->
         <flag name="textPassword" value="0x00000081" />
+        <!-- Text that is a password that should be visible.  Corresponds to
+             {@link android.text.InputType#TYPE_CLASS_TEXT} |
+             {@link android.text.InputType#TYPE_TEXT_VARIATION_VISIBLE_PASSWORD}. -->
+        <flag name="textVisiblePassword" value="0x00000091" />
         <!-- Text that is being supplied as text in a web form.  Corresponds to
              {@link android.text.InputType#TYPE_CLASS_TEXT} |
              {@link android.text.InputType#TYPE_TEXT_VARIATION_WEB_EDIT_TEXT}. -->
-        <flag name="textWebEditText" value="0x00000091" />
+        <flag name="textWebEditText" value="0x000000a1" />
+        <!-- Text that is filtering some other data.  Corresponds to
+             {@link android.text.InputType#TYPE_CLASS_TEXT} |
+             {@link android.text.InputType#TYPE_TEXT_VARIATION_FILTER}. -->
+        <flag name="textFilter" value="0x000000b1" />
+        <!-- Text that is for phonetic pronunciation, such as a phonetic name
+             field in a contact entry.  Corresponds to
+             {@link android.text.InputType#TYPE_CLASS_TEXT} |
+             {@link android.text.InputType#TYPE_TEXT_VARIATION_PHONETIC}. -->
+        <flag name="textPhonetic" value="0x000000c1" />
         <!-- A numeric only field.  Corresponds to
              {@link android.text.InputType#TYPE_CLASS_NUMBER}. -->
         <flag name="number" value="0x00000002" />
@@ -1920,6 +1935,34 @@
         </attr>
         <attr name="inputType" />
     </declare-styleable>
+    <declare-styleable name="ZoomRing">
+        <!-- Defines the drawable used as the thumb. -->
+        <attr name="thumbDrawable" format="reference" />
+        <!-- Defines the distance of the thumb from the center of the ring. -->
+        <attr name="thumbDistance" format="dimension" />
+        <!-- Defines the distance from the center of the ring to the beginning of the track. -->
+        <attr name="trackInnerRadius" format="dimension" />
+        <!-- Defines the distance from the center of the ring to the end of the track. -->
+        <attr name="trackOuterRadius" format="dimension" />
+        <!-- Defines the drawable used as a hint to show which direction is zoom in. This should be
+             the same size as the zoom ring's asset.  It will be rotated programmatically. -->
+        <attr name="zoomInArrowDrawable" format="reference" />
+        <!-- Defines the drawable used as a hint to show which direction is zoom out. This should be
+             the same size as the zoom ring's asset.  It will be rotated programmatically. -->
+        <attr name="zoomOutArrowDrawable" format="reference" />
+        <!-- Defines the drawable that is laid on top of the zoom in arrow.
+             For example, this could be a +. -->
+        <attr name="zoomInArrowHintDrawable" format="reference" />
+        <!-- Defines the drawable that is laid on top of the zoom out arrow.
+             For example, this could be a -. -->
+        <attr name="zoomOutArrowHintDrawable" format="reference" />
+        <!-- Defines the distance of the zoom arrow hint from the center of the ring. -->
+        <attr name="zoomArrowHintDistance" format="dimension" />
+        <!-- Defines the offset of the zoom arrow hints from the thumb. Valid ranges are [0, 359] -->
+        <attr name="zoomArrowHintOffsetAngle" format="integer" />
+        <!-- Defines the drawable used to hint that the zoom ring can pan its owner. -->
+        <attr name="panningArrowsDrawable" format="reference" />
+    </declare-styleable>    
     <declare-styleable name="PopupWindow">
         <attr name="popupBackground" format="reference|color" />
     </declare-styleable>
@@ -2183,7 +2226,9 @@
     </declare-styleable>
     
     <declare-styleable name="LevelListDrawableItem">
+        <!-- The minimum level allowed for this item. -->
         <attr name="minLevel" format="integer" />
+        <!-- The maximum level allowed for this item. -->
         <attr name="maxLevel" format="integer" />
         <attr name="drawable" />
     </declare-styleable>
diff --git a/core/res/res/values/strings.xml b/core/res/res/values/strings.xml
index 346fa80..d54bca3 100644
--- a/core/res/res/values/strings.xml
+++ b/core/res/res/values/strings.xml
@@ -1565,7 +1565,7 @@
          want a 24-hour clock.
          You can remove the colon
          or make other punctuation changes appropriate for your locale. -->
-    <string name="twenty_four_hour_time_format" format="date"><xliff:g id="hour" example="23">H</xliff:g>:<xliff:g id="minute" example="59">mm</xliff:g></string>
+    <string name="twenty_four_hour_time_format" format="date"><xliff:g id="hour" example="23">HH</xliff:g>:<xliff:g id="minute" example="59">mm</xliff:g></string>
 
     <!-- Quoted name for 12pm, lowercase -->
     <string name="noon">"noon"</string>
@@ -2293,6 +2293,9 @@
     <!-- Long label for a button on a full-screen input method for the "Next" action. -->
     <string name="ime_action_next">Next</string>
     
+    <!-- Long label for a button on a full-screen input method for the "Done" action. -->
+    <string name="ime_action_done">Done</string>
+    
     <!-- Long label for a button on a full-screen input method for an unknown action. -->
     <string name="ime_action_default">Execute</string>
     
diff --git a/core/res/res/values/styles.xml b/core/res/res/values/styles.xml
index 54eba62..9f4d82e 100644
--- a/core/res/res/values/styles.xml
+++ b/core/res/res/values/styles.xml
@@ -144,6 +144,11 @@
         <item name="windowExitAnimation">@anim/search_bar_exit</item>
     </style>
 
+    <!-- Standard animations for the zoom ring. -->
+    <style name="Animation.ZoomRing">
+        <item name="windowEnterAnimation">@anim/zoom_ring_enter</item>
+        <item name="windowExitAnimation">@anim/zoom_ring_exit</item>
+    </style>
     <!-- Status Bar Styles -->
 
     <style name="TextAppearance.StatusBarTitle">
@@ -456,6 +461,21 @@
         <item name="android:shadowRadius">2.75</item>
     </style>
 
+    <style name="Widget.ZoomRing">
+        <item name="android:background">@android:drawable/zoom_ring_track</item>
+        <item name="android:thumbDrawable">@android:drawable/zoom_ring_thumb</item>
+        <item name="android:thumbDistance">63dip</item>
+        <item name="android:trackInnerRadius">43dip</item>
+        <item name="android:trackOuterRadius">91dip</item>
+        <item name="android:zoomInArrowDrawable">@android:drawable/zoom_ring_thumb_plus_arrow_rotatable</item>
+        <item name="android:zoomOutArrowDrawable">@android:drawable/zoom_ring_thumb_minus_arrow_rotatable</item>
+        <item name="android:zoomInArrowHintDrawable">@android:drawable/zoom_ring_thumb_plus</item>
+        <item name="android:zoomOutArrowHintDrawable">@android:drawable/zoom_ring_thumb_minus</item>
+        <item name="android:zoomArrowHintDistance">69dip</item>
+        <item name="android:zoomArrowHintOffsetAngle">33</item>
+        <item name="android:panningArrowsDrawable">@android:drawable/zoom_ring_arrows</item>
+    </style>
+
     <!-- Text Appearances -->
     <eat-comment />
 
diff --git a/core/res/res/values/themes.xml b/core/res/res/values/themes.xml
index 01c46de..bde6b2a 100644
--- a/core/res/res/values/themes.xml
+++ b/core/res/res/values/themes.xml
@@ -162,6 +162,7 @@
         <item name="spinnerItemStyle">@android:style/Widget.TextView.SpinnerItem</item>
         <item name="dropDownHintAppearance">@android:style/TextAppearance.Widget.DropDownHint</item>
         <item name="keyboardViewStyle">@android:style/Widget.KeyboardView</item>
+        <item name="zoomRingStyle">@android:style/Widget.ZoomRing</item>
         
         <!-- Preference styles -->
         <item name="preferenceScreenStyle">@android:style/Preference.PreferenceScreen</item>