diff --git a/src/com/android/dialer/list/ListsFragment.java b/src/com/android/dialer/list/ListsFragment.java
index 3de714d..ab790ed 100644
--- a/src/com/android/dialer/list/ListsFragment.java
+++ b/src/com/android/dialer/list/ListsFragment.java
@@ -73,6 +73,7 @@
 
     public interface HostInterface {
         public void showCallHistory();
+        public int getActionBarHeight();
     }
 
     private ActionBar mActionBar;
@@ -348,6 +349,8 @@
         paneLayout.setCapturableView(mViewPagerTabs);
         paneLayout.openPane();
         paneLayout.setPanelSlideListener(mPanelSlideListener);
+        paneLayout.setIntermediatePinnedOffset(
+                ((HostInterface) getActivity()).getActionBarHeight());
 
         LayoutTransition transition = paneLayout.getLayoutTransition();
         // Turns on animations for all types of layout changes so that they occur for
diff --git a/src/com/android/dialer/widget/OverlappingPaneLayout.java b/src/com/android/dialer/widget/OverlappingPaneLayout.java
index e17194e..e28bcc5 100644
--- a/src/com/android/dialer/widget/OverlappingPaneLayout.java
+++ b/src/com/android/dialer/widget/OverlappingPaneLayout.java
@@ -44,6 +44,7 @@
  */
 public class OverlappingPaneLayout extends ViewGroup {
     private static final String TAG = "SlidingPaneLayout";
+    private static final boolean DEBUG = false;
 
     /**
      * Default size of the overhang for a pane in the open state.
@@ -92,6 +93,12 @@
     private float mSlideOffset;
 
     /**
+     * How far the panel is offset from its closed position, in pixels.
+     * range [0, {@link #mSlideRange}] where 0 is completely closed.
+     */
+    private int mSlideOffsetPx;
+
+    /**
      * How far in pixels the slideable panel may move.
      */
     private int mSlideRange;
@@ -107,6 +114,20 @@
      */
     private boolean mIsInNestedScroll;
 
+    /**
+     * Indicates that the layout is currently in the process of a nested pre-scroll operation where
+     * the child is being dragged downwards. If so, we should open the pane up to the maximum
+     * offset defined in {@link #mIntermediateOffset}, and no further.
+     */
+    boolean mInNestedPreScrollDownwards = false;
+
+    /**
+     * Stores an offset used to represent a point somewhere in between the panel's fully closed
+     * state and fully opened state where the panel can be temporarily pinned or opened up to
+     * during scrolling.
+     */
+    private int mIntermediateOffset = 0;
+
     private float mInitialMotionX;
     private float mInitialMotionY;
 
@@ -173,6 +194,16 @@
     }
 
     /**
+     * Set an offset, somewhere in between the panel's fully closed state and fully opened state,
+     * where the panel can be temporarily pinned or opened up to.
+     *
+     * @param offset Offset in pixels
+     */
+    public void setIntermediatePinnedOffset(int offset) {
+        mIntermediateOffset = offset;
+    }
+
+    /**
      * Set the view that can be used to start dragging the sliding pane.
      */
     public void setCapturableView(View capturableView) {
@@ -525,7 +556,7 @@
                 final int lpMargin = lp.topMargin;
                 final int pos = (int) (range * mSlideOffset);
                 yStart += pos + lpMargin;
-                mSlideOffset = (float) pos / mSlideRange;
+                updateSlideOffset(pos);
             } else {
                 yStart = nextYStart;
             }
@@ -664,6 +695,11 @@
         return false;
     }
 
+    private void updateSlideOffset(int offsetPx) {
+        mSlideOffsetPx = offsetPx;
+        mSlideOffset = (float) mSlideOffsetPx / mSlideRange;
+    }
+
     /**
      * Open the sliding pane if it is currently slideable. If first layout
      * has already completed this will animate.
@@ -685,13 +721,13 @@
     }
 
     /**
-     * Check if the layout is completely open. It can be open either because the slider
+     * Check if the layout is open. It can be open either because the slider
      * itself is open revealing the left pane, or if all content fits without sliding.
      *
-     * @return true if sliding panels are completely open
+     * @return true if sliding panels are open
      */
     public boolean isOpen() {
-        return !mCanSlide || mSlideOffset == 1;
+        return !mCanSlide || mSlideOffset > 0;
     }
 
     /**
@@ -715,7 +751,7 @@
         final int lpMargin = lp.topMargin;
         final int topBound = getPaddingTop() + lpMargin;
 
-        mSlideOffset = (float) (newTop - topBound) / mSlideRange;
+        updateSlideOffset(newTop - topBound);
 
         dispatchOnPanelSlide(mSlideableView);
     }
@@ -855,17 +891,44 @@
             mIsInNestedScroll = true;
             mDragHelper.startNestedScroll(mSlideableView);
         }
+        if (DEBUG) {
+            Log.d(TAG, "onStartNestedScroll: " + startNestedScroll);
+        }
         return startNestedScroll;
     }
 
     @Override
     public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {
+        if (dy == 0) {
+            // Nothing to do
+            return;
+        }
+        if (DEBUG) {
+            Log.d(TAG, "onNestedPreScroll: " + dy);
+        }
+        mInNestedPreScrollDownwards = (dy > 0 && mSlideOffsetPx <= mIntermediateOffset);
         mDragHelper.processNestedScroll(mSlideableView, 0, dy, consumed);
     }
 
     @Override
+    public void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed,
+            int dyUnconsumed) {
+        if (DEBUG) {
+            Log.d(TAG, "onNestedScroll: " + dyUnconsumed);
+        }
+        mInNestedPreScrollDownwards = false;
+        // We need to flip dyUnconsumed here, because its magnitude is reversed. b/14585990
+        mDragHelper.processNestedScroll(mSlideableView, 0, -dyUnconsumed, null);
+    }
+
+    @Override
     public void onStopNestedScroll(View child) {
-        mDragHelper.stopNestedScroll(mSlideableView);
+        if (DEBUG) {
+            Log.d(TAG, "onStopNestedScroll");
+        }
+        if (mIsInNestedScroll) {
+            mDragHelper.stopNestedScroll(mSlideableView);
+        }
         mIsInNestedScroll = false;
     }
 
@@ -911,7 +974,25 @@
             final LayoutParams lp = (LayoutParams) releasedChild.getLayoutParams();
 
             int top = getPaddingTop() + lp.topMargin;
-            if (yvel > 0 || (yvel == 0 && mSlideOffset > 0.5f)) {
+
+            if (mInNestedPreScrollDownwards) {
+                // Snap to the closest pinnable position based on the current slide offset
+                // (in pixels)   [0  -  mIntermediateoffset  - mSlideRange]
+                if (yvel > 0) {
+                    top += mSlideRange;
+                } else if (0 <= mSlideOffsetPx && mSlideOffsetPx <= mIntermediateOffset / 2) {
+                    // Offset is between 0 and mIntermediateOffset, but closer to 0
+                    // Leave top unchanged
+                } else if (mIntermediateOffset / 2 <= mSlideOffsetPx
+                        && mSlideOffsetPx <= (mIntermediateOffset + mSlideRange) / 2) {
+                    // Offset is closest to mIntermediateOffset
+                    top += mIntermediateOffset;
+                } else {
+                    // Offset is between mIntermediateOffset and mSlideRange, but closer to
+                    // mSlideRange
+                    top += mSlideRange;
+                }
+            } else if (yvel > 0 || (yvel == 0 && mSlideOffset > 0.5f)) {
                 top += mSlideRange;
             }
 
@@ -936,7 +1017,8 @@
 
             final int newTop;
             int topBound = getPaddingTop() + lp.topMargin;
-            int bottomBound = topBound + mSlideRange;
+            int bottomBound = topBound
+                    + (mInNestedPreScrollDownwards ? mIntermediateOffset : mSlideRange);
             newTop = Math.min(Math.max(top, topBound), bottomBound);
 
             return newTop;