Back to project page android-menudrawer.
The source code is released under:
Apache License
If you think the Android project android-menudrawer listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
package net.simonvt.menudrawer; //from w w w . j a v a 2s. c o m import net.simonvt.menudrawer.compat.ActionBarHelper; import android.app.Activity; import android.content.Context; import android.content.res.TypedArray; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Canvas; import android.graphics.Rect; import android.graphics.drawable.Drawable; import android.graphics.drawable.GradientDrawable; 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.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.view.ViewParent; import android.view.ViewTreeObserver; import android.view.animation.AccelerateInterpolator; 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); /** * Called when the drawer slides. * * @param openRatio Ratio for how open the menu is. * @param offsetPixels Current offset of the menu in pixels. */ void onDrawerSlide(float openRatio, int offsetPixels); } /** * 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 delta 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 delta, int x, int y); } public enum Type { /** * Positions the drawer behind the content. */ BEHIND, /** * A static drawer that can not be dragged. */ STATIC, /** * Positions the drawer on top of the content. */ OVERLAY, } /** * 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.ICE_CREAM_SANDWICH; /** * 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(); /** * Interpolator used for stretching/retracting the active indicator. */ protected static final Interpolator INDICATOR_INTERPOLATOR = new AccelerateInterpolator(); /** * Drawable used as menu overlay. */ protected Drawable mMenuOverlay; /** * Defines whether the drop shadow is enabled. */ protected boolean mDropShadowEnabled; /** * The color of the drop shadow. */ protected int mDropShadowColor; /** * Drawable used as content drop shadow onto the menu. */ protected Drawable mDropShadowDrawable; private boolean mCustomDropShadow; /** * 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 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 SlideDrawable mSlideDrawable; protected Drawable mThemeUpIndicator; protected boolean mDrawerIndicatorEnabled; private ActionBarHelper mActionBarHelper; private int mCurrentUpContentDesc; private int mDrawerOpenContentDesc; private int mDrawerClosedContentDesc; /** * The position of the drawer. */ private Position mPosition; private Position mResolvedPosition; private final Rect mIndicatorClipRect = new Rect(); protected boolean mIsStatic; protected final Rect mDropShadowRect = new Rect(); /** * Current offset. */ protected float mOffsetPixels; /** * Whether an overlay should be drawn as the drawer is opened and closed. */ protected boolean mDrawOverlay; /** * 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, Type.BEHIND); } /** * Attaches the MenuDrawer to the Activity. * * @param activity The activity the menu drawer will be attached to. * @param type The {@link Type} of the drawer. * @return The created MenuDrawer instance. */ public static MenuDrawer attach(Activity activity, Type type) { return attach(activity, type, Position.START); } /** * 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, Type.BEHIND, position); } /** * Attaches the MenuDrawer to the Activity. * * @param activity The activity the menu drawer will be attached to. * @param type The {@link Type} of the drawer. * @param position Where to position the menu. * @return The created MenuDrawer instance. */ public static MenuDrawer attach(Activity activity, Type type, Position position) { return attach(activity, type, position, MENU_DRAG_CONTENT); } /** * Attaches the MenuDrawer to the Activity. * * @param activity The activity the menu drawer will be attached to. * @param type The {@link Type} of the drawer. * @param position Where to position the menu. * @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, Type type, Position position, int dragMode) { MenuDrawer menuDrawer = createMenuDrawer(activity, dragMode, position, type); 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, Type type) { MenuDrawer drawer; if (type == Type.STATIC) { drawer = new StaticDrawer(activity); } else if (type == Type.OVERLAY) { drawer = new OverlayDrawer(activity, dragMode); if (position == Position.LEFT || position == Position.START) { drawer.setupUpIndicator(activity); } } else { drawer = new SlidingDrawer(activity, dragMode); if (position == Position.LEFT || position == Position.START) { drawer.setupUpIndicator(activity); } } drawer.mDragMode = dragMode; drawer.setPosition(position); return drawer; } /** * 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, dpToPx(240)); 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) { mDropShadowColor = a.getColor(R.styleable.MenuDrawer_mdDropShadowColor, 0xFF000000); } else { mCustomDropShadow = true; } 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); final int slideDrawableResId = a.getResourceId(R.styleable.MenuDrawer_mdSlideDrawable, -1); if (slideDrawableResId != -1) { setSlideDrawable(slideDrawableResId); } mDrawerOpenContentDesc = a.getResourceId(R.styleable.MenuDrawer_mdDrawerOpenUpContentDescription, 0); mDrawerClosedContentDesc = a.getResourceId(R.styleable.MenuDrawer_mdDrawerClosedUpContentDescription, 0); mDrawOverlay = a.getBoolean(R.styleable.MenuDrawer_mdDrawOverlay, true); final int position = a.getInt(R.styleable.MenuDrawer_mdPosition, 0); setPosition(Position.fromValue(position)); a.recycle(); mMenuContainer = new NoClickThroughFrameLayout(context); mMenuContainer.setId(R.id.md__menu); mMenuContainer.setBackgroundDrawable(menuBackground); mContentContainer = new NoClickThroughFrameLayout(context); mContentContainer.setId(R.id.md__content); mContentContainer.setBackgroundDrawable(contentBackground); mMenuOverlay = new ColorDrawable(0xFF000000); mIndicatorScroller = new FloatScroller(SMOOTH_INTERPOLATOR); } @Override protected void onFinishInflate() { super.onFinishInflate(); View menu = findViewById(R.id.mdMenu); if (menu != null) { removeView(menu); setMenuView(menu); } View content = findViewById(R.id.mdContent); if (content != null) { removeView(content); setContentView(content); } if (getChildCount() > 2) { throw new IllegalStateException( "Menu and content view added in xml must have id's @id/mdMenu and @id/mdContent"); } } 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(); } private boolean shouldDrawIndicator() { return mActiveView != null && mActiveIndicator != null && isViewDescendant(mActiveView); } @Override protected void dispatchDraw(Canvas canvas) { super.dispatchDraw(canvas); final int offsetPixels = (int) mOffsetPixels; if (mDrawOverlay && offsetPixels != 0) { drawOverlay(canvas); } if (mDropShadowEnabled && (offsetPixels != 0 || mIsStatic)) { drawDropShadow(canvas); } if (shouldDrawIndicator() && (offsetPixels != 0 || mIsStatic)) { drawIndicator(canvas); } } protected abstract void drawOverlay(Canvas canvas); private void drawDropShadow(Canvas canvas) { // Can't pass the position to the constructor, so wait with loading the drawable until the drop shadow is // actually drawn. if (mDropShadowDrawable == null) { setDropShadowColor(mDropShadowColor); } updateDropShadowRect(); mDropShadowDrawable.setBounds(mDropShadowRect); mDropShadowDrawable.draw(canvas); } protected void updateDropShadowRect() { // This updates the rect for the static and sliding drawer. The overlay drawer has its own implementation. switch (getPosition()) { case LEFT: mDropShadowRect.top = 0; mDropShadowRect.bottom = getHeight(); mDropShadowRect.right = ViewHelper.getLeft(mContentContainer); mDropShadowRect.left = mDropShadowRect.right - mDropShadowSize; break; case TOP: mDropShadowRect.left = 0; mDropShadowRect.right = getWidth(); mDropShadowRect.bottom = ViewHelper.getTop(mContentContainer); mDropShadowRect.top = mDropShadowRect.bottom - mDropShadowSize; break; case RIGHT: mDropShadowRect.top = 0; mDropShadowRect.bottom = getHeight(); mDropShadowRect.left = ViewHelper.getRight(mContentContainer); mDropShadowRect.right = mDropShadowRect.left + mDropShadowSize; break; case BOTTOM: mDropShadowRect.left = 0; mDropShadowRect.right = getWidth(); mDropShadowRect.top = ViewHelper.getBottom(mContentContainer); mDropShadowRect.bottom = mDropShadowRect.top + mDropShadowSize; break; } } private void drawIndicator(Canvas canvas) { Integer position = (Integer) mActiveView.getTag(R.id.mdActiveViewPosition); final int pos = position == null ? 0 : position; if (pos == mActivePosition) { updateIndicatorClipRect(); canvas.save(); canvas.clipRect(mIndicatorClipRect); int drawLeft = 0; int drawTop = 0; switch (getPosition()) { case LEFT: case TOP: drawLeft = mIndicatorClipRect.left; drawTop = mIndicatorClipRect.top; break; case RIGHT: drawLeft = mIndicatorClipRect.right - mActiveIndicator.getWidth(); drawTop = mIndicatorClipRect.top; break; case BOTTOM: drawLeft = mIndicatorClipRect.left; drawTop = mIndicatorClipRect.bottom - mActiveIndicator.getHeight(); } canvas.drawBitmap(mActiveIndicator, drawLeft, drawTop, null); canvas.restore(); } } /** * Update the {@link Rect} where the indicator is drawn. */ protected void updateIndicatorClipRect() { mActiveView.getDrawingRect(mActiveRect); offsetDescendantRectToMyCoords(mActiveView, mActiveRect); final float openRatio = mIsStatic ? 1.0f : Math.abs(mOffsetPixels) / mMenuSize; final float interpolatedRatio = 1.f - INDICATOR_INTERPOLATOR.getInterpolation((1.f - openRatio)); final int indicatorWidth = mActiveIndicator.getWidth(); final int indicatorHeight = mActiveIndicator.getHeight(); final int interpolatedWidth = (int) (indicatorWidth * interpolatedRatio); final int interpolatedHeight = (int) (indicatorHeight * interpolatedRatio); final int startPos = mIndicatorStartPos; int left = 0; int top = 0; int right = 0; int bottom = 0; switch (getPosition()) { case LEFT: case RIGHT: final int finalTop = mActiveRect.top + ((mActiveRect.height() - indicatorHeight) / 2); if (mIndicatorAnimating) { top = (int) (startPos + ((finalTop - startPos) * mIndicatorOffset)); } else { top = finalTop; } bottom = top + indicatorHeight; break; case TOP: case BOTTOM: final int finalLeft = mActiveRect.left + ((mActiveRect.width() - indicatorWidth) / 2); if (mIndicatorAnimating) { left = (int) (startPos + ((finalLeft - startPos) * mIndicatorOffset)); } else { left = finalLeft; } right = left + indicatorWidth; break; } switch (getPosition()) { case LEFT: { right = ViewHelper.getLeft(mContentContainer); left = right - interpolatedWidth; break; } case TOP: { bottom = ViewHelper.getTop(mContentContainer); top = bottom - interpolatedHeight; break; } case RIGHT: { left = ViewHelper.getRight(mContentContainer); right = left + interpolatedWidth; break; } case BOTTOM: { top = ViewHelper.getBottom(mContentContainer); bottom = top + interpolatedHeight; break; } } mIndicatorClipRect.left = left; mIndicatorClipRect.top = top; mIndicatorClipRect.right = right; mIndicatorClipRect.bottom = bottom; } private void setPosition(Position position) { mPosition = position; mResolvedPosition = getPosition(); } protected Position getPosition() { final int layoutDirection = ViewHelper.getLayoutDirection(this); switch (mPosition) { case START: if (layoutDirection == LAYOUT_DIRECTION_RTL) { return Position.RIGHT; } else { return Position.LEFT; } case END: if (layoutDirection == LAYOUT_DIRECTION_RTL) { return Position.LEFT; } else { return Position.RIGHT; } } return mPosition; } @Override public void onRtlPropertiesChanged(int layoutDirection) { super.onRtlPropertiesChanged(layoutDirection); if (!mCustomDropShadow) setDropShadowColor(mDropShadowColor); if (getPosition() != mResolvedPosition) { mResolvedPosition = getPosition(); setOffsetPixels(mOffsetPixels * -1); } if (mSlideDrawable != null) mSlideDrawable.setIsRtl(layoutDirection == LAYOUT_DIRECTION_RTL); requestLayout(); invalidate(); } /** * 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 (mSlideDrawable != null) { final float offset = Math.abs(mOffsetPixels) / mMenuSize; mSlideDrawable.setOffset(offset); updateUpContentDescription(); } if (newOffset != oldOffset) { onOffsetPixelsChanged(newOffset); mMenuVisible = newOffset != 0; // Notify any attached listeners of the current open ratio final float openRatio = ((float) Math.abs(newOffset)) / mMenuSize; dispatchOnDrawerSlide(openRatio, newOffset); } } /** * 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); /** * 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. */ private int getIndicatorStartPos() { switch (getPosition()) { case TOP: return mIndicatorClipRect.left; case RIGHT: return mIndicatorClipRect.top; case BOTTOM: return mIndicatorClipRect.left; default: return mIndicatorClipRect.top; } } /** * 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; } } /** * 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(); /** * Get the current state of the drawer. * * @return The state of the drawer. */ 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(); } protected GradientDrawable.Orientation getDropShadowOrientation() { // Gets the orientation for the static and sliding drawer. The overlay drawer provides its own implementation. switch (getPosition()) { case TOP: return GradientDrawable.Orientation.BOTTOM_TOP; case RIGHT: return GradientDrawable.Orientation.LEFT_RIGHT; case BOTTOM: return GradientDrawable.Orientation.TOP_BOTTOM; default: return GradientDrawable.Orientation.RIGHT_LEFT; } } /** * Sets the color of the drop shadow. * * @param color The color of the drop shadow. */ public void setDropShadowColor(int color) { GradientDrawable.Orientation orientation = getDropShadowOrientation(); final int endColor = color & 0x00FFFFFF; mDropShadowDrawable = new GradientDrawable(orientation, new int[] { color, endColor, }); invalidate(); } /** * Sets the drawable of the drop shadow. * * @param drawable The drawable of the drop shadow. */ public void setDropShadow(Drawable drawable) { mDropShadowDrawable = drawable; mCustomDropShadow = drawable != null; 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; } /** * Sets whether an overlay should be drawn when sliding the drawer. * * @param drawOverlay Whether an overlay should be drawn when sliding the drawer. */ public void setDrawOverlay(boolean drawOverlay) { mDrawOverlay = drawOverlay; } /** * Gets whether an overlay is drawn when sliding the drawer. * * @return Whether an overlay is drawn when sliding the drawer. */ public boolean getDrawOverlay() { return mDrawOverlay; } protected void updateUpContentDescription() { final int upContentDesc = isMenuVisible() ? mDrawerOpenContentDesc : mDrawerClosedContentDesc; if (mDrawerIndicatorEnabled && mActionBarHelper != null && upContentDesc != mCurrentUpContentDesc) { mCurrentUpContentDesc = upContentDesc; mActionBarHelper.setActionBarDescription(upContentDesc); } } /** * Sets the drawable used as the drawer indicator. * * @param drawable The drawable used as the drawer indicator. */ public void setSlideDrawable(int drawableRes) { setSlideDrawable(getResources().getDrawable(drawableRes)); } /** * Sets the drawable used as the drawer indicator. * * @param drawable The drawable used as the drawer indicator. */ public void setSlideDrawable(Drawable drawable) { mSlideDrawable = new SlideDrawable(drawable); mSlideDrawable.setIsRtl(ViewHelper.getLayoutDirection(this) == LAYOUT_DIRECTION_RTL); if (mActionBarHelper != null) { mActionBarHelper.setDisplayShowHomeAsUpEnabled(true); if (mDrawerIndicatorEnabled) { mActionBarHelper.setActionBarUpIndicator(mSlideDrawable, isMenuVisible() ? mDrawerOpenContentDesc : mDrawerClosedContentDesc); } } } /** * Sets up the drawer indicator. It cna then be shown with {@link #setDrawerIndicatorEnabled(boolean)}. * * @param activity The activity the drawer is attached to. */ public void setupUpIndicator(Activity activity) { if (mActionBarHelper == null) { mActionBarHelper = new ActionBarHelper(activity); mThemeUpIndicator = mActionBarHelper.getThemeUpIndicator(); if (mDrawerIndicatorEnabled) { mActionBarHelper.setActionBarUpIndicator(mSlideDrawable, isMenuVisible() ? mDrawerOpenContentDesc : mDrawerClosedContentDesc); } } } /** * Sets whether the drawer indicator should be enabled. {@link #setupUpIndicator(android.app.Activity)} must be * called first. * * @param enabled Whether the drawer indicator should enabled. */ public void setDrawerIndicatorEnabled(boolean enabled) { if (mActionBarHelper == null) { throw new IllegalStateException("setupUpIndicator(Activity) has not been called"); } mDrawerIndicatorEnabled = enabled; if (enabled) { mActionBarHelper.setActionBarUpIndicator(mSlideDrawable, isMenuVisible() ? mDrawerOpenContentDesc : mDrawerClosedContentDesc); } else { mActionBarHelper.setActionBarUpIndicator(mThemeUpIndicator, 0); } } /** * Indicates whether the drawer indicator is currently enabled. * * @return Whether the drawer indicator is enabled. */ public boolean isDrawerIndicatorEnabled() { return mDrawerIndicatorEnabled; } /** * 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 && mPosition != Position.BOTTOM) { mMenuContainer.setPadding(0, insets.top, 0, 0); } return super.fitSystemWindows(insets); } protected void dispatchOnDrawerSlide(float openRatio, int offsetPixels) { if (mOnDrawerStateChangeListener != null) { mOnDrawerStateChangeListener.onDrawerSlide(openRatio, offsetPixels); } } /** * 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]; } }; } }