diff --git a/res/drawable/page_hover_left.9.png b/res/drawable/page_hover_left.9.png
new file mode 100644
index 0000000..5d5e0c8
--- /dev/null
+++ b/res/drawable/page_hover_left.9.png
Binary files differ
diff --git a/res/drawable/page_hover_right.9.png b/res/drawable/page_hover_right.9.png
new file mode 100644
index 0000000..1545bfe
--- /dev/null
+++ b/res/drawable/page_hover_right.9.png
Binary files differ
diff --git a/res/values-xlarge-port/dimens.xml b/res/values-xlarge-port/dimens.xml
index b60635b..baa31aa 100644
--- a/res/values-xlarge-port/dimens.xml
+++ b/res/values-xlarge-port/dimens.xml
@@ -15,6 +15,10 @@
 -->
 
 <resources>
+    <!-- the area at the edge of the screen that makes the workspace go left
+         or right while you're dragging. -->
+    <dimen name="scroll_zone">40dp</dimen>
+
     <!-- Width/height gap overrides for the workspace -->
     <dimen name="workspace_width_gap">0dp</dimen>
     <dimen name="workspace_height_gap">32dp</dimen>
diff --git a/src/com/android/launcher2/CellLayout.java b/src/com/android/launcher2/CellLayout.java
index 66d5cb5..11c0c18 100644
--- a/src/com/android/launcher2/CellLayout.java
+++ b/src/com/android/launcher2/CellLayout.java
@@ -327,6 +327,10 @@
         }
     }
 
+    public boolean getHover() {
+        return mHover;
+    }
+
     public void drawChildren(Canvas canvas) {
         super.dispatchDraw(canvas);
     }
diff --git a/src/com/android/launcher2/Workspace.java b/src/com/android/launcher2/Workspace.java
index 4679c64..df3d2de 100644
--- a/src/com/android/launcher2/Workspace.java
+++ b/src/com/android/launcher2/Workspace.java
@@ -605,6 +605,30 @@
         } else {
             super.dispatchDraw(canvas);
 
+            final int width = getWidth();
+            final int height = getHeight();
+
+            // In portrait orientation, draw the glowing edge when dragging to adjacent screens
+            if (mInScrollArea && (height > width)) {
+                final int pageHeight = getChildAt(0).getHeight();
+
+                // This determines the height of the glowing edge: 90% of the page height
+                final int padding = (int) ((height - pageHeight) * 0.5f + pageHeight * 0.1f);
+
+                final CellLayout leftPage = (CellLayout) getChildAt(mCurrentPage - 1);
+                final CellLayout rightPage = (CellLayout) getChildAt(mCurrentPage + 1);
+
+                if (leftPage != null && leftPage.getHover()) {
+                    final Drawable d = getResources().getDrawable(R.drawable.page_hover_left);
+                    d.setBounds(mScrollX, padding, mScrollX + d.getIntrinsicWidth(), height - padding);
+                    d.draw(canvas);
+                } else if (rightPage != null && rightPage.getHover()) {
+                    final Drawable d = getResources().getDrawable(R.drawable.page_hover_right);
+                    d.setBounds(mScrollX + width - d.getIntrinsicWidth(), padding, mScrollX + width, height - padding);
+                    d.draw(canvas);
+                }
+            }
+
             if (mDropView != null) {
                 // We are animating an item that was just dropped on the home screen.
                 // Render its View in the current animation position.
@@ -1909,11 +1933,11 @@
             final int screen = getCurrentPage() + ((direction == DragController.SCROLL_LEFT) ? -1 : 1);
             if (0 <= screen && screen < getChildCount()) {
                 ((CellLayout) getChildAt(screen)).setHover(true);
-            }
 
-            if (mDragTargetLayout != null) {
-                mDragTargetLayout.onDragExit();
-                mDragTargetLayout = null;
+                if (mDragTargetLayout != null) {
+                    mDragTargetLayout.onDragExit();
+                    mDragTargetLayout = null;
+                }
             }
         }
     }
