diff --git a/src/com/android/launcher2/AppsCustomizePagedView.java b/src/com/android/launcher2/AppsCustomizePagedView.java
index ca11c1e..714e7f9 100644
--- a/src/com/android/launcher2/AppsCustomizePagedView.java
+++ b/src/com/android/launcher2/AppsCustomizePagedView.java
@@ -40,12 +40,12 @@
 import android.util.AttributeSet;
 import android.util.Log;
 import android.view.LayoutInflater;
+import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.animation.AccelerateInterpolator;
 import android.widget.GridLayout;
 import android.widget.ImageView;
-import android.widget.TextView;
 import android.widget.Toast;
 
 import com.android.launcher.R;
@@ -244,8 +244,12 @@
     }
 
     @Override
-    protected void onWallpaperTap(android.view.MotionEvent ev) {
-        mLauncher.showWorkspace(true);
+    protected void onWallpaperTap(MotionEvent ev) {
+        int action = ev.getAction();
+        if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_DOWN) {
+            // Dismiss AppsCustomize if we tap
+            mLauncher.showWorkspace(true);
+        }
     }
 
     /**
diff --git a/src/com/android/launcher2/CellLayout.java b/src/com/android/launcher2/CellLayout.java
index de9c188..65ca162 100644
--- a/src/com/android/launcher2/CellLayout.java
+++ b/src/com/android/launcher2/CellLayout.java
@@ -715,7 +715,6 @@
                     cellInfo.cellY = lp.cellY;
                     cellInfo.spanX = lp.cellHSpan;
                     cellInfo.spanY = lp.cellVSpan;
-                    cellInfo.valid = true;
                     found = true;
                     break;
                 }
@@ -731,8 +730,6 @@
             cellInfo.cellY = cellXY[1];
             cellInfo.spanX = 1;
             cellInfo.spanY = 1;
-            cellInfo.valid = cellXY[0] >= 0 && cellXY[1] >= 0 && cellXY[0] < mCountX &&
-                    cellXY[1] < mCountY && !mOccupied[cellXY[0]][cellXY[1]];
         }
         setTag(cellInfo);
     }
@@ -753,7 +750,6 @@
             cellInfo.cellY = -1;
             cellInfo.spanX = 0;
             cellInfo.spanY = 0;
-            cellInfo.valid = false;
             setTag(cellInfo);
         }
 
@@ -1848,7 +1844,6 @@
         int spanY;
         int screen;
         long container;
-        boolean valid;
 
         @Override
         public String toString() {
diff --git a/src/com/android/launcher2/DeleteDropTarget.java b/src/com/android/launcher2/DeleteDropTarget.java
index 2c84c78..e76ab31 100644
--- a/src/com/android/launcher2/DeleteDropTarget.java
+++ b/src/com/android/launcher2/DeleteDropTarget.java
@@ -34,7 +34,7 @@
 
 public class DeleteDropTarget extends ButtonDropTarget {
 
-    private static int DELETE_ANIMATION_DURATION = 220;
+    private static int DELETE_ANIMATION_DURATION = 250;
     private ColorStateList mOriginalTextColor;
     private TransitionDrawable mDrawable;
     private int mHoverColor = 0xFFFF0000;
@@ -175,9 +175,9 @@
                 completeDrop(d);
             }
         };
-        dragLayer.animateView(d.dragView, from, to, 0f, 0.1f,
+        dragLayer.animateView(d.dragView, from, to, 0.1f, 0.1f,
                 DELETE_ANIMATION_DURATION, new DecelerateInterpolator(2),
-                new AccelerateInterpolator(2), onAnimationEndRunnable, false);
+                new DecelerateInterpolator(1.5f), onAnimationEndRunnable, false);
     }
 
     private void completeDrop(DragObject d) {
diff --git a/src/com/android/launcher2/FolderIcon.java b/src/com/android/launcher2/FolderIcon.java
index 93f56fb..949a25e 100644
--- a/src/com/android/launcher2/FolderIcon.java
+++ b/src/com/android/launcher2/FolderIcon.java
@@ -321,7 +321,10 @@
         Rect to = finalRect;
         if (to == null) {
             to = new Rect();
+            Workspace workspace = mLauncher.getWorkspace();
+            workspace.setFinalTransitionTransform((CellLayout) getParent().getParent());
             scaleRelativeToDragLayer = dragLayer.getDescendantRectRelativeToSelf(this, to);
+            workspace.resetTransitionTransform((CellLayout) getParent().getParent());
         }
 
         int[] center = new int[2];
diff --git a/src/com/android/launcher2/Launcher.java b/src/com/android/launcher2/Launcher.java
index 3050be4..af8d986 100644
--- a/src/com/android/launcher2/Launcher.java
+++ b/src/com/android/launcher2/Launcher.java
@@ -1233,11 +1233,11 @@
                         != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
 
             // In all these cases, only animate if we're already on home
-            mWorkspace.unshrink(alreadyOnHome);
             mWorkspace.exitWidgetResizeMode();
             if (alreadyOnHome && mState == State.WORKSPACE && !mWorkspace.isTouchActive()) {
                 mWorkspace.moveToDefaultScreen(true);
             }
+            exitSpringLoadedDragMode();
             showWorkspace(alreadyOnHome);
 
             final View v = getWindow().peekDecorView();
@@ -1950,7 +1950,7 @@
         resetAddInfo();
         CellLayout.CellInfo longClickCellInfo = (CellLayout.CellInfo) v.getTag();
         // This happens when long clicking an item with the dpad/trackball
-        if (longClickCellInfo == null || !longClickCellInfo.valid) {
+        if (longClickCellInfo == null) {
             return true;
         }
 
diff --git a/src/com/android/launcher2/Workspace.java b/src/com/android/launcher2/Workspace.java
index e71e0f8..035d9ea 100644
--- a/src/com/android/launcher2/Workspace.java
+++ b/src/com/android/launcher2/Workspace.java
@@ -164,6 +164,10 @@
     private AnimatorSet mAnimator;
     private AnimatorListener mShrinkAnimationListener;
     private AnimatorListener mUnshrinkAnimationListener;
+    // Working around the face that cancelled animations may not actually be cancelled if they
+    // are cancelled before starting
+    private boolean mShrinkAnimationEnabled;
+    private boolean mUnshrinkAnimationEnabled;
 
     boolean mAnimatingViewIntoPlace = false;
     boolean mIsDragOccuring = false;
@@ -207,6 +211,30 @@
     final static float MAX_SWIPE_ANGLE = (float) Math.PI / 3;
     final static float TOUCH_SLOP_DAMPING_FACTOR = 4;
 
+    // These variables are used for storing the initial and final values during workspace animations
+    private float mCurrentScaleX;
+    private float mCurrentScaleY;
+    private float mCurrentRotationY;
+    private float mCurrentTranslationX;
+    private float mCurrentTranslationY;
+    private float[] mOldTranslationXs;
+    private float[] mOldTranslationYs;
+    private float[] mOldScaleXs;
+    private float[] mOldScaleYs;
+    private float[] mOldBackgroundAlphas;
+    private float[] mOldBackgroundAlphaMultipliers;
+    private float[] mOldAlphas;
+    private float[] mOldRotationYs;
+    private float[] mNewTranslationXs;
+    private float[] mNewTranslationYs;
+    private float[] mNewScaleXs;
+    private float[] mNewScaleYs;
+    private float[] mNewBackgroundAlphas;
+    private float[] mNewBackgroundAlphaMultipliers;
+    private float[] mNewAlphas;
+    private float[] mNewRotationYs;
+    private float mTransitionProgress;
+
     /**
      * Used to inflate the Workspace from XML.
      *
@@ -1370,22 +1398,12 @@
         }
 
         mAnimator = new AnimatorSet();
+        // Workaround the AnimatorSet cancel bug...
+        mUnshrinkAnimationEnabled = false;
+        mShrinkAnimationEnabled = true;
 
         final int childCount = getChildCount();
-        final float[] oldXs = new float[childCount];
-        final float[] oldYs = new float[childCount];
-        final float[] oldScaleXs = new float[childCount];
-        final float[] oldScaleYs = new float[childCount];
-        final float[] oldBackgroundAlphas = new float[childCount];
-        final float[] oldAlphas = new float[childCount];
-        final float[] oldRotationYs = new float[childCount];
-        final float[] newXs = new float[childCount];
-        final float[] newYs = new float[childCount];
-        final float[] newScaleXs = new float[childCount];
-        final float[] newScaleYs = new float[childCount];
-        final float[] newBackgroundAlphas = new float[childCount];
-        final float[] newAlphas = new float[childCount];
-        final float[] newRotationYs = new float[childCount];
+        initAnimationArrays();
 
         for (int i = 0; i < screenCount; i++) {
             final CellLayout cl = (CellLayout) getChildAt(i);
@@ -1394,26 +1412,26 @@
             float rotationScaleX = (float) (1.0f / Math.cos(Math.PI * rotation / 180.0f));
             float rotationScaleY = getYScaleForScreen(i);
 
-            oldAlphas[i] = cl.getAlpha();
-            newAlphas[i] = finalAlpha;
-            if (animated && (oldAlphas[i] != 0f || newAlphas[i] != 0f)) {
+            mOldAlphas[i] = cl.getAlpha();
+            mNewAlphas[i] = finalAlpha;
+            if (animated && (mOldAlphas[i] != 0f || mNewAlphas[i] != 0f)) {
                 // if the CellLayout will be visible during the animation, force building its
                 // hardware layer immediately so we don't see a blip later in the animation
                 cl.buildChildrenLayer();
             }
             if (animated) {
-                oldXs[i] = cl.getX();
-                oldYs[i] = cl.getY();
-                oldScaleXs[i] = cl.getScaleX();
-                oldScaleYs[i] = cl.getScaleY();
-                oldBackgroundAlphas[i] = cl.getBackgroundAlpha();
-                oldRotationYs[i] = cl.getRotationY();
-                newXs[i] = x;
-                newYs[i] = y;
-                newScaleXs[i] = shrinkFactor * rotationScaleX * extraShrinkFactor;
-                newScaleYs[i] = shrinkFactor * rotationScaleY * extraShrinkFactor;
-                newBackgroundAlphas[i] = finalAlpha;
-                newRotationYs[i] = rotation;
+                mOldTranslationXs[i] = cl.getX();
+                mOldTranslationYs[i] = cl.getY();
+                mOldScaleXs[i] = cl.getScaleX();
+                mOldScaleYs[i] = cl.getScaleY();
+                mOldBackgroundAlphas[i] = cl.getBackgroundAlpha();
+                mOldRotationYs[i] = cl.getRotationY();
+                mNewTranslationXs[i] = x;
+                mNewTranslationYs[i] = y;
+                mNewScaleXs[i] = shrinkFactor * rotationScaleX * extraShrinkFactor;
+                mNewScaleYs[i] = shrinkFactor * rotationScaleY * extraShrinkFactor;
+                mNewBackgroundAlphas[i] = finalAlpha;
+                mNewRotationYs[i] = rotation;
             } else {
                 cl.setX((int)x);
                 cl.setY((int)y);
@@ -1473,6 +1491,8 @@
             final float newVerticalWallpaperOffset = wallpaperOffset;
             animWithInterpolator.addUpdateListener(new LauncherAnimatorUpdateListener() {
                 public void onAnimationUpdate(float a, float b) {
+                    if (!mShrinkAnimationEnabled) return;
+                    mTransitionProgress = b;
                     if (b == 0f) {
                         // an optimization, and required for correct behavior.
                         return;
@@ -1487,14 +1507,14 @@
                     for (int i = 0; i < screenCount; i++) {
                         final CellLayout cl = (CellLayout) getChildAt(i);
                         cl.fastInvalidate();
-                        cl.setFastX(a * oldXs[i] + b * newXs[i]);
-                        cl.setFastY(a * oldYs[i] + b * newYs[i]);
-                        cl.setFastScaleX(a * oldScaleXs[i] + b * newScaleXs[i]);
-                        cl.setFastScaleY(a * oldScaleYs[i] + b * newScaleYs[i]);
+                        cl.setFastX(a * mOldTranslationXs[i] + b * mNewTranslationXs[i]);
+                        cl.setFastY(a * mOldTranslationYs[i] + b * mNewTranslationYs[i]);
+                        cl.setFastScaleX(a * mOldScaleXs[i] + b * mNewScaleXs[i]);
+                        cl.setFastScaleY(a * mOldScaleYs[i] + b * mNewScaleYs[i]);
                         cl.setFastBackgroundAlpha(
-                                a * oldBackgroundAlphas[i] + b * newBackgroundAlphas[i]);
-                        cl.setFastAlpha(a * oldAlphas[i] + b * newAlphas[i]);
-                        cl.setFastRotationY(a * oldRotationYs[i] + b * newRotationYs[i]);
+                                a * mOldBackgroundAlphas[i] + b * mNewBackgroundAlphas[i]);
+                        cl.setFastAlpha(a * mOldAlphas[i] + b * mNewAlphas[i]);
+                        cl.setFastRotationY(a * mOldRotationYs[i] + b * mNewRotationYs[i]);
                     }
                 }
             });
@@ -1646,6 +1666,27 @@
         unshrink(animated, false);
     }
 
+    private void initAnimationArrays() {
+        final int childCount = getChildCount();
+        if (mOldTranslationXs != null) return;
+        mOldTranslationXs = new float[childCount];
+        mOldTranslationYs = new float[childCount];
+        mOldScaleXs = new float[childCount];
+        mOldScaleYs = new float[childCount];
+        mOldBackgroundAlphas = new float[childCount];
+        mOldBackgroundAlphaMultipliers = new float[childCount];
+        mOldAlphas = new float[childCount];
+        mOldRotationYs = new float[childCount];
+        mNewTranslationXs = new float[childCount];
+        mNewTranslationYs = new float[childCount];
+        mNewScaleXs = new float[childCount];
+        mNewScaleYs = new float[childCount];
+        mNewBackgroundAlphas = new float[childCount];
+        mNewBackgroundAlphaMultipliers = new float[childCount];
+        mNewAlphas = new float[childCount];
+        mNewRotationYs = new float[childCount];
+    }
+
     void unshrink(boolean animated, boolean springLoaded) {
         if (isSmall()) {
             float finalScaleFactor = 1.0f;
@@ -1662,27 +1703,15 @@
             }
 
             mAnimator = new AnimatorSet();
+
+            // Workaround the AnimatorSet cancel bug...
+            mShrinkAnimationEnabled = false;
+            mUnshrinkAnimationEnabled = true;
+
             final int screenCount = getChildCount();
+            initAnimationArrays();
 
             final int duration = getResources().getInteger(R.integer.config_workspaceUnshrinkTime);
-
-            final float[] oldTranslationXs = new float[getChildCount()];
-            final float[] oldTranslationYs = new float[getChildCount()];
-            final float[] oldScaleXs = new float[getChildCount()];
-            final float[] oldScaleYs = new float[getChildCount()];
-            final float[] oldBackgroundAlphas = new float[getChildCount()];
-            final float[] oldBackgroundAlphaMultipliers = new float[getChildCount()];
-            final float[] oldAlphas = new float[getChildCount()];
-            final float[] oldRotationYs = new float[getChildCount()];
-            final float[] newTranslationXs = new float[getChildCount()];
-            final float[] newTranslationYs = new float[getChildCount()];
-            final float[] newScaleXs = new float[getChildCount()];
-            final float[] newScaleYs = new float[getChildCount()];
-            final float[] newBackgroundAlphas = new float[getChildCount()];
-            final float[] newBackgroundAlphaMultipliers = new float[getChildCount()];
-            final float[] newAlphas = new float[getChildCount()];
-            final float[] newRotationYs = new float[getChildCount()];
-
             for (int i = 0; i < screenCount; i++) {
                 final CellLayout cl = (CellLayout)getChildAt(i);
                 float finalAlphaValue = 0f;
@@ -1711,24 +1740,24 @@
                     translation = getOffsetXForRotation(rotation, cl.getWidth(), cl.getHeight());
                 }
 
-                oldAlphas[i] = cl.getAlpha();
-                newAlphas[i] = finalAlphaValue;
+                mOldAlphas[i] = cl.getAlpha();
+                mNewAlphas[i] = finalAlphaValue;
                 if (animated) {
-                    oldTranslationXs[i] = cl.getTranslationX();
-                    oldTranslationYs[i] = cl.getTranslationY();
-                    oldScaleXs[i] = cl.getScaleX();
-                    oldScaleYs[i] = cl.getScaleY();
-                    oldBackgroundAlphas[i] = cl.getBackgroundAlpha();
-                    oldBackgroundAlphaMultipliers[i] = cl.getBackgroundAlphaMultiplier();
-                    oldRotationYs[i] = cl.getRotationY();
+                    mOldTranslationXs[i] = cl.getTranslationX();
+                    mOldTranslationYs[i] = cl.getTranslationY();
+                    mOldScaleXs[i] = cl.getScaleX();
+                    mOldScaleYs[i] = cl.getScaleY();
+                    mOldBackgroundAlphas[i] = cl.getBackgroundAlpha();
+                    mOldBackgroundAlphaMultipliers[i] = cl.getBackgroundAlphaMultiplier();
+                    mOldRotationYs[i] = cl.getRotationY();
 
-                    newTranslationXs[i] = translation;
-                    newTranslationYs[i] = 0f;
-                    newScaleXs[i] = finalScaleFactor;
-                    newScaleYs[i] = finalScaleFactor;
-                    newBackgroundAlphas[i] = finalBackgroundAlpha;
-                    newBackgroundAlphaMultipliers[i] = finalAlphaMultiplierValue;
-                    newRotationYs[i] = rotation;
+                    mNewTranslationXs[i] = translation;
+                    mNewTranslationYs[i] = 0f;
+                    mNewScaleXs[i] = finalScaleFactor;
+                    mNewScaleYs[i] = finalScaleFactor;
+                    mNewBackgroundAlphas[i] = finalBackgroundAlpha;
+                    mNewBackgroundAlphaMultipliers[i] = finalAlphaMultiplierValue;
+                    mNewRotationYs[i] = rotation;
                 } else {
                     cl.setTranslationX(translation);
                     cl.setTranslationY(0.0f);
@@ -1781,6 +1810,8 @@
                 final float newVerticalWallpaperOffset = enableWallpaperEffects ? 0.5f : 0;
                 animWithInterpolator.addUpdateListener(new LauncherAnimatorUpdateListener() {
                     public void onAnimationUpdate(float a, float b) {
+                        if (!mUnshrinkAnimationEnabled) return;
+                        mTransitionProgress = b;
                         if (b == 0f) {
                             // an optimization, but not required
                             return;
@@ -1796,16 +1827,16 @@
                             final CellLayout cl = (CellLayout) getChildAt(i);
                             cl.fastInvalidate();
                             cl.setFastTranslationX(
-                                    a * oldTranslationXs[i] + b * newTranslationXs[i]);
+                                    a * mOldTranslationXs[i] + b * mNewTranslationXs[i]);
                             cl.setFastTranslationY(
-                                    a * oldTranslationYs[i] + b * newTranslationYs[i]);
-                            cl.setFastScaleX(a * oldScaleXs[i] + b * newScaleXs[i]);
-                            cl.setFastScaleY(a * oldScaleYs[i] + b * newScaleYs[i]);
+                                    a * mOldTranslationYs[i] + b * mNewTranslationYs[i]);
+                            cl.setFastScaleX(a * mOldScaleXs[i] + b * mNewScaleXs[i]);
+                            cl.setFastScaleY(a * mOldScaleYs[i] + b * mNewScaleYs[i]);
                             cl.setFastBackgroundAlpha(
-                                    a * oldBackgroundAlphas[i] + b * newBackgroundAlphas[i]);
-                            cl.setBackgroundAlphaMultiplier(a * oldBackgroundAlphaMultipliers[i] +
-                                    b * newBackgroundAlphaMultipliers[i]);
-                            cl.setFastAlpha(a * oldAlphas[i] + b * newAlphas[i]);
+                                    a * mOldBackgroundAlphas[i] + b * mNewBackgroundAlphas[i]);
+                            cl.setBackgroundAlphaMultiplier(a * mOldBackgroundAlphaMultipliers[i] +
+                                    b * mNewBackgroundAlphaMultipliers[i]);
+                            cl.setFastAlpha(a * mOldAlphas[i] + b * mNewAlphas[i]);
                         }
                     }
                 });
@@ -1815,6 +1846,7 @@
                 rotationAnim.setInterpolator(new DecelerateInterpolator(2.0f));
                 rotationAnim.addUpdateListener(new LauncherAnimatorUpdateListener() {
                     public void onAnimationUpdate(float a, float b) {
+                        if (!mUnshrinkAnimationEnabled) return;
                         // don't invalidate workspace because we did it above
                         if (b == 0f) {
                             // an optimization, but not required
@@ -1822,7 +1854,7 @@
                         }
                         for (int i = 0; i < screenCount; i++) {
                             final CellLayout cl = (CellLayout) getChildAt(i);
-                            cl.setFastRotationY(a * oldRotationYs[i] + b * newRotationYs[i]);
+                            cl.setFastRotationY(a * mOldRotationYs[i] + b * mNewRotationYs[i]);
                         }
                     }
                 });
@@ -2037,6 +2069,10 @@
                 cellXY[1]);
     }
 
+    public boolean transitionStateShouldAllowDrop() {
+        return (!isSwitchingState() || mTransitionProgress > 0.5f);
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -2047,6 +2083,7 @@
             if (mDragTargetLayout == null) {
                 return false;
             }
+            if (!transitionStateShouldAllowDrop()) return false;
 
             mDragViewVisualCenter = getDragViewVisualCenter(d.x, d.y, d.xOffset, d.yOffset,
                     d.dragView, mDragViewVisualCenter);
@@ -2222,7 +2259,9 @@
 
             if (continueDrop && dropTargetLayout != null) {
                 // Move internally
-                long container = mLauncher.isHotseatLayout(dropTargetLayout) ?
+                boolean hasMovedLayouts = (getParentCellLayoutForView(cell) != dropTargetLayout);
+                boolean hasMovedIntoHotseat = mLauncher.isHotseatLayout(dropTargetLayout);
+                long container = hasMovedIntoHotseat ?
                         LauncherSettings.Favorites.CONTAINER_HOTSEAT :
                         LauncherSettings.Favorites.CONTAINER_DESKTOP;
                 int screen = (mTargetCell[0] < 0) ?
@@ -2235,8 +2274,7 @@
                         mDragViewVisualCenter[1], spanX, spanY, dropTargetLayout, mTargetCell);
                 // If the item being dropped is a shortcut and the nearest drop
                 // cell also contains a shortcut, then create a folder with the two shortcuts.
-                boolean dropInscrollArea = mCurrentPage != screen && screen > -1;
-
+                boolean dropInscrollArea = hasMovedLayouts && !hasMovedIntoHotseat;
                 if (!dropInscrollArea && createUserFolderIfNecessary(cell, container,
                         dropTargetLayout, mTargetCell, false, d.dragView, null)) {
                     return;
@@ -2258,7 +2296,7 @@
 
 
                 if (mTargetCell[0] >= 0 && mTargetCell[1] >= 0) {
-                    if (screen != mDragInfo.screen) {
+                    if (hasMovedLayouts) {
                         // Reparent the view
                         getParentCellLayoutForView(cell).removeView(cell);
                         addInScreen(cell, container, screen, mTargetCell[0], mTargetCell[1],
@@ -2950,8 +2988,10 @@
 
             RectF r = new RectF();
             cellLayout.cellToRect(mTargetCell[0], mTargetCell[1], spanX, spanY, r);
+            setFinalTransitionTransform(cellLayout);
             float cellLayoutScale =
                     mLauncher.getDragLayer().getDescendantCoordRelativeToSelf(cellLayout, loc);
+            resetTransitionTransform(cellLayout);
 
             float dragViewScale =  r.width() / d.dragView.getMeasuredWidth();
             // The animation will scale the dragView about its center, so we need to center about
@@ -3016,12 +3056,48 @@
                     lp.cellX, lp.cellY);
 
             if (d.dragView != null) {
+                // We wrap the animation call in the temporary set and reset of the current
+                // cellLayout to its final transform -- this means we animate the drag view to
+                // the correct final location.
+                setFinalTransitionTransform(cellLayout);
                 mLauncher.getDragLayer().animateViewIntoPosition(d.dragView, view,
-                    exitSpringLoadedRunnable);
+                        exitSpringLoadedRunnable);
+                resetTransitionTransform(cellLayout);
             }
         }
     }
 
+    public void setFinalTransitionTransform(CellLayout layout) {
+        if (isSwitchingState()) {
+            int index = indexOfChild(layout);
+            mCurrentScaleX = layout.getScaleX();
+            mCurrentScaleY = layout.getScaleY();
+            mCurrentTranslationX = layout.getTranslationX();
+            mCurrentTranslationY = layout.getTranslationY();
+            mCurrentRotationY = layout.getRotationY();
+            layout.setScaleX(mNewScaleXs[index]);
+            layout.setScaleY(mNewScaleYs[index]);
+            layout.setTranslationX(mNewTranslationXs[index]);
+            layout.setTranslationY(mNewTranslationYs[index]);
+            layout.setRotationY(mNewRotationYs[index]);
+        }
+    }
+    public void resetTransitionTransform(CellLayout layout) {
+        if (isSwitchingState()) {
+            int index = indexOfChild(layout);
+            mCurrentScaleX = layout.getScaleX();
+            mCurrentScaleY = layout.getScaleY();
+            mCurrentTranslationX = layout.getTranslationX();
+            mCurrentTranslationY = layout.getTranslationY();
+            mCurrentRotationY = layout.getRotationY();
+            layout.setScaleX(mCurrentScaleX);
+            layout.setScaleY(mCurrentScaleY);
+            layout.setTranslationX(mCurrentTranslationX);
+            layout.setTranslationY(mCurrentTranslationY);
+            layout.setRotationY(mCurrentRotationY);
+        }
+    }
+
     /**
      * Return the current {@link CellLayout}, correctly picking the destination
      * screen while a scroll is in progress.
@@ -3409,12 +3485,12 @@
     }
 
     void moveToDefaultScreen(boolean animate) {
-        if (isSmall() || mIsSwitchingState) {
-            mLauncher.showWorkspace(animate, (CellLayout) getChildAt(mDefaultPage));
-        } else if (animate) {
-            snapToPage(mDefaultPage);
-        } else {
-            setCurrentPage(mDefaultPage);
+        if (!isSmall()) {
+            if (animate) {
+                snapToPage(mDefaultPage);
+            } else {
+                setCurrentPage(mDefaultPage);
+            }
         }
         getChildAt(mDefaultPage).requestFocus();
     }