diff --git a/Android.mk b/Android.mk
index 3853808..d7bfdd4 100644
--- a/Android.mk
+++ b/Android.mk
@@ -50,8 +50,6 @@
 
 include $(BUILD_PACKAGE)
 
-include $(call all-makefiles-under,$(LOCAL_PATH))
-
 #
 # Protocol Buffer Debug Utility in Java
 #
@@ -89,3 +87,6 @@
 	$(hide) chmod 755 $@
 
 INTERNAL_DALVIK_MODULES += $(LOCAL_INSTALLED_MODULE)
+
+# ==================================================
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/src/com/android/launcher3/DragController.java b/src/com/android/launcher3/DragController.java
index 09c59a0..8dc6e18 100644
--- a/src/com/android/launcher3/DragController.java
+++ b/src/com/android/launcher3/DragController.java
@@ -49,8 +49,8 @@
     /** Indicates the drag is a copy.  */
     public static int DRAG_ACTION_COPY = 1;
 
-    private static final int SCROLL_DELAY = 500;
-    private static final int RESCROLL_DELAY = PagedView.PAGE_SNAP_ANIMATION_DURATION + 150;
+    public static final int SCROLL_DELAY = 500;
+    public static final int RESCROLL_DELAY = PagedView.PAGE_SNAP_ANIMATION_DURATION + 150;
 
     private static final boolean PROFILE_DRAWING_DURING_DRAG = false;
 
diff --git a/src/com/android/launcher3/Folder.java b/src/com/android/launcher3/Folder.java
index bef1f0d..7ff60de 100644
--- a/src/com/android/launcher3/Folder.java
+++ b/src/com/android/launcher3/Folder.java
@@ -48,6 +48,7 @@
 import android.view.inputmethod.InputMethodManager;
 import android.widget.LinearLayout;
 import android.widget.TextView;
+
 import com.android.launcher3.FolderInfo.FolderListener;
 import com.android.launcher3.Workspace.ItemOperator;
 
@@ -74,6 +75,21 @@
     static final int STATE_ANIMATING = 1;
     static final int STATE_OPEN = 2;
 
+    /**
+     * Fraction of the width to scroll when showing the next page hint.
+     */
+    private static final float SCROLL_HINT_FRACTION = 0.07f;
+
+    /**
+     * Time for which the scroll hint is shown before automatically changing page.
+     */
+    public static final int SCROLL_HINT_DURATION = DragController.SCROLL_DELAY;
+
+    /**
+     * Fraction of icon width which behave as scroll region.
+     */
+    private static final float ICON_OVERSCROLL_WIDTH_FACTOR = 0.45f;
+
     private static final int REORDER_DELAY = 250;
     private static final int ON_EXIT_CLOSE_DELAY = 400;
     private static final Rect sTempRect = new Rect();
@@ -129,6 +145,17 @@
     private boolean mDeferDropAfterUninstall;
     private boolean mUninstallSuccessful;
 
+    // Folder scrolling
+    private int mScrollAreaOffset;
+    private Alarm mOnScrollHintAlarm;
+    private Alarm mScrollPauseAlarm;
+
+    // TODO: Use {@link #mContent} once {@link #ALLOW_FOLDER_SCROLL} is removed.
+    private FolderPagedView mPagedView;
+
+    private int mScrollHintDir = DragController.SCROLL_NONE;
+    private int mCurrentScrollDir = DragController.SCROLL_NONE;
+
     /**
      * Used to inflate the Workspace from XML.
      *
@@ -157,6 +184,11 @@
         // name is complete, we have something to focus on, thus hiding the cursor and giving
         // reliable behavior when clicking the text field (since it will always gain focus on click).
         setFocusableInTouchMode(true);
+
+        if (ALLOW_FOLDER_SCROLL) {
+            mOnScrollHintAlarm = new Alarm();
+            mScrollPauseAlarm = new Alarm();
+        }
     }
 
     @Override
@@ -183,6 +215,10 @@
         int measureSpec = MeasureSpec.UNSPECIFIED;
         mFooter.measure(measureSpec, measureSpec);
         mFooterHeight = mFooter.getMeasuredHeight();
+
+        if (ALLOW_FOLDER_SCROLL) {
+            mPagedView = (FolderPagedView) mContent;
+        }
     }
 
     private ActionMode.Callback mActionModeCallback = new ActionMode.Callback() {
@@ -386,6 +422,11 @@
     public void animateOpen() {
         if (!(getParent() instanceof DragLayer)) return;
 
+        if (ALLOW_FOLDER_SCROLL) {
+            // Always open on the first page.
+            mPagedView.snapToPageImmediately(0);
+        }
+
         Animator openFolderAnim = null;
         final Runnable onCompleteRunnable;
         if (!Utilities.isLmpOrAbove()) {
@@ -544,6 +585,11 @@
     public void onDragEnter(DragObject d) {
         mPrevTargetRank = -1;
         mOnExitAlarm.cancelAlarm();
+        if (ALLOW_FOLDER_SCROLL) {
+            // Get the area offset such that the folder only closes if half the drag icon width
+            // is outside the folder area
+            mScrollAreaOffset = d.dragView.getDragRegionWidth() / 2 - d.xOffset;
+        }
     }
 
     OnAlarmListener mReorderAlarmListener = new OnAlarmListener() {
@@ -558,18 +604,80 @@
         return (getLayoutDirection() == LAYOUT_DIRECTION_RTL);
     }
 
+    @Override
     public void onDragOver(DragObject d) {
-        final float[] r = d.getVisualCenter(null);
-        r[0] -= getPaddingLeft();
-        r[1] -= getPaddingTop();
+        onDragOver(d, REORDER_DELAY);
+    }
 
-        mTargetRank = mContent.findNearestArea((int) r[0], (int) r[1]);
+    private int getTargetRank(DragObject d, float[] recycle) {
+        recycle = d.getVisualCenter(recycle);
+        return mContent.findNearestArea(
+                (int) recycle[0] - getPaddingLeft(), (int) recycle[1] - getPaddingTop());
+    }
+
+    private void onDragOver(DragObject d, int reorderDelay) {
+        if (ALLOW_FOLDER_SCROLL && mScrollPauseAlarm.alarmPending()) {
+            return;
+        }
+        final float[] r = new float[2];
+        mTargetRank = getTargetRank(d, r);
+
         if (mTargetRank != mPrevTargetRank) {
             mReorderAlarm.cancelAlarm();
             mReorderAlarm.setOnAlarmListener(mReorderAlarmListener);
             mReorderAlarm.setAlarm(REORDER_DELAY);
             mPrevTargetRank = mTargetRank;
         }
+
+        if (!ALLOW_FOLDER_SCROLL) {
+            return;
+        }
+
+        float x = r[0];
+        int currentPage = mPagedView.getNextPage();
+        int cellWidth = mPagedView.getCurrentCellLayout().getCellWidth();
+        if (currentPage > 0 && x < cellWidth * ICON_OVERSCROLL_WIDTH_FACTOR) {
+            // Show scroll hint on the left
+            if (mScrollHintDir != DragController.SCROLL_LEFT) {
+                mPagedView.showScrollHint(-SCROLL_HINT_FRACTION);
+                mScrollHintDir = DragController.SCROLL_LEFT;
+            }
+
+            // Set alarm for when the hint is complete
+            if (!mOnScrollHintAlarm.alarmPending() || mCurrentScrollDir != DragController.SCROLL_LEFT) {
+                mCurrentScrollDir = DragController.SCROLL_LEFT;
+                mOnScrollHintAlarm.cancelAlarm();
+                mOnScrollHintAlarm.setOnAlarmListener(new OnScrollHintListener(d));
+                mOnScrollHintAlarm.setAlarm(SCROLL_HINT_DURATION);
+
+                mReorderAlarm.cancelAlarm();
+                mTargetRank = mEmptyCellRank;
+            }
+        } else if (currentPage < (mPagedView.getPageCount() - 1) &&
+                (x > (getWidth() - cellWidth * ICON_OVERSCROLL_WIDTH_FACTOR))) {
+            // Show scroll hint on the right
+            if (mScrollHintDir != DragController.SCROLL_RIGHT) {
+                mPagedView.showScrollHint(SCROLL_HINT_FRACTION);
+                mScrollHintDir = DragController.SCROLL_RIGHT;
+            }
+
+            // Set alarm for when the hint is complete
+            if (!mOnScrollHintAlarm.alarmPending() || mCurrentScrollDir != DragController.SCROLL_RIGHT) {
+                mCurrentScrollDir = DragController.SCROLL_RIGHT;
+                mOnScrollHintAlarm.cancelAlarm();
+                mOnScrollHintAlarm.setOnAlarmListener(new OnScrollHintListener(d));
+                mOnScrollHintAlarm.setAlarm(SCROLL_HINT_DURATION);
+
+                mReorderAlarm.cancelAlarm();
+                mTargetRank = mEmptyCellRank;
+            }
+        } else {
+            mOnScrollHintAlarm.cancelAlarm();
+            if (mScrollHintDir != DragController.SCROLL_NONE) {
+                mPagedView.clearScrollHint();
+                mScrollHintDir = DragController.SCROLL_NONE;
+            }
+        }
     }
 
     OnAlarmListener mOnExitAlarmListener = new OnAlarmListener() {
@@ -595,6 +703,15 @@
             mOnExitAlarm.setAlarm(ON_EXIT_CLOSE_DELAY);
         }
         mReorderAlarm.cancelAlarm();
+
+        if (ALLOW_FOLDER_SCROLL) {
+            mOnScrollHintAlarm.cancelAlarm();
+            mScrollPauseAlarm.cancelAlarm();
+            if (mScrollHintDir != DragController.SCROLL_NONE) {
+                mPagedView.clearScrollHint();
+                mScrollHintDir = DragController.SCROLL_NONE;
+            }
+        }
     }
 
     public void onDropCompleted(final View target, final DragObject d,
@@ -960,6 +1077,22 @@
             };
         }
 
+        if (ALLOW_FOLDER_SCROLL) {
+            // If the icon was dropped while the page was being scrolled, we need to compute
+            // the target location again such that the icon is placed of the final page.
+            if (!mPagedView.rankOnCurrentPage(mEmptyCellRank)) {
+                // Reorder again.
+                mTargetRank = getTargetRank(d, null);
+
+                // Rearrange items immediately.
+                mReorderAlarmListener.onAlarm(mReorderAlarm);
+
+                mOnScrollHintAlarm.cancelAlarm();
+                mScrollPauseAlarm.cancelAlarm();
+            }
+            mPagedView.completePendingPageChanges();
+        }
+
         View currentDragView;
         ShortcutInfo si = mCurrentDragInfo;
         if (mIsExternalDrag) {
@@ -1090,6 +1223,57 @@
     @Override
     public void getHitRectRelativeToDragLayer(Rect outRect) {
         getHitRect(outRect);
+        outRect.left -= mScrollAreaOffset;
+        outRect.right += mScrollAreaOffset;
+    }
+
+    private class OnScrollHintListener implements OnAlarmListener {
+
+        private final DragObject mDragObject;
+
+        OnScrollHintListener(DragObject object) {
+            mDragObject = object;
+        }
+
+        /**
+         * Scroll hint has been shown long enough. Now scroll to appropriate page.
+         */
+        @Override
+        public void onAlarm(Alarm alarm) {
+            if (mCurrentScrollDir == DragController.SCROLL_LEFT) {
+                mPagedView.scrollLeft();
+                mScrollHintDir = DragController.SCROLL_NONE;
+            } else if (mCurrentScrollDir == DragController.SCROLL_RIGHT) {
+                mPagedView.scrollRight();
+                mScrollHintDir = DragController.SCROLL_NONE;
+            } else {
+                // This should not happen
+                return;
+            }
+            mCurrentScrollDir = DragController.SCROLL_NONE;
+
+            // Pause drag event until the scrolling is finished
+            mScrollPauseAlarm.setOnAlarmListener(new OnScrollFinishedListener(mDragObject));
+            mScrollPauseAlarm.setAlarm(DragController.RESCROLL_DELAY);
+        }
+    }
+
+    private class OnScrollFinishedListener implements OnAlarmListener {
+
+        private final DragObject mDragObject;
+
+        OnScrollFinishedListener(DragObject object) {
+            mDragObject = object;
+        }
+
+        /**
+         * Page scroll is complete.
+         */
+        @Override
+        public void onAlarm(Alarm alarm) {
+            // Reorder immediately on page change.
+            onDragOver(mDragObject, 1);
+        }
     }
 
     public static interface FolderContent {
diff --git a/src/com/android/launcher3/FolderPagedView.java b/src/com/android/launcher3/FolderPagedView.java
index 60c94e0..b4a7a75 100644
--- a/src/com/android/launcher3/FolderPagedView.java
+++ b/src/com/android/launcher3/FolderPagedView.java
@@ -16,11 +16,13 @@
 
 package com.android.launcher3;
 
+import android.annotation.SuppressLint;
 import android.content.Context;
 import android.util.AttributeSet;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
+import android.view.animation.DecelerateInterpolator;
 
 import com.android.launcher3.FocusHelper.PagedFolderKeyEventListener;
 import com.android.launcher3.PageIndicator.PageMarkerResources;
@@ -29,12 +31,15 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.Map;
 
 public class FolderPagedView extends PagedView implements Folder.FolderContent {
 
     private static final String TAG = "FolderPagedView";
 
     private static final int REORDER_ANIMATION_DURATION = 230;
+    private static final int START_VIEW_REORDER_DELAY = 30;
+    private static final float VIEW_REORDER_DELAY_FACTOR = 0.9f;
     private static final int[] sTempPosArray = new int[2];
 
     // TODO: Remove this restriction
@@ -44,11 +49,9 @@
     private final IconCache mIconCache;
     private final HashMap<View, Runnable> mPageChangingViews = new HashMap<>();
 
-    private final CellLayout mFirstPage;
-
-    final int mMaxCountX;
-    final int mMaxCountY;
-    final int mMaxItemsPerPage;
+    private final int mMaxCountX;
+    private final int mMaxCountY;
+    private final int mMaxItemsPerPage;
 
     private int mAllocatedContentSize;
     private int mGridCountX;
@@ -61,10 +64,6 @@
     public FolderPagedView(Context context, AttributeSet attrs) {
         super(context, attrs);
         LauncherAppState app = LauncherAppState.getInstance();
-
-        mFirstPage = newCellLayout();
-        addFullScreenPage(mFirstPage);
-        setCurrentPage(0);
         setDataIsReady();
 
         DeviceProfile grid = app.getDynamicGrid().getDeviceProfile();
@@ -96,8 +95,6 @@
             mGridCountY = mMaxCountY;
             done = true;
         } else {
-            mGridCountX = mFirstPage.getCountX();
-            mGridCountY = mFirstPage.getCountY();
             done = false;
         }
 
@@ -120,50 +117,19 @@
             done = mGridCountX == oldCountX && mGridCountY == oldCountY;
         }
 
-        setGridSize(mGridCountX, mGridCountY);
-    }
-
-    public void setGridSize(int countX, int countY) {
-        mGridCountX = countX;
-        mGridCountY = countY;
-        mFirstPage.setGridSize(mGridCountX, mGridCountY);
-        for (int i = getPageCount() - 1; i > 0; i--) {
+        // Update grid size
+        for (int i = getPageCount() - 1; i >= 0; i--) {
             getPageAt(i).setGridSize(mGridCountX, mGridCountY);
         }
     }
 
     @Override
     public ArrayList<ShortcutInfo> bindItems(ArrayList<ShortcutInfo> items) {
-        final int count = items.size();
-
-        if (getPageCount() > 1) {
-            Log.d(TAG, "Binding items to an non-empty view");
-            removeAllViews();
-            addView(mFirstPage);
-            mFirstPage.removeAllViews();
-        }
-
-        setupContentDimensions(count);
-        CellLayout page = mFirstPage;
-        int pagePosition = 0;
-        int rank = 0;
-
+        ArrayList<View> icons = new ArrayList<View>();
         for (ShortcutInfo item : items) {
-            if (pagePosition >= mMaxItemsPerPage) {
-                // This page is full, add a new page.
-                pagePosition = 0;
-                page = newCellLayout();
-                addFullScreenPage(page);
-            }
-
-            item.cellX = pagePosition % mGridCountX;
-            item.cellY = pagePosition / mGridCountX;
-            item.rank = rank;
-            addNewView(item, page);
-
-            rank++;
-            pagePosition++;
+            icons.add(createNewView(item));
         }
+        arrangeChildren(icons, icons.size(), false);
         return new ArrayList<ShortcutInfo>();
     }
 
@@ -175,32 +141,29 @@
     public int allocateNewLastItemRank() {
         int rank = getItemCount();
         int total = rank + 1;
-        if (rank < mMaxItemsPerPage) {
-            // Rearrange the items as the grid size might change.
-            mFolder.rearrangeChildren(total);
-        } else {
-            setupContentDimensions(total);
-        }
+        // Rearrange the items as the grid size might change.
+        mFolder.rearrangeChildren(total);
 
-        // Add a new page if last page is full
-        if (getPageAt(getChildCount() - 1).getShortcutsAndWidgets().getChildCount()
-                >= mMaxItemsPerPage) {
-            addFullScreenPage(newCellLayout());
-        }
         setCurrentPage(getChildCount() - 1);
         return rank;
     }
 
     @Override
     public View createAndAddViewForRank(ShortcutInfo item, int rank) {
-        int pageNo = updateItemXY(item, rank);
-        CellLayout page = getPageAt(pageNo);
-        return addNewView(item, page);
+        View icon = createNewView(item);
+        addViewForRank(createNewView(item), item, rank);
+        return icon;
     }
 
     @Override
     public void addViewForRank(View view, ShortcutInfo item, int rank) {
-        int pageNo = updateItemXY(item, rank);
+        int pagePos = rank % mMaxItemsPerPage;
+        int pageNo = rank / mMaxItemsPerPage;
+
+        item.rank = rank;
+        item.cellX = pagePos % mGridCountX;
+        item.cellY = pagePos / mGridCountX;
+
         CellLayout.LayoutParams lp = (CellLayout.LayoutParams) view.getLayoutParams();
         lp.cellX = item.cellX;
         lp.cellY = item.cellY;
@@ -208,32 +171,18 @@
                 view, -1, mFolder.mLauncher.getViewIdForItem(item), lp, true);
     }
 
-    /**
-     * Updates the item cellX and cellY position and return the page number for that item.
-     */
-    private int updateItemXY(ShortcutInfo item, int rank) {
-        item.rank = rank;
-
-        int pagePos = item.rank % mMaxItemsPerPage;
-        item.cellX = pagePos % mGridCountX;
-        item.cellY = pagePos / mGridCountX;
-
-        return item.rank / mMaxItemsPerPage;
-    }
-
-    private View addNewView(ShortcutInfo item, CellLayout target) {
+    @SuppressLint("InflateParams")
+    private View createNewView(ShortcutInfo item) {
         final BubbleTextView textView = (BubbleTextView) mInflater.inflate(
-                R.layout.folder_application, target.getShortcutsAndWidgets(), false);
+                R.layout.folder_application, null, false);
         textView.applyFromShortcutInfo(item, mIconCache, false);
         textView.setOnClickListener(mFolder);
         textView.setOnLongClickListener(mFolder);
         textView.setOnFocusChangeListener(mFocusIndicatorView);
         textView.setOnKeyListener(mKeyListener);
 
-        CellLayout.LayoutParams lp = new CellLayout.LayoutParams(
-                item.cellX, item.cellY, item.spanX, item.spanY);
-        target.addViewToCellLayout(
-                textView, -1, mFolder.mLauncher.getViewIdForItem(item), lp, true);
+        textView.setLayoutParams(new CellLayout.LayoutParams(
+                item.cellX, item.cellY, item.spanX, item.spanY));
         return textView;
     }
 
@@ -252,26 +201,18 @@
         return getPageAt(getNextPage());
     }
 
-    @Override
-    public void addFullScreenPage(View page) {
+    private CellLayout createAndAddNewPage() {
+        DeviceProfile grid = LauncherAppState.getInstance().getDynamicGrid().getDeviceProfile();
+        CellLayout page = new CellLayout(getContext());
+        page.setCellDimensions(grid.folderCellWidthPx, grid.folderCellHeightPx);
+        page.getShortcutsAndWidgets().setMotionEventSplittingEnabled(false);
+        page.setInvertIfRtl(true);
+        page.setGridSize(mGridCountX, mGridCountY);
+
         LayoutParams lp = generateDefaultLayoutParams();
         lp.isFullScreenPage = true;
-        super.addView(page, -1, lp);
-    }
-
-    private CellLayout newCellLayout() {
-        DeviceProfile grid = LauncherAppState.getInstance().getDynamicGrid().getDeviceProfile();
-
-        CellLayout layout = new CellLayout(getContext());
-        layout.setCellDimensions(grid.folderCellWidthPx, grid.folderCellHeightPx);
-        layout.getShortcutsAndWidgets().setMotionEventSplittingEnabled(false);
-        layout.setInvertIfRtl(true);
-
-        if (mFirstPage != null) {
-            layout.setGridSize(mFirstPage.getCountX(), mFirstPage.getCountY());
-        }
-
-        return layout;
+        addView(page, -1, lp);
+        return page;
     }
 
     @Override
@@ -300,6 +241,10 @@
      */
     @Override
     public void arrangeChildren(ArrayList<View> list, int itemCount) {
+        arrangeChildren(list, itemCount, true);
+    }
+
+    private void arrangeChildren(ArrayList<View> list, int itemCount, boolean saveChanges) {
         ArrayList<CellLayout> pages = new ArrayList<CellLayout>();
         for (int i = 0; i < getChildCount(); i++) {
             CellLayout page = (CellLayout) getChildAt(i);
@@ -315,44 +260,47 @@
         int newX, newY, rank;
 
         rank = 0;
-        for (View v : list) {
+        for (int i = 0; i < itemCount; i++) {
+            View v = list.size() > i ? list.get(i) : null;
             if (currentPage == null || position >= mMaxItemsPerPage) {
                 // Next page
                 if (pageItr.hasNext()) {
                     currentPage = pageItr.next();
                 } else {
-                    currentPage = newCellLayout();
-                    addFullScreenPage(currentPage);
+                    currentPage = createAndAddNewPage();
                 }
                 position = 0;
             }
 
-            CellLayout.LayoutParams lp = (CellLayout.LayoutParams) v.getLayoutParams();
-            newX = position % mGridCountX;
-            newY = position / mGridCountX;
-            ItemInfo info = (ItemInfo) v.getTag();
-            if (info.cellX != newX || info.cellY != newY || info.rank != rank) {
-                info.cellX = newX;
-                info.cellY = newY;
-                info.rank = rank;
-                LauncherModel.addOrMoveItemInDatabase(getContext(), info,
-                        mFolder.mInfo.id, 0, info.cellX, info.cellY);
+            if (v != null) {
+                CellLayout.LayoutParams lp = (CellLayout.LayoutParams) v.getLayoutParams();
+                newX = position % mGridCountX;
+                newY = position / mGridCountX;
+                ItemInfo info = (ItemInfo) v.getTag();
+                if (info.cellX != newX || info.cellY != newY || info.rank != rank) {
+                    info.cellX = newX;
+                    info.cellY = newY;
+                    info.rank = rank;
+                    if (saveChanges) {
+                        LauncherModel.addOrMoveItemInDatabase(getContext(), info,
+                                mFolder.mInfo.id, 0, info.cellX, info.cellY);
+                    }
+                }
+                lp.cellX = info.cellX;
+                lp.cellY = info.cellY;
+                currentPage.addViewToCellLayout(
+                        v, -1, mFolder.mLauncher.getViewIdForItem(info), lp, true);
             }
-            lp.cellX = info.cellX;
-            lp.cellY = info.cellY;
+
             rank ++;
             position++;
-            currentPage.addViewToCellLayout(
-                    v, -1, mFolder.mLauncher.getViewIdForItem(info), lp, true);
         }
 
+        // Remove extra views.
         boolean removed = false;
         while (pageItr.hasNext()) {
-            CellLayout layout = pageItr.next();
-            if (layout != mFirstPage) {
-                removeView(layout);
-                removed = true;
-            }
+            removeView(pageItr.next());
+            removed = true;
         }
         if (removed) {
             setCurrentPage(0);
@@ -369,16 +317,20 @@
     public void syncPageItems(int page, boolean immediate) { }
 
     public int getDesiredWidth() {
-        return mFirstPage.getDesiredWidth();
+        return getPageCount() > 0 ? getPageAt(0).getDesiredWidth() : 0;
     }
 
     public int getDesiredHeight()  {
-        return mFirstPage.getDesiredHeight();
+        return  getPageCount() > 0 ? getPageAt(0).getDesiredHeight() : 0;
     }
 
     @Override
     public int getItemCount() {
         int lastPage = getChildCount() - 1;
+        if (lastPage < 0) {
+            // If there are no pages, there must be only one icon in the folder.
+            return 1;
+        }
         return getPageAt(lastPage).getShortcutsAndWidgets().getChildCount()
                 + lastPage * mMaxItemsPerPage;
     }
@@ -457,10 +409,49 @@
         }
     }
 
+    /**
+     * Scrolls the current view by a fraction
+     */
+    public void showScrollHint(float fraction) {
+        int hint = (int) (fraction * getWidth());
+        int scroll = getScrollForPage(getNextPage()) + hint;
+        int delta = scroll - mUnboundedScrollX;
+        if (delta != 0) {
+            mScroller.setInterpolator(new DecelerateInterpolator());
+            mScroller.startScroll(mUnboundedScrollX, 0, delta, 0, Folder.SCROLL_HINT_DURATION);
+            invalidate();
+        }
+    }
+
+    public void clearScrollHint() {
+        if (mUnboundedScrollX != getScrollForPage(getNextPage())) {
+            snapToPage(getNextPage());
+        }
+    }
+
+    /**
+     * Finish animation all the views which are animating across pages
+     */
+    public void completePendingPageChanges() {
+        if (!mPageChangingViews.isEmpty()) {
+            HashMap<View, Runnable> pendingViews = new HashMap<>(mPageChangingViews);
+            for (Map.Entry<View, Runnable> e : pendingViews.entrySet()) {
+                e.getKey().animate().cancel();
+                e.getValue().run();
+            }
+        }
+    }
+
+    public boolean rankOnCurrentPage(int rank) {
+        int p = rank / mMaxItemsPerPage;
+        return p == getNextPage();
+    }
+
     @Override
     public void realTimeReorder(int empty, int target) {
+        completePendingPageChanges();
         int delay = 0;
-        float delayAmount = 30;
+        float delayAmount = START_VIEW_REORDER_DELAY;
 
         // Animation only happens on the current page.
         int pageToAnimate = getNextPage();
@@ -574,7 +565,7 @@
             if (page.animateChildToPosition(v, i % mGridCountX, i / mGridCountX,
                     REORDER_ANIMATION_DURATION, delay, true, true)) {
                 delay += delayAmount;
-                delayAmount *= 0.9;
+                delayAmount *= VIEW_REORDER_DELAY_FACTOR;
             }
         }
     }