diff --git a/MenuDrawer/AndroidManifest.xml b/MenuDrawer/AndroidManifest.xml
new file mode 100755
index 0000000..a77d28a
--- /dev/null
+++ b/MenuDrawer/AndroidManifest.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="net.simonvt.menudrawer"
+      android:versionCode="3"
+      android:versionName="2.0.1">
+
+    <uses-sdk android:minSdkVersion="7" android:targetSdkVersion="16" />
+</manifest>
diff --git a/MenuDrawer/atlassian-ide-plugin.xml b/MenuDrawer/atlassian-ide-plugin.xml
new file mode 100644
index 0000000..c7826a8
--- /dev/null
+++ b/MenuDrawer/atlassian-ide-plugin.xml
@@ -0,0 +1,5 @@
+<atlassian-ide-plugin>
+  <project-configuration>
+    <servers />
+  </project-configuration>
+</atlassian-ide-plugin>
\ No newline at end of file
diff --git a/MenuDrawer/build.xml b/MenuDrawer/build.xml
new file mode 100755
index 0000000..e5eb1dc
--- /dev/null
+++ b/MenuDrawer/build.xml
@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="menudrawer" default="help">
+
+    <!-- The local.properties file is created and updated by the 'android' tool.
+         It contains the path to the SDK. It should *NOT* be checked into
+         Version Control Systems. -->
+    <property file="local.properties" />
+
+    <!-- The ant.properties file can be created by you. It is only edited by the
+         'android' tool to add properties to it.
+         This is the place to change some Ant specific build properties.
+         Here are some properties you may want to change/update:
+
+         source.dir
+             The name of the source directory. Default is 'src'.
+         out.dir
+             The name of the output directory. Default is 'bin'.
+
+         For other overridable properties, look at the beginning of the rules
+         files in the SDK, at tools/ant/build.xml
+
+         Properties related to the SDK location or the project target should
+         be updated using the 'android' tool with the 'update' action.
+
+         This file is an integral part of the build system for your
+         application and should be checked into Version Control Systems.
+
+         -->
+    <property file="ant.properties" />
+
+    <!-- if sdk.dir was not set from one of the property file, then
+         get it from the ANDROID_HOME env var.
+         This must be done before we load project.properties since
+         the proguard config can use sdk.dir -->
+    <property environment="env" />
+    <condition property="sdk.dir" value="${env.ANDROID_HOME}">
+        <isset property="env.ANDROID_HOME" />
+    </condition>
+
+    <!-- The project.properties file is created and updated by the 'android'
+         tool, as well as ADT.
+
+         This contains project specific properties such as project target, and library
+         dependencies. Lower level build properties are stored in ant.properties
+         (or in .classpath for Eclipse projects).
+
+         This file is an integral part of the build system for your
+         application and should be checked into Version Control Systems. -->
+    <loadproperties srcFile="project.properties" />
+
+    <!-- quick check on sdk.dir -->
+    <fail
+            message="sdk.dir is missing. Make sure to generate local.properties using 'android update project' or to inject it through the ANDROID_HOME environment variable."
+            unless="sdk.dir"
+    />
+
+    <!--
+        Import per project custom build rules if present at the root of the project.
+        This is the place to put custom intermediary targets such as:
+            -pre-build
+            -pre-compile
+            -post-compile (This is typically used for code obfuscation.
+                           Compiled code location: ${out.classes.absolute.dir}
+                           If this is not done in place, override ${out.dex.input.absolute.dir})
+            -post-package
+            -post-build
+            -pre-clean
+    -->
+    <import file="custom_rules.xml" optional="true" />
+
+    <!-- Import the actual build file.
+
+         To customize existing targets, there are two options:
+         - Customize only one target:
+             - copy/paste the target into this file, *before* the
+               <import> task.
+             - customize it to your needs.
+         - Customize the whole content of build.xml
+             - copy/paste the content of the rules files (minus the top node)
+               into this file, replacing the <import> task.
+             - customize to your needs.
+
+         ***********************
+         ****** IMPORTANT ******
+         ***********************
+         In all cases you must update the value of version-tag below to read 'custom' instead of an integer,
+         in order to avoid having your file be overridden by tools such as "android update project"
+    -->
+    <!-- version-tag: 1 -->
+    <import file="${sdk.dir}/tools/ant/build.xml" />
+
+</project>
diff --git a/MenuDrawer/pom.xml b/MenuDrawer/pom.xml
new file mode 100755
index 0000000..b5bd881
--- /dev/null
+++ b/MenuDrawer/pom.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>net.simonvt</groupId>
+        <artifactId>android-menudrawer-parent</artifactId>
+        <version>2.0.3-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <artifactId>android-menudrawer</artifactId>
+    <name>Android MenuDrawer</name>
+    <packaging>apklib</packaging>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.google.android</groupId>
+            <artifactId>android</artifactId>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <sourceDirectory>src</sourceDirectory>
+
+        <plugins>
+            <plugin>
+                <groupId>com.jayway.maven.plugins.android.generation2</groupId>
+                <artifactId>android-maven-plugin</artifactId>
+                <extensions>true</extensions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/MenuDrawer/project.properties b/MenuDrawer/project.properties
new file mode 100755
index 0000000..87089b8
--- /dev/null
+++ b/MenuDrawer/project.properties
@@ -0,0 +1,16 @@
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must be checked in Version Control Systems.
+#
+# To customize properties used by the Ant build system edit
+# "ant.properties", and override values to adapt the script to your
+# project structure.
+#
+# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
+#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
+
+android.library=true
+# Project target.
+target=android-16
+
diff --git a/MenuDrawer/res/values/attrs.xml b/MenuDrawer/res/values/attrs.xml
new file mode 100755
index 0000000..c8ec779
--- /dev/null
+++ b/MenuDrawer/res/values/attrs.xml
@@ -0,0 +1,43 @@
+<resources>
+
+    <!-- Reference to a style for the menu drawer. -->
+    <attr name="menuDrawerStyle" format="reference" />
+
+    <!-- Styleables used for styling the menu drawer. -->
+    <declare-styleable name="MenuDrawer">
+
+        <!-- Drawable to use for the background of the content. -->
+        <attr name="mdContentBackground" format="reference" />
+
+        <!-- Drawable to use for the background of the menu. -->
+        <attr name="mdMenuBackground" format="reference" />
+
+        <!-- The size of the menu. -->
+        <attr name="mdMenuSize" format="dimension" />
+
+        <!-- Drawable used as indicator for the active view. -->
+        <attr name="mdActiveIndicator" format="reference" />
+
+        <!-- Defines whether the content will have a dropshadow onto the menu. Default is true. -->
+        <attr name="mdDropShadowEnabled" format="boolean" />
+
+        <!-- The size of the drop shadow. Default is 6dp -->
+        <attr name="mdDropShadowSize" format="dimension" />
+
+        <!-- The color of the drop shadow. Default is #FF000000. -->
+        <attr name="mdDropShadowColor" format="color" />
+
+        <!-- Drawable used for the drop shadow. -->
+        <attr name="mdDropShadow" format="reference" />
+
+        <!-- The touch bezel size. -->
+        <attr name="mdTouchBezelSize" format="dimension" />
+
+        <!-- Whether the indicator should be animated between active views. -->
+        <attr name="mdAllowIndicatorAnimation" format="boolean" />
+
+        <!-- The maximum animation duration -->
+        <attr name="mdMaxAnimationDuration" format="integer" />
+    </declare-styleable>
+
+</resources>
diff --git a/MenuDrawer/res/values/colors.xml b/MenuDrawer/res/values/colors.xml
new file mode 100755
index 0000000..2866c6a
--- /dev/null
+++ b/MenuDrawer/res/values/colors.xml
@@ -0,0 +1,6 @@
+<resources>
+
+    <!-- The default background of the menu. -->
+    <color name="md__defaultBackground">#FF555555</color>
+
+</resources>
diff --git a/MenuDrawer/res/values/ids.xml b/MenuDrawer/res/values/ids.xml
new file mode 100755
index 0000000..c600191
--- /dev/null
+++ b/MenuDrawer/res/values/ids.xml
@@ -0,0 +1,20 @@
+<resources>
+
+    <!-- ID used when defining the content layout in XML. -->
+    <item name="mdContent" type="id" />
+
+    <!-- ID used when defining the menu layout in XML. -->
+    <item name="mdMenu" type="id" />
+
+    <!-- The ID of the content container. -->
+    <item name="md__content" type="id" />
+
+    <!-- The ID of the menu container. -->
+    <item name="md__menu" type="id" />
+
+    <!-- The ID of the drawer. -->
+    <item name="md__drawer" type="id" />
+
+    <!-- Used with View#setTag(int) to specify a position for the active view. -->
+    <item name="mdActiveViewPosition" type="id" />
+</resources>
diff --git a/MenuDrawer/res/values/styles.xml b/MenuDrawer/res/values/styles.xml
new file mode 100755
index 0000000..415be6d
--- /dev/null
+++ b/MenuDrawer/res/values/styles.xml
@@ -0,0 +1,11 @@
+<resources>
+
+    <style name="Widget" />
+
+    <!-- Base theme for the menu drawer. -->
+    <style name="Widget.MenuDrawer">
+        <item name="mdMenuBackground">@color/md__defaultBackground</item>
+        <item name="mdContentBackground">?android:attr/windowBackground</item>
+    </style>
+
+</resources>
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/BottomDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/BottomDrawer.java
new file mode 100755
index 0000000..7a2f7ac
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/BottomDrawer.java
@@ -0,0 +1,240 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.GradientDrawable;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+
+public class BottomDrawer extends VerticalDrawer {
+
+    private int mIndicatorLeft;
+
+    BottomDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public BottomDrawer(Context context) {
+        super(context);
+    }
+
+    public BottomDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public BottomDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    public void openMenu(boolean animate) {
+        animateOffsetTo(-mMenuSize, 0, animate);
+    }
+
+    @Override
+    public void closeMenu(boolean animate) {
+        animateOffsetTo(0, 0, animate);
+    }
+
+    @Override
+    public void setDropShadowColor(int color) {
+        final int endColor = color & 0x00FFFFFF;
+        mDropShadowDrawable = new GradientDrawable(GradientDrawable.Orientation.TOP_BOTTOM,
+                new int[] {
+                        color,
+                        endColor,
+                });
+        invalidate();
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        final int width = r - l;
+        final int height = b - t;
+        final int offsetPixels = (int) mOffsetPixels;
+        final int menuSize = mMenuSize;
+
+        mMenuContainer.layout(0, height - menuSize, width, height);
+        offsetMenu(offsetPixels);
+
+        if (USE_TRANSLATIONS) {
+            mContentContainer.layout(0, 0, width, height);
+        } else {
+            mContentContainer.layout(0, offsetPixels, width, height + offsetPixels);
+        }
+    }
+
+    /**
+     * Offsets the menu relative to its original position based on the position of the content.
+     *
+     * @param offsetPixels The number of pixels the content if offset.
+     */
+    private void offsetMenu(int offsetPixels) {
+        if (mOffsetMenu && mMenuSize != 0) {
+            final int height = getHeight();
+            final int menuSize = mMenuSize;
+            final float openRatio = (menuSize + (float) offsetPixels) / menuSize;
+
+            if (USE_TRANSLATIONS) {
+                if (offsetPixels != 0) {
+                    final int offset = (int) (0.25f * (openRatio * menuSize));
+                    mMenuContainer.setTranslationY(offset);
+                } else {
+                    mMenuContainer.setTranslationY(height + menuSize);
+                }
+
+            } else {
+                final int oldMenuTop = mMenuContainer.getTop();
+                final int offsetBy = (int) (0.25f * (openRatio * menuSize));
+                final int offset = height - mMenuSize + offsetBy - oldMenuTop;
+                mMenuContainer.offsetTopAndBottom(offset);
+                mMenuContainer.setVisibility(offsetPixels == 0 ? INVISIBLE : VISIBLE);
+            }
+        }
+    }
+
+    @Override
+    protected void drawDropShadow(Canvas canvas, int offsetPixels) {
+        final int width = getWidth();
+        final int height = getHeight();
+
+        mDropShadowDrawable.setBounds(0, height + offsetPixels, width, height + offsetPixels + mDropShadowSize);
+        mDropShadowDrawable.draw(canvas);
+    }
+
+    @Override
+    protected void drawMenuOverlay(Canvas canvas, int offsetPixels) {
+        final int width = getWidth();
+        final int height = getHeight();
+        final float openRatio = ((float) Math.abs(offsetPixels)) / mMenuSize;
+
+        mMenuOverlay.setBounds(0, height + offsetPixels, width, height);
+        mMenuOverlay.setAlpha((int) (MAX_MENU_OVERLAY_ALPHA * (1.f - openRatio)));
+        mMenuOverlay.draw(canvas);
+    }
+
+    @Override
+    protected void drawWindowEdge (Canvas canvas, int offsetPixels) {
+        final int width = getWidth();
+        final int height = getHeight();
+        final int edgeHeight = mWindowEdge.getIntrinsicHeight();
+        final int top = height + offsetPixels + edgeHeight;
+        final int bottom = height + offsetPixels;
+        final float openRatio = ((float) Math.abs(offsetPixels)) / mMenuSize;
+
+        mWindowEdge.setBounds(0, top, width, bottom);
+        mWindowEdge.setAlpha((int) (MAX_MENU_OVERLAY_ALPHA * (openRatio)));
+        mWindowEdge.draw(canvas);
+    }
+
+    @Override
+    protected void drawIndicator(Canvas canvas, int offsetPixels) {
+        if (mActiveView != null && isViewDescendant(mActiveView)) {
+            Integer position = (Integer) mActiveView.getTag(R.id.mdActiveViewPosition);
+            final int pos = position == null ? 0 : position;
+
+            if (pos == mActivePosition) {
+                final int height = getHeight();
+                final int menuHeight = mMenuSize;
+                final int indicatorHeight = mActiveIndicator.getHeight();
+
+                final float openRatio = ((float) Math.abs(offsetPixels)) / menuHeight;
+
+                mActiveView.getDrawingRect(mActiveRect);
+                offsetDescendantRectToMyCoords(mActiveView, mActiveRect);
+                final int indicatorWidth = mActiveIndicator.getWidth();
+
+                final float interpolatedRatio = 1.f - INDICATOR_INTERPOLATOR.getInterpolation((1.f - openRatio));
+                final int interpolatedHeight = (int) (indicatorHeight * interpolatedRatio);
+
+                final int indicatorBottom = height + offsetPixels + interpolatedHeight;
+                final int indicatorTop = indicatorBottom - indicatorHeight;
+                if (mIndicatorAnimating) {
+                    final int finalLeft = mActiveRect.left + ((mActiveRect.width() - indicatorWidth) / 2);
+                    final int startLeft = mIndicatorStartPos;
+                    final int diff = finalLeft - startLeft;
+                    final int startOffset = (int) (diff * mIndicatorOffset);
+                    mIndicatorLeft = startLeft + startOffset;
+                } else {
+                    mIndicatorLeft = mActiveRect.left + ((mActiveRect.width() - indicatorWidth) / 2);
+                }
+
+                canvas.save();
+                canvas.clipRect(mIndicatorLeft, height + offsetPixels, mIndicatorLeft + indicatorWidth,
+                        indicatorBottom);
+                canvas.drawBitmap(mActiveIndicator, mIndicatorLeft, indicatorTop, null);
+                canvas.restore();
+            }
+        }
+    }
+
+    @Override
+    protected int getIndicatorStartPos() {
+        return mIndicatorLeft;
+    }
+
+    @Override
+    protected void initPeekScroller() {
+        final int dx = -mMenuSize / 3;
+        mPeekScroller.startScroll(0, 0, dx, 0, PEEK_DURATION);
+    }
+
+    @Override
+    protected void onOffsetPixelsChanged(int offsetPixels) {
+        if (USE_TRANSLATIONS) {
+            mContentContainer.setTranslationY(offsetPixels);
+            offsetMenu(offsetPixels);
+            invalidate();
+        } else {
+            mContentContainer.offsetTopAndBottom(offsetPixels - mContentContainer.getTop());
+            offsetMenu(offsetPixels);
+            invalidate();
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////
+    // Touch handling
+    //////////////////////////////////////////////////////////////////////
+
+    @Override
+    protected boolean isContentTouch(MotionEvent ev) {
+        return ev.getY() < getHeight() + mOffsetPixels;
+    }
+
+    @Override
+    protected boolean onDownAllowDrag(MotionEvent ev) {
+        final int height = getHeight();
+        return (!mMenuVisible && mInitialMotionY >= height - mTouchSize)
+                || (mMenuVisible && mInitialMotionY <= height + mOffsetPixels);
+    }
+
+    @Override
+    protected boolean onMoveAllowDrag(MotionEvent ev, float diff) {
+        final int height = getHeight();
+        return (!mMenuVisible && mInitialMotionY >= height - mTouchSize && (diff < 0))
+                || (mMenuVisible && mInitialMotionY <= height + mOffsetPixels);
+    }
+
+    @Override
+    protected void onMoveEvent(float dx) {
+        setOffsetPixels(Math.max(Math.min(mOffsetPixels + dx, 0), -mMenuSize));
+    }
+
+    @Override
+    protected void onUpEvent(MotionEvent ev, boolean isDownOnOutside) {
+        final int offsetPixels = (int) mOffsetPixels;
+
+        if (mIsDragging) {
+            mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+            final int initialVelocity = (int) mVelocityTracker.getXVelocity();
+            mLastMotionY = ev.getY();
+            animateOffsetTo(mVelocityTracker.getYVelocity() < 0 ? -mMenuSize : 0, initialVelocity,
+                    true);
+
+            // Close the menu when content is clicked while the menu is visible.
+        } else if (mMenuVisible && ev.getY() < getHeight() + offsetPixels) {
+            closeMenu();
+        }
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/BottomStaticDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/BottomStaticDrawer.java
new file mode 100755
index 0000000..df4b5f4
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/BottomStaticDrawer.java
@@ -0,0 +1,85 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.GradientDrawable;
+import android.util.AttributeSet;
+
+public class BottomStaticDrawer extends StaticDrawer {
+
+    private int mIndicatorLeft;
+
+    BottomStaticDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public BottomStaticDrawer(Context context) {
+        super(context);
+    }
+
+    public BottomStaticDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public BottomStaticDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void initDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super.initDrawer(context, attrs, defStyle);
+        mPosition = Position.BOTTOM;
+    }
+
+    @Override
+    public void setDropShadowColor(int color) {
+        final int endColor = color & 0x00FFFFFF;
+        mDropShadowDrawable = new GradientDrawable(GradientDrawable.Orientation.TOP_BOTTOM, new int[] {
+                color,
+                endColor,
+        });
+        invalidate();
+    }
+
+    @Override
+    protected void drawIndicator(Canvas canvas) {
+        if (mActiveView != null && isViewDescendant(mActiveView)) {
+            Integer position = (Integer) mActiveView.getTag(R.id.mdActiveViewPosition);
+            final int pos = position == null ? 0 : position;
+
+            if (pos == mActivePosition) {
+                final int height = getHeight();
+                final int menuHeight = mMenuSize;
+                final int indicatorHeight = mActiveIndicator.getHeight();
+
+                mActiveView.getDrawingRect(mActiveRect);
+                offsetDescendantRectToMyCoords(mActiveView, mActiveRect);
+                final int indicatorWidth = mActiveIndicator.getWidth();
+
+                final int indicatorTop = height - menuHeight;
+                final int indicatorBottom = indicatorTop + indicatorHeight;
+                if (mIndicatorAnimating) {
+                    final int finalLeft = mActiveRect.left + ((mActiveRect.width() - indicatorWidth) / 2);
+                    final int startLeft = mIndicatorStartPos;
+                    final int diff = finalLeft - startLeft;
+                    final int startOffset = (int) (diff * mIndicatorOffset);
+                    mIndicatorLeft = startLeft + startOffset;
+                } else {
+                    mIndicatorLeft = mActiveRect.left + ((mActiveRect.width() - indicatorWidth) / 2);
+                }
+
+                canvas.save();
+                canvas.clipRect(mIndicatorLeft, indicatorTop, mIndicatorLeft + indicatorWidth,
+                        indicatorBottom);
+                canvas.drawBitmap(mActiveIndicator, mIndicatorLeft, indicatorTop, null);
+                canvas.restore();
+            }
+        }
+    }
+
+    @Override
+    protected int getIndicatorStartPos() {
+        return mIndicatorLeft;
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/BuildLayerFrameLayout.java b/MenuDrawer/src/net/simonvt/menudrawer/BuildLayerFrameLayout.java
new file mode 100755
index 0000000..45f5aa1
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/BuildLayerFrameLayout.java
@@ -0,0 +1,99 @@
+package net.simonvt.menudrawer;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.util.AttributeSet;
+import android.widget.FrameLayout;
+
+/**
+ * FrameLayout which caches the hardware layer if available.
+ * <p/>
+ * If it's not posted twice the layer either wont be built on start, or it'll be built twice.
+ */
+public class BuildLayerFrameLayout extends FrameLayout {
+
+    private boolean mChanged;
+
+    private boolean mHardwareLayersEnabled = true;
+
+    private boolean mAttached;
+
+    private boolean mFirst = true;
+
+    public BuildLayerFrameLayout(Context context) {
+        super(context);
+        if (MenuDrawer.USE_TRANSLATIONS) {
+            setLayerType(LAYER_TYPE_HARDWARE, null);
+        }
+    }
+
+    public BuildLayerFrameLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        if (MenuDrawer.USE_TRANSLATIONS) {
+            setLayerType(LAYER_TYPE_HARDWARE, null);
+        }
+    }
+
+    public BuildLayerFrameLayout(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        if (MenuDrawer.USE_TRANSLATIONS) {
+            setLayerType(LAYER_TYPE_HARDWARE, null);
+        }
+    }
+
+    void setHardwareLayersEnabled(boolean enabled) {
+        mHardwareLayersEnabled = enabled;
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        mAttached = true;
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        mAttached = false;
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+
+        if (MenuDrawer.USE_TRANSLATIONS && mHardwareLayersEnabled) {
+            post(new Runnable() {
+                @Override
+                public void run() {
+                    mChanged = true;
+                    invalidate();
+                }
+            });
+        }
+    }
+
+    @Override
+    protected void dispatchDraw(Canvas canvas) {
+        super.dispatchDraw(canvas);
+
+        if (mChanged && MenuDrawer.USE_TRANSLATIONS) {
+            post(new Runnable() {
+                @Override
+                public void run() {
+                    if (mAttached) {
+                        final int layerType = getLayerType();
+                        // If it's already a hardware layer, it'll be built anyway.
+                        if (layerType != LAYER_TYPE_HARDWARE || mFirst) {
+                            mFirst = false;
+                            setLayerType(LAYER_TYPE_HARDWARE, null);
+                            buildLayer();
+                            setLayerType(LAYER_TYPE_NONE, null);
+                        }
+                    }
+                }
+            });
+
+            mChanged = false;
+        }
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/ColorDrawable.java b/MenuDrawer/src/net/simonvt/menudrawer/ColorDrawable.java
new file mode 100755
index 0000000..10a35e7
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/ColorDrawable.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2008 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 net.simonvt.menudrawer;
+
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.PixelFormat;
+import android.graphics.drawable.Drawable;
+
+/**
+ * A specialized Drawable that fills the Canvas with a specified color.
+ * Note that a ColorDrawable ignores the ColorFilter.
+ * <p/>
+ * <p>It can be defined in an XML file with the <code>&lt;color></code> element.</p>
+ *
+ * @attr ref android.R.styleable#ColorDrawable_color
+ */
+public class ColorDrawable extends Drawable {
+
+    private ColorState mState;
+    private final Paint mPaint = new Paint();
+
+    /** Creates a new black ColorDrawable. */
+    public ColorDrawable() {
+        this(null);
+    }
+
+    /**
+     * Creates a new ColorDrawable with the specified color.
+     *
+     * @param color The color to draw.
+     */
+    public ColorDrawable(int color) {
+        this(null);
+        setColor(color);
+    }
+
+    private ColorDrawable(ColorState state) {
+        mState = new ColorState(state);
+    }
+
+    @Override
+    public int getChangingConfigurations() {
+        return super.getChangingConfigurations() | mState.mChangingConfigurations;
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        if ((mState.mUseColor >>> 24) != 0) {
+            mPaint.setColor(mState.mUseColor);
+            canvas.drawRect(getBounds(), mPaint);
+        }
+    }
+
+    /**
+     * Gets the drawable's color value.
+     *
+     * @return int The color to draw.
+     */
+    public int getColor() {
+        return mState.mUseColor;
+    }
+
+    /**
+     * Sets the drawable's color value. This action will clobber the results of prior calls to
+     * {@link #setAlpha(int)} on this object, which side-affected the underlying color.
+     *
+     * @param color The color to draw.
+     */
+    public void setColor(int color) {
+        if (mState.mBaseColor != color || mState.mUseColor != color) {
+            invalidateSelf();
+            mState.mBaseColor = mState.mUseColor = color;
+        }
+    }
+
+    /**
+     * Returns the alpha value of this drawable's color.
+     *
+     * @return A value between 0 and 255.
+     */
+    public int getAlpha() {
+        return mState.mUseColor >>> 24;
+    }
+
+    /**
+     * Sets the color's alpha value.
+     *
+     * @param alpha The alpha value to set, between 0 and 255.
+     */
+    public void setAlpha(int alpha) {
+        alpha += alpha >> 7;   // make it 0..256
+        int baseAlpha = mState.mBaseColor >>> 24;
+        int useAlpha = baseAlpha * alpha >> 8;
+        int oldUseColor = mState.mUseColor;
+        mState.mUseColor = (mState.mBaseColor << 8 >>> 8) | (useAlpha << 24);
+        if (oldUseColor != mState.mUseColor) {
+            invalidateSelf();
+        }
+    }
+
+    /**
+     * Setting a color filter on a ColorDrawable has no effect.
+     *
+     * @param colorFilter Ignore.
+     */
+    public void setColorFilter(ColorFilter colorFilter) {
+    }
+
+    public int getOpacity() {
+        switch (mState.mUseColor >>> 24) {
+            case 255:
+                return PixelFormat.OPAQUE;
+            case 0:
+                return PixelFormat.TRANSPARENT;
+        }
+        return PixelFormat.TRANSLUCENT;
+    }
+
+    @Override
+    public ConstantState getConstantState() {
+        mState.mChangingConfigurations = getChangingConfigurations();
+        return mState;
+    }
+
+    static final class ColorState extends ConstantState {
+
+        int mBaseColor; // base color, independent of setAlpha()
+        int mUseColor;  // basecolor modulated by setAlpha()
+        int mChangingConfigurations;
+
+        ColorState(ColorState state) {
+            if (state != null) {
+                mBaseColor = state.mBaseColor;
+                mUseColor = state.mUseColor;
+            }
+        }
+
+        @Override
+        public Drawable newDrawable() {
+            return new ColorDrawable(this);
+        }
+
+        @Override
+        public Drawable newDrawable(Resources res) {
+            return new ColorDrawable(this);
+        }
+
+        @Override
+        public int getChangingConfigurations() {
+            return mChangingConfigurations;
+        }
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/DraggableDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/DraggableDrawer.java
new file mode 100755
index 0000000..d0fa1ef
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/DraggableDrawer.java
@@ -0,0 +1,680 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.util.AttributeSet;
+import android.view.*;
+import android.view.animation.AccelerateInterpolator;
+import android.view.animation.Interpolator;
+
+public abstract class DraggableDrawer extends MenuDrawer {
+
+    /**
+     * Key used when saving menu visibility state.
+     */
+    private static final String STATE_MENU_VISIBLE = "net.simonvt.menudrawer.MenuDrawer.menuVisible";
+
+    /**
+     * Interpolator used for stretching/retracting the active indicator.
+     */
+    protected static final Interpolator INDICATOR_INTERPOLATOR = new AccelerateInterpolator();
+
+    /**
+     * Interpolator used for peeking at the drawer.
+     */
+    private static final Interpolator PEEK_INTERPOLATOR = new PeekInterpolator();
+
+    /**
+     * The maximum alpha of the dark menu overlay used for dimming the menu.
+     */
+    protected static final int MAX_MENU_OVERLAY_ALPHA = 255;
+
+    /**
+     * Default delay from {@link #peekDrawer()} is called until first animation is run.
+     */
+    private static final long DEFAULT_PEEK_START_DELAY = 5000;
+
+    /**
+     * Default delay between each subsequent animation, after {@link #peekDrawer()} has been called.
+     */
+    private static final long DEFAULT_PEEK_DELAY = 10000;
+
+    /**
+     * The duration of the peek animation.
+     */
+    protected static final int PEEK_DURATION = 5000;
+
+    /**
+     * Distance in dp from closed position from where the drawer is considered closed with regards to touch events.
+     */
+    private static final int CLOSE_ENOUGH = 3;
+
+    /**
+     * Slop before starting a drag.
+     */
+    protected int mTouchSlop;
+
+    /**
+     * Runnable used when the peek animation is running.
+     */
+    protected final Runnable mPeekRunnable = new Runnable() {
+        @Override
+        public void run () {
+            peekDrawerInvalidate();
+        }
+    };
+
+    /**
+     * Runnable used when animating the drawer open/closed.
+     */
+    private final Runnable mDragRunnable = new Runnable() {
+        @Override
+        public void run () {
+            postAnimationInvalidate();
+        }
+    };
+
+    /**
+     * Current left position of the content.
+     */
+    protected float mOffsetPixels;
+
+    /**
+     * Indicates whether the drawer is currently being dragged.
+     */
+    protected boolean mIsDragging;
+
+    /**
+     * The initial X position of a drag.
+     */
+    protected float mInitialMotionX;
+
+    /**
+     * The initial Y position of a drag.
+     */
+    protected float mInitialMotionY;
+
+    /**
+     * The last X position of a drag.
+     */
+    protected float mLastMotionX = -1;
+
+    /**
+     * The last Y position of a drag.
+     */
+    protected float mLastMotionY = -1;
+
+    /**
+     * Default delay between each subsequent animation, after {@link #peekDrawer()} has been called.
+     */
+    protected long mPeekDelay;
+
+    /**
+     * Scroller used for the peek drawer animation.
+     */
+    protected Scroller mPeekScroller;
+
+    /**
+     * Velocity tracker used when animating the drawer open/closed after a drag.
+     */
+    protected VelocityTracker mVelocityTracker;
+
+    /**
+     * Maximum velocity allowed when animating the drawer open/closed.
+     */
+    protected int mMaxVelocity;
+
+    /**
+     * Indicates whether the menu should be offset when dragging the drawer.
+     */
+    protected boolean mOffsetMenu = true;
+
+    /**
+     * Distance in px from closed position from where the drawer is considered closed with regards to touch events.
+     */
+    protected int mCloseEnough;
+
+    /**
+     * Runnable used for first call to {@link #startPeek()} after {@link #peekDrawer()}  has been called.
+     */
+    private Runnable mPeekStartRunnable;
+
+    /**
+     * Scroller used when animating the drawer open/closed.
+     */
+    private Scroller mScroller;
+
+    /**
+     * Indicates whether the current layer type is {@link android.view.View#LAYER_TYPE_HARDWARE}.
+     */
+    private boolean mLayerTypeHardware;
+
+    /**
+     * Indicates whether the menu overlay should be drawn
+     */
+    private boolean mDrawerOverlayEnabled = true;
+
+    DraggableDrawer (Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public DraggableDrawer (Context context) {
+        super(context);
+    }
+
+    public DraggableDrawer (Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public DraggableDrawer (Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void initDrawer (Context context, AttributeSet attrs, int defStyle) {
+        super.initDrawer(context, attrs, defStyle);
+
+        final ViewConfiguration configuration = ViewConfiguration.get(context);
+        mTouchSlop = configuration.getScaledTouchSlop();
+        mMaxVelocity = configuration.getScaledMaximumFlingVelocity();
+
+        mScroller = new Scroller(context, MenuDrawer.SMOOTH_INTERPOLATOR);
+        mPeekScroller = new Scroller(context, DraggableDrawer.PEEK_INTERPOLATOR);
+
+        mCloseEnough = dpToPx(DraggableDrawer.CLOSE_ENOUGH);
+    }
+
+    public void toggleMenu(boolean animate) {
+        if (mDrawerState == STATE_OPEN || mDrawerState == STATE_OPENING) {
+            closeMenu(animate);
+        } else if (mDrawerState == STATE_CLOSED || mDrawerState == STATE_CLOSING) {
+            openMenu(animate);
+        }
+    }
+
+    public boolean isMenuVisible() {
+        return mMenuVisible;
+    }
+
+    public void setMenuSize(final int size) {
+        mMenuSize = size;
+        mMenuSizeSet = true;
+        if (mDrawerState == STATE_OPEN || mDrawerState == STATE_OPENING) {
+            setOffsetPixels(mMenuSize);
+        }
+        requestLayout();
+        invalidate();
+    }
+
+    public void setOffsetMenuEnabled(boolean offsetMenu) {
+        if (offsetMenu != mOffsetMenu) {
+            mOffsetMenu = offsetMenu;
+            requestLayout();
+            invalidate();
+        }
+    }
+
+    public boolean getOffsetMenuEnabled() {
+        return mOffsetMenu;
+    }
+
+    public void peekDrawer() {
+        peekDrawer(DEFAULT_PEEK_START_DELAY, DEFAULT_PEEK_DELAY);
+    }
+
+    public void peekDrawer(long delay) {
+        peekDrawer(DEFAULT_PEEK_START_DELAY, delay);
+    }
+
+    public void peekDrawer(final long startDelay, final long delay) {
+        if (startDelay < 0) {
+            throw new IllegalArgumentException("startDelay must be zero or larger.");
+        }
+        if (delay < 0) {
+            throw new IllegalArgumentException("delay must be zero or larger");
+        }
+
+        removeCallbacks(mPeekRunnable);
+        removeCallbacks(mPeekStartRunnable);
+
+        mPeekDelay = delay;
+        mPeekStartRunnable = new Runnable() {
+            @Override
+            public void run() {
+                startPeek();
+            }
+        };
+        postDelayed(mPeekStartRunnable, startDelay);
+    }
+
+    public void setHardwareLayerEnabled(boolean enabled) {
+        if (enabled != mHardwareLayersEnabled) {
+            mHardwareLayersEnabled = enabled;
+            mMenuContainer.setHardwareLayersEnabled(enabled);
+            mContentContainer.setHardwareLayersEnabled(enabled);
+            stopLayerTranslation();
+        }
+    }
+
+    public void setDrawerOverlayEnabled (boolean enabled) {
+        mDrawerOverlayEnabled = enabled;
+    }
+
+    public int getTouchMode() {
+        return mTouchMode;
+    }
+
+    public void setTouchMode(int mode) {
+        if (mTouchMode != mode) {
+            mTouchMode = mode;
+            updateTouchAreaSize();
+        }
+    }
+
+    public void setTouchBezelSize(int size) {
+        mTouchBezelSize = size;
+    }
+
+    public int getTouchBezelSize() {
+        return mTouchBezelSize;
+    }
+
+    /**
+     * Sets the number of pixels the content should be offset.
+     *
+     * @param offsetPixels The number of pixels to offset the content by.
+     */
+    protected void setOffsetPixels(float offsetPixels) {
+        final int oldOffset = (int) mOffsetPixels;
+        final int newOffset = (int) offsetPixels;
+
+        mOffsetPixels = offsetPixels;
+
+        if (newOffset != oldOffset) {
+            onOffsetPixelsChanged(newOffset);
+            mMenuVisible = newOffset != 0;
+        }
+    }
+
+    /**
+     * Called when the number of pixels the content should be offset by has changed.
+     *
+     * @param offsetPixels The number of pixels to offset the content by.
+     */
+    protected abstract void onOffsetPixelsChanged(int offsetPixels);
+
+    /**
+     * If possible, set the layer type to {@link android.view.View#LAYER_TYPE_HARDWARE}.
+     */
+    protected void startLayerTranslation() {
+        if (USE_TRANSLATIONS && mHardwareLayersEnabled && !mLayerTypeHardware) {
+            mLayerTypeHardware = true;
+            mContentContainer.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+            mMenuContainer.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+        }
+    }
+
+    /**
+     * If the current layer type is {@link android.view.View#LAYER_TYPE_HARDWARE}, this will set it to
+     * {@link View#LAYER_TYPE_NONE}.
+     */
+    private void stopLayerTranslation() {
+        if (mLayerTypeHardware) {
+            mLayerTypeHardware = false;
+            mContentContainer.setLayerType(View.LAYER_TYPE_NONE, null);
+            mMenuContainer.setLayerType(View.LAYER_TYPE_NONE, null);
+        }
+    }
+
+    /**
+     * Compute the touch area based on the touch mode.
+     */
+    protected void updateTouchAreaSize() {
+        if (mTouchMode == TOUCH_MODE_BEZEL) {
+            mTouchSize = mTouchBezelSize;
+        } else if (mTouchMode == TOUCH_MODE_FULLSCREEN) {
+            mTouchSize = getMeasuredWidth();
+        } else {
+            mTouchSize = 0;
+        }
+    }
+
+    /**
+     * Called when a drag has been ended.
+     */
+    protected void endDrag() {
+        mIsDragging = false;
+
+        if (mVelocityTracker != null) {
+            mVelocityTracker.recycle();
+            mVelocityTracker = null;
+        }
+    }
+
+    /**
+     * Stops ongoing animation of the drawer.
+     */
+    protected void stopAnimation() {
+        removeCallbacks(mDragRunnable);
+        mScroller.abortAnimation();
+        stopLayerTranslation();
+    }
+
+    /**
+     * Called when a drawer animation has successfully completed.
+     */
+    private void completeAnimation() {
+        mScroller.abortAnimation();
+        final int finalX = mScroller.getFinalX();
+        setOffsetPixels(finalX);
+        setDrawerState(finalX == 0 ? STATE_CLOSED : STATE_OPEN);
+        stopLayerTranslation();
+    }
+
+    /**
+     * Moves the drawer to the position passed.
+     *
+     * @param position The position the content is moved to.
+     * @param velocity Optional velocity if called by releasing a drag event.
+     * @param animate  Whether the move is animated.
+     */
+    protected void animateOffsetTo(int position, int velocity, boolean animate) {
+        endDrag();
+        endPeek();
+
+        final int startX = (int) mOffsetPixels;
+        final int dx = position - startX;
+        if (dx == 0 || !animate) {
+            setOffsetPixels(position);
+            setDrawerState(position == 0 ? STATE_CLOSED : STATE_OPEN);
+            stopLayerTranslation();
+            return;
+        }
+
+        int duration;
+
+        velocity = Math.abs(velocity);
+        if (velocity > 0) {
+            duration = 4 * Math.round(1000.f * Math.abs((float) dx / velocity));
+        } else {
+            duration = (int) (600.f * Math.abs((float) dx / mMenuSize));
+        }
+
+        duration = Math.min(duration, mMaxAnimationDuration);
+
+        if (dx > 0) {
+            setDrawerState(STATE_OPENING);
+            mScroller.startScroll(startX, 0, dx, 0, duration);
+        } else {
+            setDrawerState(STATE_CLOSING);
+            mScroller.startScroll(startX, 0, dx, 0, duration);
+        }
+
+        startLayerTranslation();
+
+        postAnimationInvalidate();
+    }
+
+    /**
+     * Callback when each frame in the drawer animation should be drawn.
+     */
+    private void postAnimationInvalidate() {
+        if (mScroller.computeScrollOffset()) {
+            final int oldX = (int) mOffsetPixels;
+            final int x = mScroller.getCurrX();
+
+            if (x != oldX) setOffsetPixels(x);
+            if (x != mScroller.getFinalX()) {
+                postOnAnimation(mDragRunnable);
+                return;
+            }
+        }
+
+        completeAnimation();
+    }
+
+    /**
+     * Starts peek drawer animation.
+     */
+    protected void startPeek() {
+        initPeekScroller();
+
+        startLayerTranslation();
+        peekDrawerInvalidate();
+    }
+
+    protected abstract void initPeekScroller();
+
+    /**
+     * Callback when each frame in the peek drawer animation should be drawn.
+     */
+    private void peekDrawerInvalidate() {
+        if (mPeekScroller.computeScrollOffset()) {
+            final int oldX = (int) mOffsetPixels;
+            final int x = mPeekScroller.getCurrX();
+            if (x != oldX) setOffsetPixels(x);
+
+            if (!mPeekScroller.isFinished()) {
+                postOnAnimation(mPeekRunnable);
+                return;
+
+            } else if (mPeekDelay > 0) {
+                mPeekStartRunnable = new Runnable() {
+                    @Override
+                    public void run() {
+                        startPeek();
+                    }
+                };
+                postDelayed(mPeekStartRunnable, mPeekDelay);
+            }
+        }
+
+        completePeek();
+    }
+
+    /**
+     * Called when the peek drawer animation has successfully completed.
+     */
+    private void completePeek() {
+        mPeekScroller.abortAnimation();
+
+        setOffsetPixels(0);
+
+        setDrawerState(STATE_CLOSED);
+        stopLayerTranslation();
+    }
+
+    /**
+     * Stops ongoing peek drawer animation.
+     */
+    protected void endPeek() {
+        removeCallbacks(mPeekStartRunnable);
+        removeCallbacks(mPeekRunnable);
+        stopLayerTranslation();
+    }
+
+    protected boolean isCloseEnough() {
+        return Math.abs(mOffsetPixels) <= mCloseEnough;
+    }
+
+    /**
+     * Returns true if the touch event occurs over the content.
+     *
+     * @param ev The motion event.
+     * @return True if the touch event occurred over the content, false otherwise.
+     */
+    protected abstract boolean isContentTouch(MotionEvent ev);
+
+    /**
+     * Returns true if dragging the content should be allowed.
+     *
+     * @param ev The motion event.
+     * @return True if dragging the content should be allowed, false otherwise.
+     */
+    protected abstract boolean onDownAllowDrag(MotionEvent ev);
+
+    /**
+     * Tests scrollability within child views of v given a delta of dx.
+     *
+     * @param v      View to test for horizontal scrollability
+     * @param checkV Whether the view should be checked for draggability
+     * @param dx     Delta scrolled in pixels
+     * @param x      X coordinate of the active touch point
+     * @param y      Y coordinate of the active touch point
+     * @return true if child views of v can be scrolled by delta of dx.
+     */
+    protected boolean canChildScrollHorizontally(View v, boolean checkV, int dx, int x, int y) {
+        if (v instanceof ViewGroup) {
+            final ViewGroup group = (ViewGroup) v;
+
+            final int count = group.getChildCount();
+            // Count backwards - let topmost views consume scroll distance first.
+            for (int i = count - 1; i >= 0; i--) {
+                final View child = group.getChildAt(i);
+
+                final int childLeft = child.getLeft() + supportGetTranslationX(child);
+                final int childRight = child.getRight() + supportGetTranslationX(child);
+                final int childTop = child.getTop() + supportGetTranslationY(child);
+                final int childBottom = child.getBottom() + supportGetTranslationY(child);
+
+                if (x >= childLeft && x < childRight && y >= childTop && y < childBottom
+                        &&  canChildScrollHorizontally(child, true, dx, x - childLeft, y - childTop)) {
+                    return true;
+                }
+            }
+        }
+
+        return checkV && mOnInterceptMoveEventListener.isViewDraggable(v, dx, x, y);
+    }
+
+    /**
+     * Tests scrollability within child views of v given a delta of dx.
+     *
+     * @param v      View to test for horizontal scrollability
+     * @param checkV Whether the view should be checked for draggability
+     * @param dx     Delta scrolled in pixels
+     * @param x      X coordinate of the active touch point
+     * @param y      Y coordinate of the active touch point
+     * @return true if child views of v can be scrolled by delta of dx.
+     */
+    protected boolean canChildScrollVertically(View v, boolean checkV, int dx, int x, int y) {
+        if (v instanceof ViewGroup) {
+            final ViewGroup group = (ViewGroup) v;
+
+            final int count = group.getChildCount();
+            // Count backwards - let topmost views consume scroll distance first.
+            for (int i = count - 1; i >= 0; i--) {
+                final View child = group.getChildAt(i);
+
+                final int childLeft = child.getLeft() + supportGetTranslationX(child);
+                final int childRight = child.getRight() + supportGetTranslationX(child);
+                final int childTop = child.getTop() + supportGetTranslationY(child);
+                final int childBottom = child.getBottom() + supportGetTranslationY(child);
+
+                if (x >= childLeft && x < childRight && y >= childTop && y < childBottom
+                        && canChildScrollVertically(child, true, dx, x - childLeft, y - childTop)) {
+                    return true;
+                }
+            }
+        }
+
+        return checkV && mOnInterceptMoveEventListener.isViewDraggable(v, dx, x, y);
+    }
+
+    private int supportGetTranslationY(View v) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+            return (int) v.getTranslationY();
+        }
+
+        return 0;
+    }
+
+    private int supportGetTranslationX(View v) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+            return (int) v.getTranslationX();
+        }
+
+        return 0;
+    }
+
+    /**
+     * Returns true if dragging the content should be allowed.
+     *
+     * @param ev The motion event.
+     * @return True if dragging the content should be allowed, false otherwise.
+     */
+    protected abstract boolean onMoveAllowDrag(MotionEvent ev, float dx);
+
+    /**
+     * Called when a move event has happened while dragging the content is in progress.
+     *
+     * @param dx The X difference between the last motion event and the current motion event.
+     */
+    protected abstract void onMoveEvent(float dx);
+
+    /**
+     * Called when {@link android.view.MotionEvent#ACTION_UP} of {@link android.view.MotionEvent#ACTION_CANCEL} is
+     * delivered to {@link net.simonvt.menudrawer.MenuDrawer#onTouchEvent(android.view.MotionEvent)}.
+     *
+     * @param ev The motion event.
+     */
+    protected abstract void onUpEvent(MotionEvent ev, boolean isDownOnOutside);
+
+    @Override
+    protected void dispatchDraw(Canvas canvas) {
+        super.dispatchDraw(canvas);
+        final int offsetPixels = (int) mOffsetPixels;
+
+        if (offsetPixels != 0 && mDrawerOverlayEnabled) drawMenuOverlay(canvas, offsetPixels);
+        if (offsetPixels != 0 && mWindowEdge != null) drawWindowEdge(canvas, offsetPixels);
+        if (mDropShadowEnabled) drawDropShadow(canvas, offsetPixels);
+        if (mActiveIndicator != null) drawIndicator(canvas, offsetPixels);
+    }
+
+    /**
+     * Called when the content drop shadow should be drawn.
+     *
+     * @param canvas       The canvas on which to draw.
+     * @param offsetPixels Value in pixels indicating the offset.
+     */
+    protected abstract void drawDropShadow(Canvas canvas, int offsetPixels);
+
+    /**
+     * Called when the menu overlay should be drawn.
+     *
+     * @param canvas       The canvas on which to draw.
+     * @param offsetPixels Value in pixels indicating the offset.
+     */
+    protected abstract void drawMenuOverlay(Canvas canvas, int offsetPixels);
+
+    /**
+     * Called when the active indicator should be drawn.
+     *
+     * @param canvas       The canvas on which to draw.
+     * @param offsetPixels Value in pixels indicating the offset.
+     */
+    protected abstract void drawIndicator(Canvas canvas, int offsetPixels);
+
+    protected abstract void drawWindowEdge(Canvas canvas, int offsetPixels);
+
+    void saveState(Bundle state) {
+        final boolean menuVisible = mDrawerState == STATE_OPEN || mDrawerState == STATE_OPENING;
+        state.putBoolean(STATE_MENU_VISIBLE, menuVisible);
+    }
+
+    public void restoreState(Parcelable in) {
+        super.restoreState(in);
+        Bundle state = (Bundle) in;
+        final boolean menuOpen = state.getBoolean(STATE_MENU_VISIBLE);
+        if (menuOpen) {
+            openMenu(false);
+        } else {
+            setOffsetPixels(0);
+        }
+        mDrawerState = menuOpen ? STATE_OPEN : STATE_CLOSED;
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/FloatScroller.java b/MenuDrawer/src/net/simonvt/menudrawer/FloatScroller.java
new file mode 100755
index 0000000..df5b445
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/FloatScroller.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2006 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 net.simonvt.menudrawer;
+
+import android.view.animation.AnimationUtils;
+import android.view.animation.Interpolator;
+
+/**
+ * This class encapsulates scrolling.  The duration of the scroll
+ * can be passed in the constructor and specifies the maximum time that
+ * the scrolling animation should take.  Past this time, the scrolling is
+ * automatically moved to its final stage and computeScrollOffset()
+ * will always return false to indicate that scrolling is over.
+ */
+public class FloatScroller {
+
+    private float mStart;
+    private float mFinal;
+
+    private float mCurr;
+    private long mStartTime;
+    private int mDuration;
+    private float mDurationReciprocal;
+    private float mDeltaX;
+    private boolean mFinished;
+    private Interpolator mInterpolator;
+
+    /**
+     * Create a Scroller with the specified interpolator. If the interpolator is
+     * null, the default (viscous) interpolator will be used. Specify whether or
+     * not to support progressive "flywheel" behavior in flinging.
+     */
+    public FloatScroller(Interpolator interpolator) {
+        mFinished = true;
+        mInterpolator = interpolator;
+    }
+
+    /**
+     * Returns whether the scroller has finished scrolling.
+     *
+     * @return True if the scroller has finished scrolling, false otherwise.
+     */
+    public final boolean isFinished() {
+        return mFinished;
+    }
+
+    /**
+     * Force the finished field to a particular value.
+     *
+     * @param finished The new finished value.
+     */
+    public final void forceFinished(boolean finished) {
+        mFinished = finished;
+    }
+
+    /**
+     * Returns how long the scroll event will take, in milliseconds.
+     *
+     * @return The duration of the scroll in milliseconds.
+     */
+    public final int getDuration() {
+        return mDuration;
+    }
+
+    /**
+     * Returns the current offset in the scroll.
+     *
+     * @return The new offset as an absolute distance from the origin.
+     */
+    public final float getCurr() {
+        return mCurr;
+    }
+
+    /**
+     * Returns the start offset in the scroll.
+     *
+     * @return The start offset as an absolute distance from the origin.
+     */
+    public final float getStart() {
+        return mStart;
+    }
+
+    /**
+     * Returns where the scroll will end. Valid only for "fling" scrolls.
+     *
+     * @return The final offset as an absolute distance from the origin.
+     */
+    public final float getFinal() {
+        return mFinal;
+    }
+
+    public boolean computeScrollOffset() {
+        if (mFinished) {
+            return false;
+        }
+
+        int timePassed = (int) (AnimationUtils.currentAnimationTimeMillis() - mStartTime);
+
+        if (timePassed < mDuration) {
+            float x = timePassed * mDurationReciprocal;
+            x = mInterpolator.getInterpolation(x);
+            mCurr = mStart + x * mDeltaX;
+
+        } else {
+            mCurr = mFinal;
+            mFinished = true;
+        }
+        return true;
+    }
+
+    public void startScroll(float start, float delta, int duration) {
+        mFinished = false;
+        mDuration = duration;
+        mStartTime = AnimationUtils.currentAnimationTimeMillis();
+        mStart = start;
+        mFinal = start + delta;
+        mDeltaX = delta;
+        mDurationReciprocal = 1.0f / (float) mDuration;
+    }
+
+    /**
+     * Stops the animation. Contrary to {@link #forceFinished(boolean)},
+     * aborting the animating cause the scroller to move to the final x and y
+     * position
+     *
+     * @see #forceFinished(boolean)
+     */
+    public void abortAnimation() {
+        mCurr = mFinal;
+        mFinished = true;
+    }
+
+    /**
+     * Extend the scroll animation. This allows a running animation to scroll
+     * further and longer, when used with {@link #setFinal(float)}.
+     *
+     * @param extend Additional time to scroll in milliseconds.
+     * @see #setFinal(float)
+     */
+    public void extendDuration(int extend) {
+        int passed = timePassed();
+        mDuration = passed + extend;
+        mDurationReciprocal = 1.0f / mDuration;
+        mFinished = false;
+    }
+
+    /**
+     * Returns the time elapsed since the beginning of the scrolling.
+     *
+     * @return The elapsed time in milliseconds.
+     */
+    public int timePassed() {
+        return (int) (AnimationUtils.currentAnimationTimeMillis() - mStartTime);
+    }
+
+    public void setFinal(float newVal) {
+        mFinal = newVal;
+        mDeltaX = mFinal - mStart;
+        mFinished = false;
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/HorizontalDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/HorizontalDrawer.java
new file mode 100755
index 0000000..0f25684
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/HorizontalDrawer.java
@@ -0,0 +1,211 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+
+public abstract class HorizontalDrawer extends DraggableDrawer {
+
+    private static final String TAG = "HorizontalDrawer";
+
+    HorizontalDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public HorizontalDrawer(Context context) {
+        super(context);
+    }
+
+    public HorizontalDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public HorizontalDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+
+        if (widthMode != MeasureSpec.EXACTLY || heightMode != MeasureSpec.EXACTLY) {
+            throw new IllegalStateException("Must measure with an exact size");
+        }
+
+        final int width = MeasureSpec.getSize(widthMeasureSpec);
+        final int height = MeasureSpec.getSize(heightMeasureSpec);
+
+        if (!mMenuSizeSet) mMenuSize = (int) (width * 0.8f);
+        if (mOffsetPixels == -1) openMenu(false);
+
+        final int menuWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, mMenuSize);
+        final int menuHeightMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, height);
+        mMenuContainer.measure(menuWidthMeasureSpec, menuHeightMeasureSpec);
+
+        final int contentWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, width);
+        final int contentHeightMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, height);
+        mContentContainer.measure(contentWidthMeasureSpec, contentHeightMeasureSpec);
+
+        setMeasuredDimension(width, height);
+
+        updateTouchAreaSize();
+    }
+
+    @Override
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        final int action = ev.getAction() & MotionEvent.ACTION_MASK;
+
+        if (action == MotionEvent.ACTION_DOWN && mMenuVisible && isCloseEnough()) {
+            setOffsetPixels(0);
+            stopAnimation();
+            endPeek();
+            setDrawerState(STATE_CLOSED);
+        }
+
+        // Always intercept events over the content while menu is visible.
+        if (mMenuVisible && isContentTouch(ev)) return true;
+
+        if (mTouchMode == TOUCH_MODE_NONE) {
+            return false;
+        }
+
+        if (action != MotionEvent.ACTION_DOWN) {
+            if (mIsDragging) return true;
+        }
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN: {
+                mLastMotionX = mInitialMotionX = ev.getX();
+                mLastMotionY = mInitialMotionY = ev.getY();
+                final boolean allowDrag = onDownAllowDrag(ev);
+
+                if (allowDrag) {
+                    setDrawerState(mMenuVisible ? STATE_OPEN : STATE_CLOSED);
+                    stopAnimation();
+                    endPeek();
+                    mIsDragging = false;
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_MOVE: {
+                final float x = ev.getX();
+                final float dx = x - mLastMotionX;
+                final float xDiff = Math.abs(dx);
+                final float y = ev.getY();
+                final float yDiff = Math.abs(y - mLastMotionY);
+
+                if (xDiff > mTouchSlop && xDiff > yDiff) {
+                    if (mOnInterceptMoveEventListener != null && mTouchMode == TOUCH_MODE_FULLSCREEN
+                            && canChildScrollHorizontally(mContentContainer, false, (int) dx, (int) x, (int) y)) {
+                        endDrag(); // Release the velocity tracker
+                        return false;
+                    }
+
+                    final boolean allowDrag = onMoveAllowDrag(ev, dx);
+
+                    if (allowDrag) {
+                        setDrawerState(STATE_DRAGGING);
+                        mIsDragging = true;
+                        mLastMotionX = x;
+                        mLastMotionY = y;
+                    }
+                }
+                break;
+            }
+
+            /**
+             * If you click really fast, an up or cancel event is delivered here.
+             * Just snap content to whatever is closest.
+             * */
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP: {
+                if (Math.abs(mOffsetPixels) > mMenuSize / 2) {
+                    openMenu();
+                } else {
+                    closeMenu();
+                }
+                break;
+            }
+        }
+
+        if (mVelocityTracker == null) mVelocityTracker = VelocityTracker.obtain();
+        mVelocityTracker.addMovement(ev);
+
+        return mIsDragging;
+    }
+
+    private boolean mIsDownOnOutside = false;
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        if (!mMenuVisible && !mIsDragging && (mTouchMode == TOUCH_MODE_NONE)) {
+            return false;
+        }
+        final int action = ev.getAction() & MotionEvent.ACTION_MASK;
+
+        if (mVelocityTracker == null) mVelocityTracker = VelocityTracker.obtain();
+        mVelocityTracker.addMovement(ev);
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN: {
+                mIsDownOnOutside = ev.getX() <= getWidth() + mOffsetPixels;
+                mLastMotionX = mInitialMotionX = ev.getX();
+                mLastMotionY = mInitialMotionY = ev.getY();
+                final boolean allowDrag = onDownAllowDrag(ev);
+
+                if (allowDrag) {
+                    stopAnimation();
+                    endPeek();
+                    startLayerTranslation();
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_MOVE: {
+                if (!mIsDragging) {
+                    final float x = ev.getX();
+                    final float dx = x - mLastMotionX;
+                    final float xDiff = Math.abs(dx);
+                    final float y = ev.getY();
+                    final float yDiff = Math.abs(y - mLastMotionY);
+
+                    if (xDiff > mTouchSlop && xDiff > yDiff) {
+                        final boolean allowDrag = onMoveAllowDrag(ev, dx);
+
+                        if (allowDrag) {
+                            setDrawerState(STATE_DRAGGING);
+                            mIsDragging = true;
+                            mLastMotionX = x - mInitialMotionX > 0
+                                    ? mInitialMotionX + mTouchSlop
+                                    : mInitialMotionX - mTouchSlop;
+                        }
+                    }
+                }
+
+                if (mIsDragging) {
+                    startLayerTranslation();
+
+                    final float x = ev.getX();
+                    final float dx = x - mLastMotionX;
+
+                    mLastMotionX = x;
+                    onMoveEvent(dx);
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP: {
+                onUpEvent(ev, mIsDownOnOutside);
+                mIsDownOnOutside = false;
+                break;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/LeftDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/LeftDrawer.java
new file mode 100755
index 0000000..c204ae7
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/LeftDrawer.java
@@ -0,0 +1,225 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.GradientDrawable;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+
+public class LeftDrawer extends HorizontalDrawer {
+
+    private int mIndicatorTop;
+
+    LeftDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public LeftDrawer(Context context) {
+        super(context);
+    }
+
+    public LeftDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public LeftDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    public void openMenu(boolean animate) {
+        animateOffsetTo(mMenuSize, 0, animate);
+    }
+
+    @Override
+    public void closeMenu(boolean animate) {
+        animateOffsetTo(0, 0, animate);
+    }
+
+    @Override
+    public void setDropShadowColor(int color) {
+        final int endColor = color & 0x00FFFFFF;
+        mDropShadowDrawable = new GradientDrawable(GradientDrawable.Orientation.RIGHT_LEFT, new int[] {
+                color,
+                endColor,
+        });
+        invalidate();
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        final int width = r - l;
+        final int height = b - t;
+        final int offsetPixels = (int) mOffsetPixels;
+
+        mMenuContainer.layout(0, 0, mMenuSize, height);
+        offsetMenu(offsetPixels);
+
+        if (USE_TRANSLATIONS) {
+            mContentContainer.layout(0, 0, width, height);
+        } else {
+            mContentContainer.layout(offsetPixels, 0, width + offsetPixels, height);
+        }
+    }
+
+    /**
+     * Offsets the menu relative to its original position based on the position of the content.
+     *
+     * @param offsetPixels The number of pixels the content if offset.
+     */
+    private void offsetMenu(int offsetPixels) {
+        if (mOffsetMenu && mMenuSize != 0) {
+            final int menuWidth = mMenuSize;
+            final float openRatio = (menuWidth - (float) offsetPixels) / menuWidth;
+
+            if (USE_TRANSLATIONS) {
+                if (offsetPixels > 0) {
+                    final int menuLeft = (int) (0.25f * (-openRatio * menuWidth));
+                    mMenuContainer.setTranslationX(menuLeft);
+                } else {
+                    mMenuContainer.setTranslationX(-menuWidth);
+                }
+
+            } else {
+                final int oldMenuLeft = mMenuContainer.getLeft();
+                final int offset = (int) (0.25f * (-openRatio * menuWidth)) - oldMenuLeft;
+                mMenuContainer.offsetLeftAndRight(offset);
+                mMenuContainer.setVisibility(offsetPixels == 0 ? INVISIBLE : VISIBLE);
+            }
+        }
+    }
+
+    @Override
+    protected void drawDropShadow(Canvas canvas, int offsetPixels) {
+        final int height = getHeight();
+
+        mDropShadowDrawable.setBounds(offsetPixels - mDropShadowSize, 0, offsetPixels, height);
+        mDropShadowDrawable.draw(canvas);
+    }
+
+    @Override
+    protected void drawMenuOverlay(Canvas canvas, int offsetPixels) {
+        final int height = getHeight();
+        final float openRatio = ((float) offsetPixels) / mMenuSize;
+
+        mMenuOverlay.setBounds(0, 0, offsetPixels, height);
+        mMenuOverlay.setAlpha((int) (MAX_MENU_OVERLAY_ALPHA * (1.f - openRatio)));
+        mMenuOverlay.draw(canvas);
+    }
+
+    @Override
+    protected void drawWindowEdge (Canvas canvas, int offsetPixels) {
+        final int height = getHeight();
+        final int edgeWidth = mWindowEdge.getIntrinsicWidth();
+        final int left = offsetPixels;
+        final int right = offsetPixels + edgeWidth;
+        final float openRatio = ((float) Math.abs(offsetPixels)) / mMenuSize;
+
+        mWindowEdge.setBounds(left, 0, right, height);
+        mWindowEdge.setAlpha((int) (MAX_MENU_OVERLAY_ALPHA * (openRatio)));
+        mWindowEdge.draw(canvas);
+    }
+
+    @Override
+    protected void drawIndicator(Canvas canvas, int offsetPixels) {
+        if (mActiveView != null && isViewDescendant(mActiveView)) {
+            Integer position = (Integer) mActiveView.getTag(R.id.mdActiveViewPosition);
+            final int pos = position == null ? 0 : position;
+
+            if (pos == mActivePosition) {
+                final float openRatio = ((float) offsetPixels) / mMenuSize;
+
+                mActiveView.getDrawingRect(mActiveRect);
+                offsetDescendantRectToMyCoords(mActiveView, mActiveRect);
+
+                final float interpolatedRatio = 1.f - INDICATOR_INTERPOLATOR.getInterpolation((1.f - openRatio));
+                final int interpolatedWidth = (int) (mActiveIndicator.getWidth() * interpolatedRatio);
+
+                if (mIndicatorAnimating) {
+                    final int indicatorFinalTop = mActiveRect.top + ((mActiveRect.height()
+                            - mActiveIndicator.getHeight()) / 2);
+                    final int indicatorStartTop = mIndicatorStartPos;
+                    final int diff = indicatorFinalTop - indicatorStartTop;
+                    final int startOffset = (int) (diff * mIndicatorOffset);
+                    mIndicatorTop = indicatorStartTop + startOffset;
+                } else {
+                    mIndicatorTop = mActiveRect.top + ((mActiveRect.height() - mActiveIndicator.getHeight()) / 2);
+                }
+                final int right = offsetPixels;
+                final int left = right - interpolatedWidth;
+
+                canvas.save();
+                canvas.clipRect(left, 0, right, getHeight());
+                canvas.drawBitmap(mActiveIndicator, left, mIndicatorTop, null);
+                canvas.restore();
+            }
+        }
+    }
+
+    @Override
+    protected int getIndicatorStartPos() {
+        return mIndicatorTop;
+    }
+
+    @Override
+    protected void initPeekScroller() {
+        final int dx = mMenuSize / 3;
+        mPeekScroller.startScroll(0, 0, dx, 0, PEEK_DURATION);
+    }
+
+    @Override
+    protected void onOffsetPixelsChanged(int offsetPixels) {
+        if (USE_TRANSLATIONS) {
+            mContentContainer.setTranslationX(offsetPixels);
+            offsetMenu(offsetPixels);
+            invalidate();
+        } else {
+            mContentContainer.offsetLeftAndRight(offsetPixels - mContentContainer.getLeft());
+            offsetMenu(offsetPixels);
+            invalidate();
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////
+    // Touch handling
+    //////////////////////////////////////////////////////////////////////
+
+    @Override
+    protected boolean isContentTouch(MotionEvent ev) {
+        return ev.getX() > mOffsetPixels;
+    }
+
+    @Override
+    protected boolean onDownAllowDrag(MotionEvent ev) {
+        return (!mMenuVisible && mInitialMotionX <= mTouchSize)
+                || (mMenuVisible && mInitialMotionX >= mOffsetPixels);
+    }
+
+    @Override
+    protected boolean onMoveAllowDrag(MotionEvent ev, float diff) {
+        return (!mMenuVisible && mInitialMotionX <= mTouchSize && (diff > 0))
+                || (mMenuVisible && mInitialMotionX >= mOffsetPixels);
+    }
+
+    @Override
+    protected void onMoveEvent(float dx) {
+        setOffsetPixels(Math.min(Math.max(mOffsetPixels + dx, 0), mMenuSize));
+    }
+
+    @Override
+    protected void onUpEvent(MotionEvent ev, boolean isDownOnOutside) {
+        final int offsetPixels = (int) mOffsetPixels;
+
+        if (mIsDragging) {
+            mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+            final int initialVelocity = (int) mVelocityTracker.getXVelocity();
+            mLastMotionX = ev.getX();
+            animateOffsetTo(mVelocityTracker.getXVelocity() > 0 ? mMenuSize : 0, initialVelocity, true);
+
+            // Close the menu when content is clicked while the menu is visible.
+        } else if (mMenuVisible && ev.getX() > offsetPixels) {
+            closeMenu();
+        }
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/LeftStaticDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/LeftStaticDrawer.java
new file mode 100755
index 0000000..47fa75a
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/LeftStaticDrawer.java
@@ -0,0 +1,80 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.GradientDrawable;
+import android.util.AttributeSet;
+
+public class LeftStaticDrawer extends StaticDrawer {
+
+    private int mIndicatorTop;
+
+    LeftStaticDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public LeftStaticDrawer(Context context) {
+        super(context);
+    }
+
+    public LeftStaticDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public LeftStaticDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void initDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super.initDrawer(context, attrs, defStyle);
+        mPosition = Position.LEFT;
+    }
+
+    @Override
+    public void setDropShadowColor(int color) {
+        final int endColor = color & 0x00FFFFFF;
+        mDropShadowDrawable = new GradientDrawable(GradientDrawable.Orientation.RIGHT_LEFT, new int[] {
+                color,
+                endColor,
+        });
+        invalidate();
+    }
+
+    @Override
+    protected void drawIndicator(Canvas canvas) {
+        if (mActiveView != null && isViewDescendant(mActiveView)) {
+            Integer position = (Integer) mActiveView.getTag(R.id.mdActiveViewPosition);
+            final int pos = position == null ? 0 : position;
+
+            if (pos == mActivePosition) {
+                mActiveView.getDrawingRect(mActiveRect);
+                offsetDescendantRectToMyCoords(mActiveView, mActiveRect);
+
+                if (mIndicatorAnimating) {
+                    final int indicatorFinalTop = mActiveRect.top + ((mActiveRect.height()
+                            - mActiveIndicator.getHeight()) / 2);
+                    final int indicatorStartTop = mIndicatorStartPos;
+                    final int diff = indicatorFinalTop - indicatorStartTop;
+                    final int startOffset = (int) (diff * mIndicatorOffset);
+                    mIndicatorTop = indicatorStartTop + startOffset;
+                } else {
+                    mIndicatorTop = mActiveRect.top + ((mActiveRect.height() - mActiveIndicator.getHeight()) / 2);
+                }
+                final int right = mMenuSize;
+                final int left = right - mActiveIndicator.getWidth();
+
+                canvas.save();
+                canvas.clipRect(left, 0, right, getHeight());
+                canvas.drawBitmap(mActiveIndicator, left, mIndicatorTop, null);
+                canvas.restore();
+            }
+        }
+    }
+
+    @Override
+    protected int getIndicatorStartPos() {
+        return mIndicatorTop;
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/MenuDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/MenuDrawer.java
new file mode 100755
index 0000000..21f29d6
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/MenuDrawer.java
@@ -0,0 +1,1157 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.*;
+import android.view.animation.Interpolator;
+
+public abstract class MenuDrawer extends ViewGroup {
+
+    /**
+     * Callback interface for changing state of the drawer.
+     */
+    public interface OnDrawerStateChangeListener {
+
+        /**
+         * Called when the drawer state changes.
+         *
+         * @param oldState The old drawer state.
+         * @param newState The new drawer state.
+         */
+        void onDrawerStateChange(int oldState, int newState);
+    }
+
+    /**
+     * Callback that is invoked when the drawer is in the process of deciding whether it should intercept the touch
+     * event. This lets the listener decide if the pointer is on a view that would disallow dragging of the drawer.
+     * This is only called when the touch mode is {@link #TOUCH_MODE_FULLSCREEN}.
+     */
+    public interface OnInterceptMoveEventListener {
+
+        /**
+         * Called for each child the pointer i on when the drawer is deciding whether to intercept the touch event.
+         *
+         * @param v  View to test for draggability
+         * @param dx Delta drag in pixels
+         * @param x  X coordinate of the active touch point
+         * @param y  Y coordinate of the active touch point
+         * @return true if view is draggable by delta dx.
+         */
+        boolean isViewDraggable(View v, int dx, int x, int y);
+    }
+
+    /**
+     * Tag used when logging.
+     */
+    private static final String TAG = "MenuDrawer";
+
+    /**
+     * Indicates whether debug code should be enabled.
+     */
+    private static final boolean DEBUG = false;
+
+    /**
+     * The time between each frame when animating the drawer.
+     */
+    protected static final int ANIMATION_DELAY = 1000 / 60;
+
+    /**
+     * The default touch bezel size of the drawer in dp.
+     */
+    private static final int DEFAULT_DRAG_BEZEL_DP = 24;
+
+    /**
+     * The default drop shadow size in dp.
+     */
+    private static final int DEFAULT_DROP_SHADOW_DP = 6;
+
+    /**
+     * Drag mode for sliding only the content view.
+     */
+    public static final int MENU_DRAG_CONTENT = 0;
+
+    /**
+     * Drag mode for sliding the entire window.
+     */
+    public static final int MENU_DRAG_WINDOW = 1;
+
+    /**
+     * Disallow opening the drawer by dragging the screen.
+     */
+    public static final int TOUCH_MODE_NONE = 0;
+
+    /**
+     * Allow opening drawer only by dragging on the edge of the screen.
+     */
+    public static final int TOUCH_MODE_BEZEL = 1;
+
+    /**
+     * Allow opening drawer by dragging anywhere on the screen.
+     */
+    public static final int TOUCH_MODE_FULLSCREEN = 2;
+
+    /**
+     * Indicates that the drawer is currently closed.
+     */
+    public static final int STATE_CLOSED = 0;
+
+    /**
+     * Indicates that the drawer is currently closing.
+     */
+    public static final int STATE_CLOSING = 1;
+
+    /**
+     * Indicates that the drawer is currently being dragged by the user.
+     */
+    public static final int STATE_DRAGGING = 2;
+
+    /**
+     * Indicates that the drawer is currently opening.
+     */
+    public static final int STATE_OPENING = 4;
+
+    /**
+     * Indicates that the drawer is currently open.
+     */
+    public static final int STATE_OPEN = 8;
+
+    /**
+     * Indicates whether to use {@link View#setTranslationX(float)} when positioning views.
+     */
+    static final boolean USE_TRANSLATIONS = Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1;
+
+    /**
+     * Time to animate the indicator to the new active view.
+     */
+    static final int INDICATOR_ANIM_DURATION = 800;
+
+    /**
+     * The maximum animation duration.
+     */
+    private static final int DEFAULT_ANIMATION_DURATION = 600;
+
+    /**
+     * Interpolator used when animating the drawer open/closed.
+     */
+    protected static final Interpolator SMOOTH_INTERPOLATOR = new SmoothInterpolator();
+
+    /**
+     * Drawable used as menu overlay.
+     */
+    protected Drawable mMenuOverlay;
+
+    /**
+     * Defines whether the drop shadow is enabled.
+     */
+    protected boolean mDropShadowEnabled;
+
+    /**
+     * Drawable used as content drop shadow onto the menu.
+     */
+    protected Drawable mDropShadowDrawable;
+
+    /**
+     * The size of the content drop shadow.
+     */
+    protected int mDropShadowSize;
+
+    /**
+     * Bitmap used to indicate the active view.
+     */
+    protected Bitmap mActiveIndicator;
+
+    /**
+     * The currently active view.
+     */
+    protected View mActiveView;
+
+    /**
+     * Position of the active view. This is compared to View#getTag(R.id.mdActiveViewPosition) when drawing the
+     * indicator.
+     */
+    protected int mActivePosition;
+
+    /**
+     * Whether the indicator should be animated between positions.
+     */
+    private boolean mAllowIndicatorAnimation;
+
+    /**
+     * Used when reading the position of the active view.
+     */
+    protected final Rect mActiveRect = new Rect();
+
+    /**
+     * Temporary {@link Rect} used for deciding whether the view should be invalidated so the indicator can be redrawn.
+     */
+    private final Rect mTempRect = new Rect();
+
+    /**
+     * The custom menu view set by the user.
+     */
+    private View mMenuView;
+
+    /**
+     * The parent of the menu view.
+     */
+    protected BuildLayerFrameLayout mMenuContainer;
+
+    /**
+     * The parent of the content view.
+     */
+    protected BuildLayerFrameLayout mContentContainer;
+
+    /**
+     * The size of the menu (width or height depending on the gravity).
+     */
+    protected int mMenuSize;
+
+    /**
+     * Indicates whether the menu size has been set explicity either via the theme or by calling
+     * {@link #setMenuSize(int)}.
+     */
+    protected boolean mMenuSizeSet;
+
+    /**
+     * Indicates whether the menu is currently visible.
+     */
+    protected boolean mMenuVisible;
+
+    /**
+     * The drag mode of the drawer. Can be either {@link #MENU_DRAG_CONTENT} or {@link #MENU_DRAG_WINDOW}.
+     */
+    private int mDragMode = MENU_DRAG_CONTENT;
+
+    /**
+     * The current drawer state.
+     *
+     * @see #STATE_CLOSED
+     * @see #STATE_CLOSING
+     * @see #STATE_DRAGGING
+     * @see #STATE_OPENING
+     * @see #STATE_OPEN
+     */
+    protected int mDrawerState = STATE_CLOSED;
+
+    /**
+     * The touch bezel size of the drawer in px.
+     */
+    protected int mTouchBezelSize;
+
+    /**
+     * The touch area size of the drawer in px.
+     */
+    protected int mTouchSize;
+
+    /**
+     * Listener used to dispatch state change events.
+     */
+    private OnDrawerStateChangeListener mOnDrawerStateChangeListener;
+
+    /**
+     * Touch mode for the Drawer.
+     * Possible values are {@link #TOUCH_MODE_NONE}, {@link #TOUCH_MODE_BEZEL} or {@link #TOUCH_MODE_FULLSCREEN}
+     * Default: {@link #TOUCH_MODE_BEZEL}
+     */
+    protected int mTouchMode = TOUCH_MODE_BEZEL;
+
+    /**
+     * Indicates whether to use {@link View#LAYER_TYPE_HARDWARE} when animating the drawer.
+     */
+    protected boolean mHardwareLayersEnabled = true;
+
+    /**
+     * The Activity the drawer is attached to.
+     */
+    private Activity mActivity;
+
+    /**
+     * Scroller used when animating the indicator to a new position.
+     */
+    private FloatScroller mIndicatorScroller;
+
+    /**
+     * Runnable used when animating the indicator to a new position.
+     */
+    private Runnable mIndicatorRunnable = new Runnable() {
+        @Override
+        public void run() {
+            animateIndicatorInvalidate();
+        }
+    };
+
+    /**
+     * The start position of the indicator when animating it to a new position.
+     */
+    protected int mIndicatorStartPos;
+
+    /**
+     * [0..1] value indicating the current progress of the animation.
+     */
+    protected float mIndicatorOffset;
+
+    /**
+     * Whether the indicator is currently animating.
+     */
+    protected boolean mIndicatorAnimating;
+
+    /**
+     * Bundle used to hold the drawers state.
+     */
+    protected Bundle mState;
+
+    /**
+     * The maximum duration of open/close animations.
+     */
+    protected int mMaxAnimationDuration = DEFAULT_ANIMATION_DURATION;
+
+    /**
+     * Callback that lets the listener override intercepting of touch events.
+     */
+    protected OnInterceptMoveEventListener mOnInterceptMoveEventListener;
+
+    protected Drawable mWindowEdge = null;
+
+    /**
+     * Attaches the MenuDrawer to the Activity.
+     *
+     * @param activity The activity that the MenuDrawer will be attached to.
+     * @return The created MenuDrawer instance.
+     */
+    public static MenuDrawer attach(Activity activity) {
+        return attach(activity, MENU_DRAG_CONTENT);
+    }
+
+    /**
+     * Attaches the MenuDrawer to the Activity.
+     *
+     * @param activity The activity the menu drawer will be attached to.
+     * @param dragMode The drag mode of the drawer. Can be either {@link MenuDrawer#MENU_DRAG_CONTENT}
+     *                 or {@link MenuDrawer#MENU_DRAG_WINDOW}.
+     * @return The created MenuDrawer instance.
+     */
+    public static MenuDrawer attach(Activity activity, int dragMode) {
+        return attach(activity, dragMode, Position.LEFT);
+    }
+
+    /**
+     * Attaches the MenuDrawer to the Activity.
+     *
+     * @param activity The activity the menu drawer will be attached to.
+     * @param position Where to position the menu.
+     * @return The created MenuDrawer instance.
+     */
+    public static MenuDrawer attach(Activity activity, Position position) {
+        return attach(activity, MENU_DRAG_CONTENT, position);
+    }
+
+    /**
+     * Attaches the MenuDrawer to the Activity.
+     *
+     * @param activity The activity the menu drawer will be attached to.
+     * @param dragMode The drag mode of the drawer. Can be either {@link MenuDrawer#MENU_DRAG_CONTENT}
+     *                 or {@link MenuDrawer#MENU_DRAG_WINDOW}.
+     * @param position Where to position the menu.
+     * @return The created MenuDrawer instance.
+     */
+    public static MenuDrawer attach(Activity activity, int dragMode, Position position) {
+        return attach(activity, dragMode, position, false);
+    }
+
+    /**
+     * Attaches the MenuDrawer to the Activity.
+     *
+     * @param activity     The activity the menu drawer will be attached to.
+     * @param dragMode     The drag mode of the drawer. Can be either {@link MenuDrawer#MENU_DRAG_CONTENT}
+     *                     or {@link MenuDrawer#MENU_DRAG_WINDOW}.
+     * @param position     Where to position the menu.
+     * @param attachStatic Whether a static (non-draggable, always visible) drawer should be used.
+     * @return The created MenuDrawer instance.
+     */
+    public static MenuDrawer attach(Activity activity, int dragMode, Position position, boolean attachStatic) {
+        MenuDrawer menuDrawer = createMenuDrawer(activity, dragMode, position, attachStatic);
+        menuDrawer.setId(R.id.md__drawer);
+
+        switch (dragMode) {
+            case MenuDrawer.MENU_DRAG_CONTENT:
+                attachToContent(activity, menuDrawer);
+                break;
+
+            case MenuDrawer.MENU_DRAG_WINDOW:
+                attachToDecor(activity, menuDrawer);
+                break;
+
+            default:
+                throw new RuntimeException("Unknown menu mode: " + dragMode);
+        }
+
+        return menuDrawer;
+    }
+
+    /**
+     * Constructs the appropriate MenuDrawer based on the position.
+     */
+    private static MenuDrawer createMenuDrawer(Activity activity, int dragMode, Position position,
+            boolean attachStatic) {
+        if (attachStatic) {
+            switch (position) {
+                case LEFT:
+                    return new LeftStaticDrawer(activity, dragMode);
+                case RIGHT:
+                    return new RightStaticDrawer(activity, dragMode);
+                case TOP:
+                    return new TopStaticDrawer(activity, dragMode);
+                case BOTTOM:
+                    return new BottomStaticDrawer(activity, dragMode);
+                default:
+                    throw new IllegalArgumentException("position must be one of LEFT, TOP, RIGHT or BOTTOM");
+            }
+        }
+
+        switch (position) {
+            case LEFT:
+                return new LeftDrawer(activity, dragMode);
+            case RIGHT:
+                return new RightDrawer(activity, dragMode);
+            case TOP:
+                return new TopDrawer(activity, dragMode);
+            case BOTTOM:
+                return new BottomDrawer(activity, dragMode);
+            default:
+                throw new IllegalArgumentException("position must be one of LEFT, TOP, RIGHT or BOTTOM");
+        }
+    }
+
+    /**
+     * Attaches the menu drawer to the content view.
+     */
+    private static void attachToContent(Activity activity, MenuDrawer menuDrawer) {
+        /**
+         * Do not call mActivity#setContentView.
+         * E.g. if using with a ListActivity, Activity#setContentView is overridden and dispatched to
+         * MenuDrawer#setContentView, which then again would call Activity#setContentView.
+         */
+        ViewGroup content = (ViewGroup) activity.findViewById(android.R.id.content);
+        content.removeAllViews();
+        content.addView(menuDrawer, LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+    }
+
+    /**
+     * Attaches the menu drawer to the window.
+     */
+    private static void attachToDecor(Activity activity, MenuDrawer menuDrawer) {
+        ViewGroup decorView = (ViewGroup) activity.getWindow().getDecorView();
+        ViewGroup decorChild = (ViewGroup) decorView.getChildAt(0);
+
+        decorView.removeAllViews();
+        decorView.addView(menuDrawer, LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+
+        menuDrawer.mContentContainer.addView(decorChild, decorChild.getLayoutParams());
+    }
+
+    MenuDrawer(Activity activity, int dragMode) {
+        this(activity);
+
+        mActivity = activity;
+        mDragMode = dragMode;
+    }
+
+    public MenuDrawer(Context context) {
+        this(context, null);
+    }
+
+    public MenuDrawer(Context context, AttributeSet attrs) {
+        this(context, attrs, R.attr.menuDrawerStyle);
+    }
+
+    public MenuDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        initDrawer(context, attrs, defStyle);
+    }
+
+    protected void initDrawer(Context context, AttributeSet attrs, int defStyle) {
+        setWillNotDraw(false);
+        setFocusable(false);
+
+        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.MenuDrawer, R.attr.menuDrawerStyle,
+                R.style.Widget_MenuDrawer);
+
+        final Drawable contentBackground = a.getDrawable(R.styleable.MenuDrawer_mdContentBackground);
+        final Drawable menuBackground = a.getDrawable(R.styleable.MenuDrawer_mdMenuBackground);
+
+        mMenuSize = a.getDimensionPixelSize(R.styleable.MenuDrawer_mdMenuSize, -1);
+        mMenuSizeSet = mMenuSize != -1;
+
+        final int indicatorResId = a.getResourceId(R.styleable.MenuDrawer_mdActiveIndicator, 0);
+        if (indicatorResId != 0) {
+            mActiveIndicator = BitmapFactory.decodeResource(getResources(), indicatorResId);
+        }
+
+        mDropShadowEnabled = a.getBoolean(R.styleable.MenuDrawer_mdDropShadowEnabled, true);
+
+        mDropShadowDrawable = a.getDrawable(R.styleable.MenuDrawer_mdDropShadow);
+
+        if (mDropShadowDrawable == null) {
+            final int dropShadowColor = a.getColor(R.styleable.MenuDrawer_mdDropShadowColor, 0xFF000000);
+            setDropShadowColor(dropShadowColor);
+        }
+
+        mDropShadowSize = a.getDimensionPixelSize(R.styleable.MenuDrawer_mdDropShadowSize,
+                dpToPx(DEFAULT_DROP_SHADOW_DP));
+
+        mTouchBezelSize = a.getDimensionPixelSize(R.styleable.MenuDrawer_mdTouchBezelSize,
+                dpToPx(DEFAULT_DRAG_BEZEL_DP));
+
+        mAllowIndicatorAnimation = a.getBoolean(R.styleable.MenuDrawer_mdAllowIndicatorAnimation, false);
+
+        mMaxAnimationDuration = a.getInt(R.styleable.MenuDrawer_mdMaxAnimationDuration, DEFAULT_ANIMATION_DURATION);
+
+        a.recycle();
+
+        mMenuContainer = new BuildLayerFrameLayout(context);
+        mMenuContainer.setId(R.id.md__menu);
+        mMenuContainer.setBackgroundDrawable(null); //TODO Make this modifiable in code
+        super.addView(mMenuContainer, -1, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+
+        mContentContainer = new NoClickThroughFrameLayout(context);
+        mContentContainer.setId(R.id.md__content);
+        mContentContainer.setBackgroundDrawable(contentBackground);
+        super.addView(mContentContainer, -1, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+
+        mMenuOverlay = new ColorDrawable(0xFF000000);
+
+        mIndicatorScroller = new FloatScroller(SMOOTH_INTERPOLATOR);
+    }
+
+    public void setMenuOverlayColor (int color) {
+        mMenuOverlay = new ColorDrawable(color);
+    }
+
+    public void setWindowEdge (Drawable windowEdge) {
+        mWindowEdge = windowEdge;
+    }
+
+    @Override
+    public void addView(View child, int index, LayoutParams params) {
+        int childCount = mMenuContainer.getChildCount();
+        if (childCount == 0) {
+            mMenuContainer.addView(child, index, params);
+            return;
+        }
+
+        childCount = mContentContainer.getChildCount();
+        if (childCount == 0) {
+            mContentContainer.addView(child, index, params);
+            return;
+        }
+
+        throw new IllegalStateException("MenuDrawer can only hold two child views");
+    }
+
+    protected int dpToPx(int dp) {
+        return (int) (getResources().getDisplayMetrics().density * dp + 0.5f);
+    }
+
+    protected boolean isViewDescendant(View v) {
+        ViewParent parent = v.getParent();
+        while (parent != null) {
+            if (parent == this) {
+                return true;
+            }
+
+            parent = parent.getParent();
+        }
+
+        return false;
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        getViewTreeObserver().addOnScrollChangedListener(mScrollListener);
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        getViewTreeObserver().removeOnScrollChangedListener(mScrollListener);
+        super.onDetachedFromWindow();
+    }
+
+    /**
+     * Toggles the menu open and close with animation.
+     */
+    public void toggleMenu() {
+        toggleMenu(true);
+    }
+
+    /**
+     * Toggles the menu open and close.
+     *
+     * @param animate Whether open/close should be animated.
+     */
+    public abstract void toggleMenu(boolean animate);
+
+    /**
+     * Animates the menu open.
+     */
+    public void openMenu() {
+        openMenu(true);
+    }
+
+    /**
+     * Opens the menu.
+     *
+     * @param animate Whether open/close should be animated.
+     */
+    public abstract void openMenu(boolean animate);
+
+    /**
+     * Animates the menu closed.
+     */
+    public void closeMenu() {
+        closeMenu(true);
+    }
+
+    /**
+     * Closes the menu.
+     *
+     * @param animate Whether open/close should be animated.
+     */
+    public abstract void closeMenu(boolean animate);
+
+    /**
+     * Indicates whether the menu is currently visible.
+     *
+     * @return True if the menu is open, false otherwise.
+     */
+    public abstract boolean isMenuVisible();
+
+    /**
+     * Set the size of the menu drawer when open.
+     *
+     * @param size The size of the menu.
+     */
+    public abstract void setMenuSize(int size);
+
+    /**
+     * Returns the size of the menu.
+     *
+     * @return The size of the menu.
+     */
+    public int getMenuSize() {
+        return mMenuSize;
+    }
+
+    /**
+     * Set the active view.
+     * If the mdActiveIndicator attribute is set, this View will have the indicator drawn next to it.
+     *
+     * @param v The active view.
+     */
+    public void setActiveView(View v) {
+        setActiveView(v, 0);
+    }
+
+    /**
+     * Set the active view.
+     * If the mdActiveIndicator attribute is set, this View will have the indicator drawn next to it.
+     *
+     * @param v        The active view.
+     * @param position Optional position, usually used with ListView. v.setTag(R.id.mdActiveViewPosition, position)
+     *                 must be called first.
+     */
+    public void setActiveView(View v, int position) {
+        final View oldView = mActiveView;
+        mActiveView = v;
+        mActivePosition = position;
+
+        if (mAllowIndicatorAnimation && oldView != null) {
+            startAnimatingIndicator();
+        }
+
+        invalidate();
+    }
+
+    /**
+     * Sets whether the indicator should be animated between active views.
+     *
+     * @param animate Whether the indicator should be animated between active views.
+     */
+    public void setAllowIndicatorAnimation(boolean animate) {
+        if (animate != mAllowIndicatorAnimation) {
+            mAllowIndicatorAnimation = animate;
+            completeAnimatingIndicator();
+        }
+    }
+
+    /**
+     * Indicates whether the indicator should be animated between active views.
+     *
+     * @return Whether the indicator should be animated between active views.
+     */
+    public boolean getAllowIndicatorAnimation() {
+        return mAllowIndicatorAnimation;
+    }
+
+    /**
+     * Scroll listener that checks whether the active view has moved before the drawer is invalidated.
+     */
+    private ViewTreeObserver.OnScrollChangedListener mScrollListener = new ViewTreeObserver.OnScrollChangedListener() {
+        @Override
+        public void onScrollChanged() {
+            if (mActiveView != null && isViewDescendant(mActiveView)) {
+                mActiveView.getDrawingRect(mTempRect);
+                offsetDescendantRectToMyCoords(mActiveView, mTempRect);
+                if (mTempRect.left != mActiveRect.left || mTempRect.top != mActiveRect.top
+                        || mTempRect.right != mActiveRect.right || mTempRect.bottom != mActiveRect.bottom) {
+                    invalidate();
+                }
+            }
+        }
+    };
+
+    /**
+     * Starts animating the indicator to a new position.
+     */
+    private void startAnimatingIndicator() {
+        mIndicatorStartPos = getIndicatorStartPos();
+        mIndicatorAnimating = true;
+        mIndicatorScroller.startScroll(0.0f, 1.0f, INDICATOR_ANIM_DURATION);
+
+        animateIndicatorInvalidate();
+    }
+
+    /**
+     * Returns the start position of the indicator.
+     *
+     * @return The start position of the indicator.
+     */
+    protected abstract int getIndicatorStartPos();
+
+    /**
+     * Callback when each frame in the indicator animation should be drawn.
+     */
+    private void animateIndicatorInvalidate() {
+        if (mIndicatorScroller.computeScrollOffset()) {
+            mIndicatorOffset = mIndicatorScroller.getCurr();
+            invalidate();
+
+            if (!mIndicatorScroller.isFinished()) {
+                postOnAnimation(mIndicatorRunnable);
+                return;
+            }
+        }
+
+        completeAnimatingIndicator();
+    }
+
+    /**
+     * Called when the indicator animation has completed.
+     */
+    private void completeAnimatingIndicator() {
+        mIndicatorOffset = 1.0f;
+        mIndicatorAnimating = false;
+        invalidate();
+    }
+
+    /**
+     * Enables or disables offsetting the menu when dragging the drawer.
+     *
+     * @param offsetMenu True to offset the menu, false otherwise.
+     */
+    public abstract void setOffsetMenuEnabled(boolean offsetMenu);
+
+    /**
+     * Indicates whether the menu is being offset when dragging the drawer.
+     *
+     * @return True if the menu is being offset, false otherwise.
+     */
+    public abstract boolean getOffsetMenuEnabled();
+
+    public int getDrawerState() {
+        return mDrawerState;
+    }
+
+    /**
+     * Register a callback to be invoked when the drawer state changes.
+     *
+     * @param listener The callback that will run.
+     */
+    public void setOnDrawerStateChangeListener(OnDrawerStateChangeListener listener) {
+        mOnDrawerStateChangeListener = listener;
+    }
+
+    /**
+     * Register a callback that will be invoked when the drawer is about to intercept touch events.
+     *
+     * @param listener The callback that will be invoked.
+     */
+    public void setOnInterceptMoveEventListener(OnInterceptMoveEventListener listener) {
+        mOnInterceptMoveEventListener = listener;
+    }
+
+    /**
+     * Defines whether the drop shadow is enabled.
+     *
+     * @param enabled Whether the drop shadow is enabled.
+     */
+    public void setDropShadowEnabled(boolean enabled) {
+        mDropShadowEnabled = enabled;
+        invalidate();
+    }
+
+    /**
+     * Sets the color of the drop shadow.
+     *
+     * @param color The color of the drop shadow.
+     */
+    public abstract void setDropShadowColor(int color);
+
+    /**
+     * Sets the drawable of the drop shadow.
+     *
+     * @param drawable The drawable of the drop shadow.
+     */
+    public void setDropShadow(Drawable drawable) {
+        mDropShadowDrawable = drawable;
+        invalidate();
+    }
+
+    /**
+     * Sets the drawable of the drop shadow.
+     *
+     * @param resId The resource identifier of the the drawable.
+     */
+    public void setDropShadow(int resId) {
+        setDropShadow(getResources().getDrawable(resId));
+    }
+
+    /**
+     * Returns the drawable of the drop shadow.
+     */
+    public Drawable getDropShadow() {
+        return mDropShadowDrawable;
+    }
+
+    /**
+     * Sets the size of the drop shadow.
+     *
+     * @param size The size of the drop shadow in px.
+     */
+    public void setDropShadowSize(int size) {
+        mDropShadowSize = size;
+        invalidate();
+    }
+
+    /**
+     * Animates the drawer slightly open until the user opens the drawer.
+     */
+    public abstract void peekDrawer();
+
+    /**
+     * Animates the drawer slightly open. If delay is larger than 0, this happens until the user opens the drawer.
+     *
+     * @param delay The delay (in milliseconds) between each run of the animation. If 0, this animation is only run
+     *              once.
+     */
+    public abstract void peekDrawer(long delay);
+
+    /**
+     * Animates the drawer slightly open. If delay is larger than 0, this happens until the user opens the drawer.
+     *
+     * @param startDelay The delay (in milliseconds) until the animation is first run.
+     * @param delay      The delay (in milliseconds) between each run of the animation. If 0, this animation is only run
+     *                   once.
+     */
+    public abstract void peekDrawer(long startDelay, long delay);
+
+    /**
+     * Enables or disables the user of {@link View#LAYER_TYPE_HARDWARE} when animations views.
+     *
+     * @param enabled Whether hardware layers are enabled.
+     */
+    public abstract void setHardwareLayerEnabled(boolean enabled);
+
+    /**
+     * Sets the maximum duration of open/close animations.
+     * @param duration The maximum duration in milliseconds.
+     */
+    public void setMaxAnimationDuration(int duration) {
+        mMaxAnimationDuration = duration;
+    }
+
+    /**
+     * Returns the ViewGroup used as a parent for the menu view.
+     *
+     * @return The menu view's parent.
+     */
+    public ViewGroup getMenuContainer() {
+        return mMenuContainer;
+    }
+
+    /**
+     * Returns the ViewGroup used as a parent for the content view.
+     *
+     * @return The content view's parent.
+     */
+    public ViewGroup getContentContainer() {
+        if (mDragMode == MENU_DRAG_CONTENT) {
+            return mContentContainer;
+        } else {
+            return (ViewGroup) findViewById(android.R.id.content);
+        }
+    }
+
+    /**
+     * Set the menu view from a layout resource.
+     *
+     * @param layoutResId Resource ID to be inflated.
+     */
+    public void setMenuView(int layoutResId) {
+        mMenuContainer.removeAllViews();
+        mMenuView = LayoutInflater.from(getContext()).inflate(layoutResId, mMenuContainer, false);
+        mMenuContainer.addView(mMenuView);
+    }
+
+    /**
+     * Set the menu view to an explicit view.
+     *
+     * @param view The menu view.
+     */
+    public void setMenuView(View view) {
+        setMenuView(view, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+    }
+
+    /**
+     * Set the menu view to an explicit view.
+     *
+     * @param view   The menu view.
+     * @param params Layout parameters for the view.
+     */
+    public void setMenuView(View view, LayoutParams params) {
+        mMenuView = view;
+        mMenuContainer.removeAllViews();
+        mMenuContainer.addView(view, params);
+    }
+
+    /**
+     * Returns the menu view.
+     *
+     * @return The menu view.
+     */
+    public View getMenuView() {
+        return mMenuView;
+    }
+
+    /**
+     * Set the content from a layout resource.
+     *
+     * @param layoutResId Resource ID to be inflated.
+     */
+    public void setContentView(int layoutResId) {
+        switch (mDragMode) {
+            case MenuDrawer.MENU_DRAG_CONTENT:
+                mContentContainer.removeAllViews();
+                LayoutInflater.from(getContext()).inflate(layoutResId, mContentContainer, true);
+                break;
+
+            case MenuDrawer.MENU_DRAG_WINDOW:
+                mActivity.setContentView(layoutResId);
+                break;
+        }
+    }
+
+    /**
+     * Set the content to an explicit view.
+     *
+     * @param view The desired content to display.
+     */
+    public void setContentView(View view) {
+        setContentView(view, new ViewGroup.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+    }
+
+    /**
+     * Set the content to an explicit view.
+     *
+     * @param view   The desired content to display.
+     * @param params Layout parameters for the view.
+     */
+    public void setContentView(View view, LayoutParams params) {
+        switch (mDragMode) {
+            case MenuDrawer.MENU_DRAG_CONTENT:
+                mContentContainer.removeAllViews();
+                mContentContainer.addView(view, params);
+                break;
+
+            case MenuDrawer.MENU_DRAG_WINDOW:
+                mActivity.setContentView(view, params);
+                break;
+        }
+    }
+
+    protected void setDrawerState(int state) {
+        if (state != mDrawerState) {
+            final int oldState = mDrawerState;
+            mDrawerState = state;
+            if (mOnDrawerStateChangeListener != null) mOnDrawerStateChangeListener.onDrawerStateChange(oldState, state);
+            if (DEBUG) logDrawerState(state);
+        }
+    }
+
+    protected void logDrawerState(int state) {
+        switch (state) {
+            case STATE_CLOSED:
+                Log.d(TAG, "[DrawerState] STATE_CLOSED");
+                break;
+
+            case STATE_CLOSING:
+                Log.d(TAG, "[DrawerState] STATE_CLOSING");
+                break;
+
+            case STATE_DRAGGING:
+                Log.d(TAG, "[DrawerState] STATE_DRAGGING");
+                break;
+
+            case STATE_OPENING:
+                Log.d(TAG, "[DrawerState] STATE_OPENING");
+                break;
+
+            case STATE_OPEN:
+                Log.d(TAG, "[DrawerState] STATE_OPEN");
+                break;
+
+            default:
+                Log.d(TAG, "[DrawerState] Unknown: " + state);
+        }
+    }
+
+    /**
+     * Returns the touch mode.
+     */
+    public abstract int getTouchMode();
+
+    /**
+     * Sets the drawer touch mode. Possible values are {@link #TOUCH_MODE_NONE}, {@link #TOUCH_MODE_BEZEL} or
+     * {@link #TOUCH_MODE_FULLSCREEN}.
+     *
+     * @param mode The touch mode.
+     */
+    public abstract void setTouchMode(int mode);
+
+    /**
+     * Sets the size of the touch bezel.
+     *
+     * @param size The touch bezel size in px.
+     */
+    public abstract void setTouchBezelSize(int size);
+
+    /**
+     * Returns the size of the touch bezel in px.
+     */
+    public abstract int getTouchBezelSize();
+
+    @Override
+    public void postOnAnimation(Runnable action) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+            super.postOnAnimation(action);
+        } else {
+            postDelayed(action, ANIMATION_DELAY);
+        }
+    }
+
+    @Override
+    protected boolean fitSystemWindows(Rect insets) {
+        if (mDragMode == MENU_DRAG_WINDOW) {
+            mMenuContainer.setPadding(0, insets.top, 0, 0);
+        }
+        return super.fitSystemWindows(insets);
+    }
+
+    /**
+     * Saves the state of the drawer.
+     *
+     * @return Returns a Parcelable containing the drawer state.
+     */
+    public final Parcelable saveState() {
+        if (mState == null) mState = new Bundle();
+        saveState(mState);
+        return mState;
+    }
+
+    void saveState(Bundle state) {
+        // State saving isn't required for subclasses.
+    }
+
+    /**
+     * Restores the state of the drawer.
+     *
+     * @param in A parcelable containing the drawer state.
+     */
+    public void restoreState(Parcelable in) {
+        mState = (Bundle) in;
+    }
+
+    @Override
+    protected Parcelable onSaveInstanceState() {
+        Parcelable superState = super.onSaveInstanceState();
+        SavedState state = new SavedState(superState);
+
+        if (mState == null) mState = new Bundle();
+        saveState(mState);
+
+        state.mState = mState;
+        return state;
+    }
+
+    @Override
+    protected void onRestoreInstanceState(Parcelable state) {
+        SavedState savedState = (SavedState) state;
+        super.onRestoreInstanceState(savedState.getSuperState());
+
+        restoreState(savedState.mState);
+    }
+
+    static class SavedState extends BaseSavedState {
+
+        Bundle mState;
+
+        public SavedState(Parcelable superState) {
+            super(superState);
+        }
+
+        public SavedState(Parcel in) {
+            super(in);
+            mState = in.readBundle();
+        }
+
+        @Override
+        public void writeToParcel(Parcel dest, int flags) {
+            super.writeToParcel(dest, flags);
+            dest.writeBundle(mState);
+        }
+
+        @SuppressWarnings("UnusedDeclaration")
+        public static final Creator<SavedState> CREATOR = new Creator<SavedState>() {
+            @Override
+            public SavedState createFromParcel(Parcel in) {
+                return new SavedState(in);
+            }
+
+            @Override
+            public SavedState[] newArray(int size) {
+                return new SavedState[size];
+            }
+        };
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/NoClickThroughFrameLayout.java b/MenuDrawer/src/net/simonvt/menudrawer/NoClickThroughFrameLayout.java
new file mode 100755
index 0000000..9462282
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/NoClickThroughFrameLayout.java
@@ -0,0 +1,28 @@
+package net.simonvt.menudrawer;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+
+/**
+ * FrameLayout which doesn't let touch events propagate to views positioned behind it in the view hierarchy.
+ */
+public class NoClickThroughFrameLayout extends BuildLayerFrameLayout {
+
+    public NoClickThroughFrameLayout(Context context) {
+        super(context);
+    }
+
+    public NoClickThroughFrameLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public NoClickThroughFrameLayout(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        return true;
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/PeekInterpolator.java b/MenuDrawer/src/net/simonvt/menudrawer/PeekInterpolator.java
new file mode 100755
index 0000000..d0c7600
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/PeekInterpolator.java
@@ -0,0 +1,28 @@
+package net.simonvt.menudrawer;
+
+import android.view.animation.Interpolator;
+
+public class PeekInterpolator implements Interpolator {
+
+    private static final String TAG = "PeekInterpolator";
+
+    private static final SinusoidalInterpolator SINUSOIDAL_INTERPOLATOR = new SinusoidalInterpolator();
+
+    @Override
+    public float getInterpolation(float input) {
+        float result;
+
+        if (input < 1.f / 3.f) {
+            result = SINUSOIDAL_INTERPOLATOR.getInterpolation(input * 3);
+
+        } else if (input > 2.f / 3.f) {
+            final float val = ((input + 1.f / 3.f) - 1.f) * 3.f;
+            result = 1.f - SINUSOIDAL_INTERPOLATOR.getInterpolation(val);
+
+        } else {
+            result = 1.f;
+        }
+
+        return result;
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/Position.java b/MenuDrawer/src/net/simonvt/menudrawer/Position.java
new file mode 100755
index 0000000..e1a3dd3
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/Position.java
@@ -0,0 +1,18 @@
+package net.simonvt.menudrawer;
+
+/**
+ * Enums used for positioning the drawer.
+ */
+public enum Position {
+    // Positions the drawer to the left of the content.
+    LEFT,
+
+    // Positions the drawer above the content.
+    TOP,
+
+    // Positions the drawer to the right of the content.
+    RIGHT,
+
+    // Positions the drawer below the content.
+    BOTTOM,
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/RightDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/RightDrawer.java
new file mode 100755
index 0000000..54e1cb5
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/RightDrawer.java
@@ -0,0 +1,250 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.GradientDrawable;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+
+public class RightDrawer extends HorizontalDrawer {
+
+    private int mIndicatorTop;
+
+    RightDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public RightDrawer(Context context) {
+        super(context);
+    }
+
+    public RightDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public RightDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    public void openMenu(boolean animate) {
+        animateOffsetTo(-mMenuSize, 0, animate);
+    }
+
+    @Override
+    public void closeMenu(boolean animate) {
+        animateOffsetTo(0, 0, animate);
+    }
+
+    @Override
+    public void setDropShadowColor(int color) {
+        final int endColor = color & 0x00FFFFFF;
+        mDropShadowDrawable = new GradientDrawable(GradientDrawable.Orientation.LEFT_RIGHT, new int[] {
+                color,
+                endColor,
+        });
+        invalidate();
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        final int width = r - l;
+        final int height = b - t;
+        final int offsetPixels = (int) mOffsetPixels;
+
+        mMenuContainer.layout(width - mMenuSize, 0, width, height);
+        offsetMenu(offsetPixels);
+
+        if (USE_TRANSLATIONS) {
+            mContentContainer.layout(0, 0, width, height);
+        } else {
+            mContentContainer.layout(offsetPixels, 0, width + offsetPixels, height);
+        }
+    }
+
+    /**
+     * Offsets the menu relative to its original position based on the position of the content.
+     *
+     * @param offsetPixels The number of pixels the content if offset.
+     */
+    private void offsetMenu(int offsetPixels) {
+        if (mOffsetMenu && mMenuSize != 0) {
+            final int menuWidth = mMenuSize;
+            final float openRatio = (menuWidth + (float) offsetPixels) / menuWidth;
+
+            if (USE_TRANSLATIONS) {
+                if (offsetPixels != 0) {
+                    final int offset = (int) (/* 0.25f * */ (openRatio * menuWidth)); //TODO Bookmark
+//                    mMenuContainer.setTranslationX(offset);
+                    mMenuContainer.setTranslationX(0);
+                } else {
+//                    mMenuContainer.setTranslationX(-menuWidth);
+                    mMenuContainer.setTranslationX(0);
+                }
+                mMenuContainer.setVisibility(offsetPixels == 0 ? INVISIBLE : VISIBLE);
+            } else {
+                final int width = getWidth();
+                final int oldMenuRight = mMenuContainer.getRight();
+                final int newRight = width + (int) (0.25f * (openRatio * menuWidth));
+                final int offset = newRight - oldMenuRight;
+                mMenuContainer.offsetLeftAndRight(offset);
+                mMenuContainer.setVisibility(offsetPixels == 0 ? INVISIBLE : VISIBLE);
+            }
+        }
+    }
+
+    @Override
+    protected void drawDropShadow(Canvas canvas, int offsetPixels) {
+        final int height = getHeight();
+        final int width = getWidth();
+        final int left = width + offsetPixels;
+        final int right = left + mDropShadowSize;
+
+        mDropShadowDrawable.setBounds(left, 0, right, height);
+        mDropShadowDrawable.draw(canvas);
+    }
+
+    @Override
+    protected void drawMenuOverlay(Canvas canvas, int offsetPixels) {
+        final int height = getHeight();
+        final int width = getWidth();
+        final int left = 0;
+        final int right = width + offsetPixels;
+        final float openRatio = ((float) Math.abs(offsetPixels)) / mMenuSize;
+
+        mMenuOverlay.setBounds(left, 0, right, height);
+        mMenuOverlay.setAlpha((int) (MAX_MENU_OVERLAY_ALPHA * (openRatio)));
+        mMenuOverlay.draw(canvas);
+    }
+
+    @Override
+    protected void drawWindowEdge (Canvas canvas, int offsetPixels) {
+        final int width = getWidth();
+        final int height = getHeight();
+        final int edgeWidth = mWindowEdge.getIntrinsicWidth();
+        final int left = width + offsetPixels - edgeWidth;
+        final int right = width + offsetPixels;
+        final float openRatio = ((float) Math.abs(offsetPixels)) / mMenuSize;
+
+        mWindowEdge.setBounds(left, 0, right, height);
+        mWindowEdge.setAlpha((int) (MAX_MENU_OVERLAY_ALPHA * (openRatio)));
+        mWindowEdge.draw(canvas);
+    }
+
+    @Override
+    protected void drawIndicator(Canvas canvas, int offsetPixels) {
+        if (mActiveView != null && isViewDescendant(mActiveView)) {
+            Integer position = (Integer) mActiveView.getTag(R.id.mdActiveViewPosition);
+            final int pos = position == null ? 0 : position;
+
+            if (pos == mActivePosition) {
+                final int width = getWidth();
+                final int menuWidth = mMenuSize;
+                final int indicatorWidth = mActiveIndicator.getWidth();
+
+                final int contentRight = width + offsetPixels;
+                final float openRatio = ((float) Math.abs(offsetPixels)) / menuWidth;
+
+                mActiveView.getDrawingRect(mActiveRect);
+                offsetDescendantRectToMyCoords(mActiveView, mActiveRect);
+
+                final float interpolatedRatio = 1.f - INDICATOR_INTERPOLATOR.getInterpolation((1.f - openRatio));
+                final int interpolatedWidth = (int) (indicatorWidth * interpolatedRatio);
+
+                final int indicatorRight = contentRight + interpolatedWidth;
+                final int indicatorLeft = indicatorRight - indicatorWidth;
+
+                if (mIndicatorAnimating) {
+                    final int indicatorFinalTop = mActiveRect.top + ((mActiveRect.height()
+                            - mActiveIndicator.getHeight()) / 2);
+                    final int indicatorStartTop = mIndicatorStartPos;
+                    final int diff = indicatorFinalTop - indicatorStartTop;
+                    final int startOffset = (int) (diff * mIndicatorOffset);
+                    mIndicatorTop = indicatorStartTop + startOffset;
+                } else {
+                    mIndicatorTop = mActiveRect.top + ((mActiveRect.height() - mActiveIndicator.getHeight()) / 2);
+                }
+
+                canvas.save();
+                canvas.clipRect(contentRight, 0, indicatorRight, getHeight());
+                canvas.drawBitmap(mActiveIndicator, indicatorLeft, mIndicatorTop, null);
+                canvas.restore();
+            }
+        }
+    }
+
+    @Override
+    protected int getIndicatorStartPos() {
+        return mIndicatorTop;
+    }
+
+    @Override
+    protected void initPeekScroller() {
+        final int dx = -mMenuSize / 3;
+        mPeekScroller.startScroll(0, 0, dx, 0, PEEK_DURATION);
+    }
+
+    @Override
+    protected void onOffsetPixelsChanged(int offsetPixels) {
+        if (USE_TRANSLATIONS) {
+            mContentContainer.setTranslationX(offsetPixels);
+            offsetMenu(offsetPixels);
+            invalidate();
+        } else {
+            mContentContainer.offsetLeftAndRight(offsetPixels - mContentContainer.getLeft());
+            offsetMenu(offsetPixels);
+            invalidate();
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////
+    // Touch handling
+    //////////////////////////////////////////////////////////////////////
+
+    @Override
+    protected boolean isContentTouch(MotionEvent ev) {
+        return ev.getX() < getWidth() + mOffsetPixels;
+    }
+
+    @Override
+    protected boolean onDownAllowDrag(MotionEvent ev) {
+        final int width = getWidth();
+        final int initialMotionX = (int) mInitialMotionX;
+
+        return (!mMenuVisible && initialMotionX >= width - mTouchSize)
+                || (mMenuVisible && initialMotionX <= width + mOffsetPixels);
+    }
+
+    @Override
+    protected boolean onMoveAllowDrag(MotionEvent ev, float diff) {
+        final int width = getWidth();
+        final int initialMotionX = (int) mInitialMotionX;
+
+        return (!mMenuVisible && initialMotionX >= width - mTouchSize && (diff < 0))
+                || (mMenuVisible && initialMotionX <= width + mOffsetPixels);
+    }
+
+    @Override
+    protected void onMoveEvent(float dx) {
+        final float newOffset = Math.max(Math.min(mOffsetPixels + dx, 0), -mMenuSize);
+        setOffsetPixels(newOffset);
+    }
+
+    @Override
+    protected void onUpEvent(MotionEvent ev, boolean isDownOnOutside) {
+        final int offsetPixels = (int) mOffsetPixels;
+        final int width = getWidth();
+
+        if (mIsDragging) {
+            mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+            final int initialVelocity = (int) mVelocityTracker.getXVelocity();
+            mLastMotionX = ev.getX();
+            animateOffsetTo(mVelocityTracker.getXVelocity() > 0 ? 0 : -mMenuSize, initialVelocity, true);
+
+            // Close the menu when content is clicked while the menu is visible.
+        } else if (mMenuVisible && ev.getX() < width + offsetPixels && isDownOnOutside) {
+            closeMenu();
+        }
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/RightStaticDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/RightStaticDrawer.java
new file mode 100755
index 0000000..2027b43
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/RightStaticDrawer.java
@@ -0,0 +1,87 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.GradientDrawable;
+import android.util.AttributeSet;
+
+public class RightStaticDrawer extends StaticDrawer {
+
+    private int mIndicatorTop;
+
+    RightStaticDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public RightStaticDrawer(Context context) {
+        super(context);
+    }
+
+    public RightStaticDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public RightStaticDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void initDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super.initDrawer(context, attrs, defStyle);
+        mPosition = Position.RIGHT;
+    }
+
+    @Override
+    public void setDropShadowColor(int color) {
+        final int endColor = color & 0x00FFFFFF;
+        mDropShadowDrawable = new GradientDrawable(GradientDrawable.Orientation.LEFT_RIGHT, new int[] {
+                color,
+                endColor,
+        });
+        invalidate();
+    }
+
+    @Override
+    protected void drawIndicator(Canvas canvas) {
+        if (mActiveView != null && isViewDescendant(mActiveView)) {
+            Integer position = (Integer) mActiveView.getTag(R.id.mdActiveViewPosition);
+            final int pos = position == null ? 0 : position;
+
+            if (pos == mActivePosition) {
+                final int width = getWidth();
+                final int menuWidth = mMenuSize;
+                final int indicatorWidth = mActiveIndicator.getWidth();
+
+                final int contentRight = width - menuWidth;
+
+                mActiveView.getDrawingRect(mActiveRect);
+                offsetDescendantRectToMyCoords(mActiveView, mActiveRect);
+
+                final int indicatorRight = contentRight + indicatorWidth;
+                final int indicatorLeft = contentRight;
+
+                if (mIndicatorAnimating) {
+                    final int indicatorFinalTop = mActiveRect.top + ((mActiveRect.height()
+                            - mActiveIndicator.getHeight()) / 2);
+                    final int indicatorStartTop = mIndicatorStartPos;
+                    final int diff = indicatorFinalTop - indicatorStartTop;
+                    final int startOffset = (int) (diff * mIndicatorOffset);
+                    mIndicatorTop = indicatorStartTop + startOffset;
+                } else {
+                    mIndicatorTop = mActiveRect.top + ((mActiveRect.height() - mActiveIndicator.getHeight()) / 2);
+                }
+
+                canvas.save();
+                canvas.clipRect(contentRight, 0, indicatorRight, getHeight());
+                canvas.drawBitmap(mActiveIndicator, indicatorLeft, mIndicatorTop, null);
+                canvas.restore();
+            }
+        }
+    }
+
+    @Override
+    protected int getIndicatorStartPos() {
+        return mIndicatorTop;
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/Scroller.java b/MenuDrawer/src/net/simonvt/menudrawer/Scroller.java
new file mode 100755
index 0000000..58f0fc5
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/Scroller.java
@@ -0,0 +1,505 @@
+/*
+ * Copyright (C) 2006 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 net.simonvt.menudrawer;
+
+import android.content.Context;
+import android.hardware.SensorManager;
+import android.os.Build;
+import android.util.FloatMath;
+import android.view.ViewConfiguration;
+import android.view.animation.AnimationUtils;
+import android.view.animation.Interpolator;
+
+
+/**
+ * This class encapsulates scrolling.  The duration of the scroll
+ * can be passed in the constructor and specifies the maximum time that
+ * the scrolling animation should take.  Past this time, the scrolling is
+ * automatically moved to its final stage and computeScrollOffset()
+ * will always return false to indicate that scrolling is over.
+ */
+public class Scroller  {
+    private int mMode;
+
+    private int mStartX;
+    private int mStartY;
+    private int mFinalX;
+    private int mFinalY;
+
+    private int mMinX;
+    private int mMaxX;
+    private int mMinY;
+    private int mMaxY;
+
+    private int mCurrX;
+    private int mCurrY;
+    private long mStartTime;
+    private int mDuration;
+    private float mDurationReciprocal;
+    private float mDeltaX;
+    private float mDeltaY;
+    private boolean mFinished;
+    private Interpolator mInterpolator;
+    private boolean mFlywheel;
+
+    private float mVelocity;
+
+    private static final int DEFAULT_DURATION = 250;
+    private static final int SCROLL_MODE = 0;
+    private static final int FLING_MODE = 1;
+
+    private static final float DECELERATION_RATE = (float) (Math.log(0.75) / Math.log(0.9));
+    private static final float ALPHA = 800; // pixels / seconds
+    private static final float START_TENSION = 0.4f; // Tension at start: (0.4 * total T, 1.0 * Distance)
+    private static final float END_TENSION = 1.0f - START_TENSION;
+    private static final int NB_SAMPLES = 100;
+    private static final float[] SPLINE = new float[NB_SAMPLES + 1];
+
+    private float mDeceleration;
+    private final float mPpi;
+
+    static {
+        float xMin = 0.0f;
+        for (int i = 0; i <= NB_SAMPLES; i++) {
+            final float t = (float) i / NB_SAMPLES;
+            float xMax = 1.0f;
+            float x, tx, coef;
+            while (true) {
+                x = xMin + (xMax - xMin) / 2.0f;
+                coef = 3.0f * x * (1.0f - x);
+                tx = coef * ((1.0f - x) * START_TENSION + x * END_TENSION) + x * x * x;
+                if (Math.abs(tx - t) < 1E-5) break;
+                if (tx > t) xMax = x;
+                else xMin = x;
+            }
+            final float d = coef + x * x * x;
+            SPLINE[i] = d;
+        }
+        SPLINE[NB_SAMPLES] = 1.0f;
+
+        // This controls the viscous fluid effect (how much of it)
+        sViscousFluidScale = 8.0f;
+        // must be set to 1.0 (used in viscousFluid())
+        sViscousFluidNormalize = 1.0f;
+        sViscousFluidNormalize = 1.0f / viscousFluid(1.0f);
+    }
+
+    private static float sViscousFluidScale;
+    private static float sViscousFluidNormalize;
+
+    /**
+     * Create a Scroller with the default duration and interpolator.
+     */
+    public Scroller(Context context) {
+        this(context, null);
+    }
+
+    /**
+     * Create a Scroller with the specified interpolator. If the interpolator is
+     * null, the default (viscous) interpolator will be used. "Flywheel" behavior will
+     * be in effect for apps targeting Honeycomb or newer.
+     */
+    public Scroller(Context context, Interpolator interpolator) {
+        this(context, interpolator,
+                context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.HONEYCOMB);
+    }
+
+    /**
+     * Create a Scroller with the specified interpolator. If the interpolator is
+     * null, the default (viscous) interpolator will be used. Specify whether or
+     * not to support progressive "flywheel" behavior in flinging.
+     */
+    public Scroller(Context context, Interpolator interpolator, boolean flywheel) {
+        mFinished = true;
+        mInterpolator = interpolator;
+        mPpi = context.getResources().getDisplayMetrics().density * 160.0f;
+        mDeceleration = computeDeceleration(ViewConfiguration.getScrollFriction());
+        mFlywheel = flywheel;
+    }
+
+    /**
+     * The amount of friction applied to flings. The default value
+     * is {@link android.view.ViewConfiguration#getScrollFriction}.
+     *
+     * @param friction A scalar dimension-less value representing the coefficient of
+     *         friction.
+     */
+    public final void setFriction(float friction) {
+        mDeceleration = computeDeceleration(friction);
+    }
+
+    private float computeDeceleration(float friction) {
+        return SensorManager.GRAVITY_EARTH   // g (m/s^2)
+                      * 39.37f               // inch/meter
+                      * mPpi                 // pixels per inch
+                      * friction;
+    }
+
+    /**
+     *
+     * Returns whether the scroller has finished scrolling.
+     *
+     * @return True if the scroller has finished scrolling, false otherwise.
+     */
+    public final boolean isFinished() {
+        return mFinished;
+    }
+
+    /**
+     * Force the finished field to a particular value.
+     *
+     * @param finished The new finished value.
+     */
+    public final void forceFinished(boolean finished) {
+        mFinished = finished;
+    }
+
+    /**
+     * Returns how long the scroll event will take, in milliseconds.
+     *
+     * @return The duration of the scroll in milliseconds.
+     */
+    public final int getDuration() {
+        return mDuration;
+    }
+
+    /**
+     * Returns the current X offset in the scroll.
+     *
+     * @return The new X offset as an absolute distance from the origin.
+     */
+    public final int getCurrX() {
+        return mCurrX;
+    }
+
+    /**
+     * Returns the current Y offset in the scroll.
+     *
+     * @return The new Y offset as an absolute distance from the origin.
+     */
+    public final int getCurrY() {
+        return mCurrY;
+    }
+
+    /**
+     * Returns the current velocity.
+     *
+     * @return The original velocity less the deceleration. Result may be
+     * negative.
+     */
+    public float getCurrVelocity() {
+        return mVelocity - mDeceleration * timePassed() / 2000.0f;
+    }
+
+    /**
+     * Returns the start X offset in the scroll.
+     *
+     * @return The start X offset as an absolute distance from the origin.
+     */
+    public final int getStartX() {
+        return mStartX;
+    }
+
+    /**
+     * Returns the start Y offset in the scroll.
+     *
+     * @return The start Y offset as an absolute distance from the origin.
+     */
+    public final int getStartY() {
+        return mStartY;
+    }
+
+    /**
+     * Returns where the scroll will end. Valid only for "fling" scrolls.
+     *
+     * @return The final X offset as an absolute distance from the origin.
+     */
+    public final int getFinalX() {
+        return mFinalX;
+    }
+
+    /**
+     * Returns where the scroll will end. Valid only for "fling" scrolls.
+     *
+     * @return The final Y offset as an absolute distance from the origin.
+     */
+    public final int getFinalY() {
+        return mFinalY;
+    }
+
+    /**
+     * Call this when you want to know the new location.  If it returns true,
+     * the animation is not yet finished.  loc will be altered to provide the
+     * new location.
+     */
+    public boolean computeScrollOffset() {
+        if (mFinished) {
+            return false;
+        }
+
+        int timePassed = (int) (AnimationUtils.currentAnimationTimeMillis() - mStartTime);
+
+        if (timePassed < mDuration) {
+            switch (mMode) {
+            case SCROLL_MODE:
+                float x = timePassed * mDurationReciprocal;
+
+                if (mInterpolator == null)
+                    x = viscousFluid(x);
+                else
+                    x = mInterpolator.getInterpolation(x);
+
+                mCurrX = mStartX + Math.round(x * mDeltaX);
+                mCurrY = mStartY + Math.round(x * mDeltaY);
+                break;
+            case FLING_MODE:
+                final float t = (float) timePassed / mDuration;
+                final int index = (int) (NB_SAMPLES * t);
+                final float tInf = (float) index / NB_SAMPLES;
+                final float tSup = (float) (index + 1) / NB_SAMPLES;
+                final float dInf = SPLINE[index];
+                final float dSup = SPLINE[index + 1];
+                final float distanceCoef = dInf + (t - tInf) / (tSup - tInf) * (dSup - dInf);
+
+                mCurrX = mStartX + Math.round(distanceCoef * (mFinalX - mStartX));
+                // Pin to mMinX <= mCurrX <= mMaxX
+                mCurrX = Math.min(mCurrX, mMaxX);
+                mCurrX = Math.max(mCurrX, mMinX);
+
+                mCurrY = mStartY + Math.round(distanceCoef * (mFinalY - mStartY));
+                // Pin to mMinY <= mCurrY <= mMaxY
+                mCurrY = Math.min(mCurrY, mMaxY);
+                mCurrY = Math.max(mCurrY, mMinY);
+
+                if (mCurrX == mFinalX && mCurrY == mFinalY) {
+                    mFinished = true;
+                }
+
+                break;
+            }
+        } else {
+            mCurrX = mFinalX;
+            mCurrY = mFinalY;
+            mFinished = true;
+        }
+        return true;
+    }
+
+    /**
+     * Start scrolling by providing a starting point and the distance to travel.
+     * The scroll will use the default value of 250 milliseconds for the
+     * duration.
+     *
+     * @param startX Starting horizontal scroll offset in pixels. Positive
+     *        numbers will scroll the content to the left.
+     * @param startY Starting vertical scroll offset in pixels. Positive numbers
+     *        will scroll the content up.
+     * @param dx Horizontal distance to travel. Positive numbers will scroll the
+     *        content to the left.
+     * @param dy Vertical distance to travel. Positive numbers will scroll the
+     *        content up.
+     */
+    public void startScroll(int startX, int startY, int dx, int dy) {
+        startScroll(startX, startY, dx, dy, DEFAULT_DURATION);
+    }
+
+    /**
+     * Start scrolling by providing a starting point and the distance to travel.
+     *
+     * @param startX Starting horizontal scroll offset in pixels. Positive
+     *        numbers will scroll the content to the left.
+     * @param startY Starting vertical scroll offset in pixels. Positive numbers
+     *        will scroll the content up.
+     * @param dx Horizontal distance to travel. Positive numbers will scroll the
+     *        content to the left.
+     * @param dy Vertical distance to travel. Positive numbers will scroll the
+     *        content up.
+     * @param duration Duration of the scroll in milliseconds.
+     */
+    public void startScroll(int startX, int startY, int dx, int dy, int duration) {
+        mMode = SCROLL_MODE;
+        mFinished = false;
+        mDuration = duration;
+        mStartTime = AnimationUtils.currentAnimationTimeMillis();
+        mStartX = startX;
+        mStartY = startY;
+        mFinalX = startX + dx;
+        mFinalY = startY + dy;
+        mDeltaX = dx;
+        mDeltaY = dy;
+        mDurationReciprocal = 1.0f / (float) mDuration;
+    }
+
+    /**
+     * Start scrolling based on a fling gesture. The distance travelled will
+     * depend on the initial velocity of the fling.
+     *
+     * @param startX Starting point of the scroll (X)
+     * @param startY Starting point of the scroll (Y)
+     * @param velocityX Initial velocity of the fling (X) measured in pixels per
+     *        second.
+     * @param velocityY Initial velocity of the fling (Y) measured in pixels per
+     *        second
+     * @param minX Minimum X value. The scroller will not scroll past this
+     *        point.
+     * @param maxX Maximum X value. The scroller will not scroll past this
+     *        point.
+     * @param minY Minimum Y value. The scroller will not scroll past this
+     *        point.
+     * @param maxY Maximum Y value. The scroller will not scroll past this
+     *        point.
+     */
+    public void fling(int startX, int startY, int velocityX, int velocityY,
+            int minX, int maxX, int minY, int maxY) {
+        // Continue a scroll or fling in progress
+        if (mFlywheel && !mFinished) {
+            float oldVel = getCurrVelocity();
+
+            float dx = (float) (mFinalX - mStartX);
+            float dy = (float) (mFinalY - mStartY);
+            float hyp = FloatMath.sqrt(dx * dx + dy * dy);
+
+            float ndx = dx / hyp;
+            float ndy = dy / hyp;
+
+            float oldVelocityX = ndx * oldVel;
+            float oldVelocityY = ndy * oldVel;
+            if (Math.signum(velocityX) == Math.signum(oldVelocityX)
+                    && Math.signum(velocityY) == Math.signum(oldVelocityY)) {
+                velocityX += oldVelocityX;
+                velocityY += oldVelocityY;
+            }
+        }
+
+        mMode = FLING_MODE;
+        mFinished = false;
+
+        float velocity = FloatMath.sqrt(velocityX * velocityX + velocityY * velocityY);
+
+        mVelocity = velocity;
+        final double l = Math.log(START_TENSION * velocity / ALPHA);
+        mDuration = (int) (1000.0 * Math.exp(l / (DECELERATION_RATE - 1.0)));
+        mStartTime = AnimationUtils.currentAnimationTimeMillis();
+        mStartX = startX;
+        mStartY = startY;
+
+        float coeffX = velocity == 0 ? 1.0f : velocityX / velocity;
+        float coeffY = velocity == 0 ? 1.0f : velocityY / velocity;
+
+        int totalDistance =
+                (int) (ALPHA * Math.exp(DECELERATION_RATE / (DECELERATION_RATE - 1.0) * l));
+
+        mMinX = minX;
+        mMaxX = maxX;
+        mMinY = minY;
+        mMaxY = maxY;
+
+        mFinalX = startX + Math.round(totalDistance * coeffX);
+        // Pin to mMinX <= mFinalX <= mMaxX
+        mFinalX = Math.min(mFinalX, mMaxX);
+        mFinalX = Math.max(mFinalX, mMinX);
+
+        mFinalY = startY + Math.round(totalDistance * coeffY);
+        // Pin to mMinY <= mFinalY <= mMaxY
+        mFinalY = Math.min(mFinalY, mMaxY);
+        mFinalY = Math.max(mFinalY, mMinY);
+    }
+
+    static float viscousFluid(float x) {
+        x *= sViscousFluidScale;
+        if (x < 1.0f) {
+            x -= (1.0f - (float) Math.exp(-x));
+        } else {
+            float start = 0.36787944117f;   // 1/e == exp(-1)
+            x = 1.0f - (float) Math.exp(1.0f - x);
+            x = start + x * (1.0f - start);
+        }
+        x *= sViscousFluidNormalize;
+        return x;
+    }
+
+    /**
+     * Stops the animation. Contrary to {@link #forceFinished(boolean)},
+     * aborting the animating cause the scroller to move to the final x and y
+     * position
+     *
+     * @see #forceFinished(boolean)
+     */
+    public void abortAnimation() {
+        mCurrX = mFinalX;
+        mCurrY = mFinalY;
+        mFinished = true;
+    }
+
+    /**
+     * Extend the scroll animation. This allows a running animation to scroll
+     * further and longer, when used with {@link #setFinalX(int)} or {@link #setFinalY(int)}.
+     *
+     * @param extend Additional time to scroll in milliseconds.
+     * @see #setFinalX(int)
+     * @see #setFinalY(int)
+     */
+    public void extendDuration(int extend) {
+        int passed = timePassed();
+        mDuration = passed + extend;
+        mDurationReciprocal = 1.0f / mDuration;
+        mFinished = false;
+    }
+
+    /**
+     * Returns the time elapsed since the beginning of the scrolling.
+     *
+     * @return The elapsed time in milliseconds.
+     */
+    public int timePassed() {
+        return (int) (AnimationUtils.currentAnimationTimeMillis() - mStartTime);
+    }
+
+    /**
+     * Sets the final position (X) for this scroller.
+     *
+     * @param newX The new X offset as an absolute distance from the origin.
+     * @see #extendDuration(int)
+     * @see #setFinalY(int)
+     */
+    public void setFinalX(int newX) {
+        mFinalX = newX;
+        mDeltaX = mFinalX - mStartX;
+        mFinished = false;
+    }
+
+    /**
+     * Sets the final position (Y) for this scroller.
+     *
+     * @param newY The new Y offset as an absolute distance from the origin.
+     * @see #extendDuration(int)
+     * @see #setFinalX(int)
+     */
+    public void setFinalY(int newY) {
+        mFinalY = newY;
+        mDeltaY = mFinalY - mStartY;
+        mFinished = false;
+    }
+
+    /**
+     * @hide
+     */
+    public boolean isScrollingInDirection(float xvel, float yvel) {
+        return !mFinished && Math.signum(xvel) == Math.signum(mFinalX - mStartX)
+                && Math.signum(yvel) == Math.signum(mFinalY - mStartY);
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/SinusoidalInterpolator.java b/MenuDrawer/src/net/simonvt/menudrawer/SinusoidalInterpolator.java
new file mode 100755
index 0000000..e79051a
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/SinusoidalInterpolator.java
@@ -0,0 +1,15 @@
+package net.simonvt.menudrawer;
+
+import android.view.animation.Interpolator;
+
+/**
+ * Interpolator which, when drawn from 0 to 1, looks like half a sine-wave. Used for smoother opening/closing when
+ * peeking at the drawer.
+ */
+public class SinusoidalInterpolator implements Interpolator {
+
+    @Override
+    public float getInterpolation(float input) {
+        return (float) (0.5f + 0.5f * Math.sin(input * Math.PI - Math.PI / 2.f));
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/SmoothInterpolator.java b/MenuDrawer/src/net/simonvt/menudrawer/SmoothInterpolator.java
new file mode 100755
index 0000000..cfdcb69
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/SmoothInterpolator.java
@@ -0,0 +1,12 @@
+package net.simonvt.menudrawer;
+
+import android.view.animation.Interpolator;
+
+public class SmoothInterpolator implements Interpolator {
+
+    @Override
+    public float getInterpolation(float t) {
+        t -= 1.0f;
+        return t * t * t * t * t + 1.0f;
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/StaticDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/StaticDrawer.java
new file mode 100755
index 0000000..879f2c9
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/StaticDrawer.java
@@ -0,0 +1,208 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.util.AttributeSet;
+
+public abstract class StaticDrawer extends MenuDrawer {
+
+    protected Position mPosition;
+
+    StaticDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public StaticDrawer(Context context) {
+        super(context);
+    }
+
+    public StaticDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public StaticDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void dispatchDraw(Canvas canvas) {
+        super.dispatchDraw(canvas);
+        if (mDropShadowEnabled) drawDropShadow(canvas);
+        if (mActiveIndicator != null) drawIndicator(canvas);
+    }
+
+    private void drawDropShadow(Canvas canvas) {
+        final int width = getWidth();
+        final int height = getHeight();
+        final int menuSize = mMenuSize;
+        final int dropShadowSize = mDropShadowSize;
+
+        switch (mPosition) {
+            case LEFT:
+                mDropShadowDrawable.setBounds(menuSize - dropShadowSize, 0, menuSize, height);
+                break;
+
+            case TOP:
+                mDropShadowDrawable.setBounds(0, menuSize - dropShadowSize, width, menuSize);
+                break;
+
+            case RIGHT:
+                mDropShadowDrawable.setBounds(width - menuSize, 0, width - menuSize + dropShadowSize, height);
+                break;
+
+            case BOTTOM:
+                mDropShadowDrawable.setBounds(0, height - menuSize, width, height - menuSize + dropShadowSize);
+                break;
+        }
+
+        mDropShadowDrawable.draw(canvas);
+    }
+
+    protected abstract void drawIndicator(Canvas canvas);
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        final int width = r - l;
+        final int height = b - t;
+
+        switch (mPosition) {
+            case LEFT:
+                mMenuContainer.layout(0, 0, mMenuSize, height);
+                mContentContainer.layout(mMenuSize, 0, width, height);
+                break;
+
+            case RIGHT:
+                mMenuContainer.layout(width - mMenuSize, 0, width, height);
+                mContentContainer.layout(0, 0, width - mMenuSize, height);
+                break;
+
+            case TOP:
+                mMenuContainer.layout(0, 0, width, mMenuSize);
+                mContentContainer.layout(0, mMenuSize, width, height);
+                break;
+
+            case BOTTOM:
+                mMenuContainer.layout(0, height - mMenuSize, width, height);
+                mContentContainer.layout(0, 0, width, height - mMenuSize);
+                break;
+        }
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+
+        if (widthMode != MeasureSpec.EXACTLY || heightMode != MeasureSpec.EXACTLY) {
+            throw new IllegalStateException("Must measure with an exact size");
+        }
+
+        final int width = MeasureSpec.getSize(widthMeasureSpec);
+        final int height = MeasureSpec.getSize(heightMeasureSpec);
+
+        if (!mMenuSizeSet) mMenuSize = (int) (height * 0.25f);
+
+        switch (mPosition) {
+            case LEFT:
+            case RIGHT: {
+                final int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
+
+                final int menuWidth = mMenuSize;
+                final int menuWidthMeasureSpec = MeasureSpec.makeMeasureSpec(menuWidth, MeasureSpec.EXACTLY);
+
+                final int contentWidth = width - menuWidth;
+                final int contentWidthMeasureSpec = MeasureSpec.makeMeasureSpec(contentWidth, MeasureSpec.EXACTLY);
+
+                mContentContainer.measure(contentWidthMeasureSpec, childHeightMeasureSpec);
+                mMenuContainer.measure(menuWidthMeasureSpec, childHeightMeasureSpec);
+                break;
+            }
+
+            case TOP:
+            case BOTTOM: {
+                final int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY);
+
+                final int menuHeight = mMenuSize;
+                final int menuHeightMeasureSpec = MeasureSpec.makeMeasureSpec(menuHeight, MeasureSpec.EXACTLY);
+
+                final int contentHeight = height - menuHeight;
+                final int contentHeightMeasureSpec = MeasureSpec.makeMeasureSpec(contentHeight, MeasureSpec.EXACTLY);
+
+                mContentContainer.measure(childWidthMeasureSpec, contentHeightMeasureSpec);
+                mMenuContainer.measure(childWidthMeasureSpec, menuHeightMeasureSpec);
+                break;
+            }
+        }
+
+        setMeasuredDimension(width, height);
+    }
+
+    @Override
+    public void toggleMenu(boolean animate) {
+    }
+
+    @Override
+    public void openMenu(boolean animate) {
+    }
+
+    @Override
+    public void closeMenu(boolean animate) {
+    }
+
+    @Override
+    public boolean isMenuVisible() {
+        return true;
+    }
+
+    @Override
+    public void setMenuSize(int size) {
+        mMenuSize = size;
+        mMenuSizeSet = true;
+        requestLayout();
+        invalidate();
+    }
+
+    @Override
+    public void setOffsetMenuEnabled(boolean offsetMenu) {
+    }
+
+    @Override
+    public boolean getOffsetMenuEnabled() {
+        return false;
+    }
+
+    @Override
+    public void peekDrawer() {
+    }
+
+    @Override
+    public void peekDrawer(long delay) {
+    }
+
+    @Override
+    public void peekDrawer(long startDelay, long delay) {
+    }
+
+    @Override
+    public void setHardwareLayerEnabled(boolean enabled) {
+    }
+
+    @Override
+    public int getTouchMode() {
+        return TOUCH_MODE_NONE;
+    }
+
+    @Override
+    public void setTouchMode(int mode) {
+    }
+
+    @Override
+    public void setTouchBezelSize(int size) {
+    }
+
+    @Override
+    public int getTouchBezelSize() {
+        return 0;
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/TopDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/TopDrawer.java
new file mode 100755
index 0000000..198bde5
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/TopDrawer.java
@@ -0,0 +1,229 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.GradientDrawable;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+
+public class TopDrawer extends VerticalDrawer {
+
+    private int mIndicatorLeft;
+
+    TopDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public TopDrawer(Context context) {
+        super(context);
+    }
+
+    public TopDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public TopDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    public void openMenu(boolean animate) {
+        animateOffsetTo(mMenuSize, 0, animate);
+    }
+
+    @Override
+    public void closeMenu(boolean animate) {
+        animateOffsetTo(0, 0, animate);
+    }
+
+    @Override
+    public void setDropShadowColor(int color) {
+        final int endColor = color & 0x00FFFFFF;
+        mDropShadowDrawable = new GradientDrawable(GradientDrawable.Orientation.BOTTOM_TOP,
+                new int[] {
+                        color,
+                        endColor,
+                });
+        invalidate();
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        final int width = r - l;
+        final int height = b - t;
+        final int offsetPixels = (int) mOffsetPixels;
+
+        mMenuContainer.layout(0, 0, width, mMenuSize);
+        offsetMenu(offsetPixels);
+
+        if (USE_TRANSLATIONS) {
+            mContentContainer.layout(0, 0, width, height);
+        } else {
+            mContentContainer.layout(0, offsetPixels, width, height + offsetPixels);
+        }
+    }
+
+    /**
+     * Offsets the menu relative to its original position based on the position of the content.
+     *
+     * @param offsetPixels The number of pixels the content if offset.
+     */
+    private void offsetMenu(int offsetPixels) {
+        if (mOffsetMenu && mMenuSize != 0) {
+            final int menuSize = mMenuSize;
+            final float openRatio = (menuSize - (float) offsetPixels) / menuSize;
+
+            if (USE_TRANSLATIONS) {
+                if (offsetPixels > 0) {
+                    final int offset = (int) (0.25f * (-openRatio * menuSize));
+                    mMenuContainer.setTranslationY(offset);
+                } else {
+                    mMenuContainer.setTranslationY(-menuSize);
+                }
+
+            } else {
+                final int oldMenuTop = mMenuContainer.getTop();
+                final int offset = (int) (0.25f * (-openRatio * menuSize)) - oldMenuTop;
+                mMenuContainer.offsetTopAndBottom(offset);
+                mMenuContainer.setVisibility(offsetPixels == 0 ? INVISIBLE : VISIBLE);
+            }
+        }
+    }
+
+    @Override
+    protected void drawDropShadow(Canvas canvas, int offsetPixels) {
+        final int width = getWidth();
+
+        mDropShadowDrawable.setBounds(0, offsetPixels - mDropShadowSize, width, offsetPixels);
+        mDropShadowDrawable.draw(canvas);
+    }
+
+    @Override
+    protected void drawMenuOverlay(Canvas canvas, int offsetPixels) {
+        final int width = getWidth();
+        final float openRatio = ((float) offsetPixels) / mMenuSize;
+
+        mMenuOverlay.setBounds(0, 0, width, offsetPixels);
+        mMenuOverlay.setAlpha((int) (MAX_MENU_OVERLAY_ALPHA * (1.f - openRatio)));
+        mMenuOverlay.draw(canvas);
+    }
+
+    @Override
+    protected void drawWindowEdge (Canvas canvas, int offsetPixels) {
+        final int width = getWidth();
+        final int edgeHeight = mWindowEdge.getIntrinsicHeight();
+        final int top = offsetPixels;
+        final int bottom = offsetPixels + edgeHeight;
+        final float openRatio = ((float) Math.abs(offsetPixels)) / mMenuSize;
+
+        mWindowEdge.setBounds(0, top, width, bottom);
+        mWindowEdge.setAlpha((int) (MAX_MENU_OVERLAY_ALPHA * (openRatio)));
+        mWindowEdge.draw(canvas);
+    }
+
+    @Override
+    protected void drawIndicator(Canvas canvas, int offsetPixels) {
+        if (mActiveView != null && isViewDescendant(mActiveView)) {
+            Integer position = (Integer) mActiveView.getTag(R.id.mdActiveViewPosition);
+            final int pos = position == null ? 0 : position;
+
+            if (pos == mActivePosition) {
+                final int menuHeight = mMenuSize;
+                final int indicatorHeight = mActiveIndicator.getHeight();
+
+                final float openRatio = ((float) offsetPixels) / menuHeight;
+
+                mActiveView.getDrawingRect(mActiveRect);
+                offsetDescendantRectToMyCoords(mActiveView, mActiveRect);
+                final int indicatorWidth = mActiveIndicator.getWidth();
+
+                final float interpolatedRatio = 1.f - INDICATOR_INTERPOLATOR.getInterpolation((1.f - openRatio));
+                final int interpolatedHeight = (int) (indicatorHeight * interpolatedRatio);
+
+                final int indicatorTop = offsetPixels - interpolatedHeight;
+                if (mIndicatorAnimating) {
+                    final int finalLeft = mActiveRect.left + ((mActiveRect.width() - indicatorWidth) / 2);
+                    final int startLeft = mIndicatorStartPos;
+                    final int diff = finalLeft - startLeft;
+                    final int startOffset = (int) (diff * mIndicatorOffset);
+                    mIndicatorLeft = startLeft + startOffset;
+                } else {
+                    mIndicatorLeft = mActiveRect.left + ((mActiveRect.width() - indicatorWidth) / 2);
+                }
+
+                canvas.save();
+                canvas.clipRect(mIndicatorLeft, indicatorTop, mIndicatorLeft + indicatorWidth, offsetPixels);
+                canvas.drawBitmap(mActiveIndicator, mIndicatorLeft, indicatorTop, null);
+                canvas.restore();
+            }
+        }
+    }
+
+    @Override
+    protected int getIndicatorStartPos() {
+        return mIndicatorLeft;
+    }
+
+    @Override
+    protected void initPeekScroller() {
+        final int dx = mMenuSize / 3;
+        mPeekScroller.startScroll(0, 0, dx, 0, PEEK_DURATION);
+    }
+
+    @Override
+    protected void onOffsetPixelsChanged(int offsetPixels) {
+        if (USE_TRANSLATIONS) {
+            mContentContainer.setTranslationY(offsetPixels);
+            offsetMenu(offsetPixels);
+            invalidate();
+        } else {
+            mContentContainer.offsetTopAndBottom(offsetPixels - mContentContainer.getTop());
+            offsetMenu(offsetPixels);
+            invalidate();
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////
+    // Touch handling
+    //////////////////////////////////////////////////////////////////////
+
+    @Override
+    protected boolean isContentTouch(MotionEvent ev) {
+        return ev.getY() > mOffsetPixels;
+    }
+
+    @Override
+    protected boolean onDownAllowDrag(MotionEvent ev) {
+        return (!mMenuVisible && mInitialMotionY <= mTouchSize)
+                || (mMenuVisible && mInitialMotionY >= mOffsetPixels);
+    }
+
+    @Override
+    protected boolean onMoveAllowDrag(MotionEvent ev, float diff) {
+        return (!mMenuVisible && mInitialMotionY <= mTouchSize && (diff > 0))
+                || (mMenuVisible && mInitialMotionY >= mOffsetPixels);
+    }
+
+    @Override
+    protected void onMoveEvent(float dx) {
+        setOffsetPixels(Math.min(Math.max(mOffsetPixels + dx, 0), mMenuSize));
+    }
+
+    @Override
+    protected void onUpEvent(MotionEvent ev, boolean isDownOnOutside) {
+        final int offsetPixels = (int) mOffsetPixels;
+
+        if (mIsDragging) {
+            mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+            final int initialVelocity = (int) mVelocityTracker.getXVelocity();
+            mLastMotionY = ev.getY();
+            animateOffsetTo(mVelocityTracker.getYVelocity() > 0 ? mMenuSize : 0, initialVelocity,
+                    true);
+
+            // Close the menu when content is clicked while the menu is visible.
+        } else if (mMenuVisible && ev.getY() > offsetPixels) {
+            closeMenu();
+        }
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/TopStaticDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/TopStaticDrawer.java
new file mode 100755
index 0000000..ac84614
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/TopStaticDrawer.java
@@ -0,0 +1,82 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.GradientDrawable;
+import android.util.AttributeSet;
+
+public class TopStaticDrawer extends StaticDrawer {
+
+    private int mIndicatorLeft;
+
+    TopStaticDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public TopStaticDrawer(Context context) {
+        super(context);
+    }
+
+    public TopStaticDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public TopStaticDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void initDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super.initDrawer(context, attrs, defStyle);
+        mPosition = Position.TOP;
+    }
+
+    @Override
+    public void setDropShadowColor(int color) {
+        final int endColor = color & 0x00FFFFFF;
+        mDropShadowDrawable = new GradientDrawable(GradientDrawable.Orientation.BOTTOM_TOP, new int[] {
+                color,
+                endColor,
+        });
+        invalidate();
+    }
+
+    @Override
+    protected void drawIndicator(Canvas canvas) {
+        if (mActiveView != null && isViewDescendant(mActiveView)) {
+            Integer position = (Integer) mActiveView.getTag(R.id.mdActiveViewPosition);
+            final int pos = position == null ? 0 : position;
+
+            if (pos == mActivePosition) {
+                final int menuHeight = mMenuSize;
+                final int indicatorHeight = mActiveIndicator.getHeight();
+
+                mActiveView.getDrawingRect(mActiveRect);
+                offsetDescendantRectToMyCoords(mActiveView, mActiveRect);
+                final int indicatorWidth = mActiveIndicator.getWidth();
+
+                final int indicatorTop = menuHeight - indicatorHeight;
+                if (mIndicatorAnimating) {
+                    final int finalLeft = mActiveRect.left + ((mActiveRect.width() - indicatorWidth) / 2);
+                    final int startLeft = mIndicatorStartPos;
+                    final int diff = finalLeft - startLeft;
+                    final int startOffset = (int) (diff * mIndicatorOffset);
+                    mIndicatorLeft = startLeft + startOffset;
+                } else {
+                    mIndicatorLeft = mActiveRect.left + ((mActiveRect.width() - indicatorWidth) / 2);
+                }
+
+                canvas.save();
+                canvas.clipRect(mIndicatorLeft, indicatorTop, mIndicatorLeft + indicatorWidth, menuHeight);
+                canvas.drawBitmap(mActiveIndicator, mIndicatorLeft, indicatorTop, null);
+                canvas.restore();
+            }
+        }
+    }
+
+    @Override
+    protected int getIndicatorStartPos() {
+        return mIndicatorLeft;
+    }
+}
diff --git a/MenuDrawer/src/net/simonvt/menudrawer/VerticalDrawer.java b/MenuDrawer/src/net/simonvt/menudrawer/VerticalDrawer.java
new file mode 100755
index 0000000..2d7999b
--- /dev/null
+++ b/MenuDrawer/src/net/simonvt/menudrawer/VerticalDrawer.java
@@ -0,0 +1,216 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+
+public abstract class VerticalDrawer extends DraggableDrawer {
+
+    VerticalDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public VerticalDrawer(Context context) {
+        super(context);
+    }
+
+    public VerticalDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public VerticalDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+
+        if (widthMode != MeasureSpec.EXACTLY || heightMode != MeasureSpec.EXACTLY) {
+            throw new IllegalStateException("Must measure with an exact size");
+        }
+
+        final int width = MeasureSpec.getSize(widthMeasureSpec);
+        final int height = MeasureSpec.getSize(heightMeasureSpec);
+
+        if (!mMenuSizeSet) mMenuSize = (int) (height * 0.25f);
+        if (mOffsetPixels == -1) openMenu(false);
+
+        final int menuWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, width);
+        final int menuHeightMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, mMenuSize);
+        mMenuContainer.measure(menuWidthMeasureSpec, menuHeightMeasureSpec);
+
+        final int contentWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, width);
+        final int contentHeightMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, height);
+        mContentContainer.measure(contentWidthMeasureSpec, contentHeightMeasureSpec);
+
+        setMeasuredDimension(width, height);
+
+        updateTouchAreaSize();
+    }
+
+    @Override
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        final int action = ev.getAction() & MotionEvent.ACTION_MASK;
+
+        if (action == MotionEvent.ACTION_DOWN && mMenuVisible && isCloseEnough()) {
+            setOffsetPixels(0);
+            stopAnimation();
+            endPeek();
+            setDrawerState(STATE_CLOSED);
+        }
+
+        // Always intercept events over the content while menu is visible.
+        if (mMenuVisible && isContentTouch(ev)) {
+            return true;
+        }
+
+        if (mTouchMode == TOUCH_MODE_NONE) {
+            return false;
+        }
+
+        if (action != MotionEvent.ACTION_DOWN) {
+            if (mIsDragging) {
+                return true;
+            }
+        }
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN: {
+                mLastMotionX = mInitialMotionX = ev.getX();
+                mLastMotionY = mInitialMotionY = ev.getY();
+                final boolean allowDrag = onDownAllowDrag(ev);
+
+                if (allowDrag) {
+                    setDrawerState(mMenuVisible ? STATE_OPEN : STATE_CLOSED);
+                    stopAnimation();
+                    endPeek();
+                    mIsDragging = false;
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_MOVE: {
+                final float x = ev.getX();
+                final float dx = x - mLastMotionX;
+                final float xDiff = Math.abs(dx);
+                final float y = ev.getY();
+                final float dy = y - mLastMotionY;
+                final float yDiff = Math.abs(dy);
+
+                if (yDiff > mTouchSlop && yDiff > xDiff) {
+                    if (mOnInterceptMoveEventListener != null && mTouchMode == TOUCH_MODE_FULLSCREEN
+                            && canChildScrollVertically(mContentContainer, false, (int) dx, (int) x, (int) y)) {
+                        endDrag(); // Release the velocity tracker
+                        return false;
+                    }
+
+                    final boolean allowDrag = onMoveAllowDrag(ev, dy);
+
+                    if (allowDrag) {
+                        setDrawerState(STATE_DRAGGING);
+                        mIsDragging = true;
+                        mLastMotionX = x;
+                        mLastMotionY = y;
+                    }
+                }
+                break;
+            }
+
+            /**
+             * If you click really fast, an up or cancel event is delivered here. Just snap content to
+             * whatever is closest.
+             */
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP: {
+                if (Math.abs(mOffsetPixels) > mMenuSize / 2) {
+                    openMenu();
+                } else {
+                    closeMenu();
+                }
+                break;
+            }
+        }
+
+        if (mVelocityTracker == null) {
+            mVelocityTracker = VelocityTracker.obtain();
+        }
+        mVelocityTracker.addMovement(ev);
+
+        return mIsDragging;
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        if (!mMenuVisible && !mIsDragging && (mTouchMode == TOUCH_MODE_NONE)) {
+            return false;
+        }
+        final int action = ev.getAction() & MotionEvent.ACTION_MASK;
+
+        if (mVelocityTracker == null) {
+            mVelocityTracker = VelocityTracker.obtain();
+        }
+        mVelocityTracker.addMovement(ev);
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN: {
+                mLastMotionX = mInitialMotionX = ev.getX();
+                mLastMotionY = mInitialMotionY = ev.getY();
+                final boolean allowDrag = onDownAllowDrag(ev);
+
+                if (allowDrag) {
+                    stopAnimation();
+                    endPeek();
+                    startLayerTranslation();
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_MOVE: {
+                if (!mIsDragging) {
+                    final float x = ev.getX();
+                    final float dx = x - mLastMotionX;
+                    final float xDiff = Math.abs(dx);
+                    final float y = ev.getY();
+                    final float dy = y - mLastMotionY;
+                    final float yDiff = Math.abs(dy);
+
+                    if (yDiff > mTouchSlop && yDiff > xDiff) {
+                        final boolean allowDrag = onMoveAllowDrag(ev, dy);
+
+                        if (allowDrag) {
+                            setDrawerState(STATE_DRAGGING);
+                            mIsDragging = true;
+                            mLastMotionY = y - mInitialMotionY > 0
+                                    ? mInitialMotionY + mTouchSlop
+                                    : mInitialMotionY - mTouchSlop;
+                        }
+                    }
+                }
+
+                if (mIsDragging) {
+                    startLayerTranslation();
+
+                    final float y = ev.getY();
+                    final float dy = y - mLastMotionY;
+
+                    mLastMotionY = y;
+                    onMoveEvent(dy);
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP: {
+                onUpEvent(ev, true);
+                break;
+            }
+        }
+
+        return true;
+    }
+
+}