仿qq最新侧滑菜单

public class SlidingMenu extends RelativeLayout {  
 
 private static final String TAG = SlidingMenu.class.getSimpleName();  
 
 public static final int SLIDING_WINDOW = 0;  
 public static final int SLIDING_CONTENT = 1;  
 private boolean mActionbarOverlay = false;  
 
 /** 
     * Constant value for use with setTouchModeAbove(). Allows the SlidingMenu 
     * to be opened with a swipe gesture on the screen's margin 
     */ 
 public static final int TOUCHMODE_MARGIN = 0;  
 
 /** 
     * Constant value for use with setTouchModeAbove(). Allows the SlidingMenu 
     * to be opened with a swipe gesture anywhere on the screen 
     */ 
 public static final int TOUCHMODE_FULLSCREEN = 1;  
 
 /** 
     * Constant value for use with setTouchModeAbove(). Denies the SlidingMenu 
     * to be opened with a swipe gesture 
     */ 
 public static final int TOUCHMODE_NONE = 2;  
 
 /** 
     * Constant value for use with setMode(). Puts the menu to the left of the 
     * content. 
     */ 
 public static final int LEFT = 0;  
 
 /** 
     * Constant value for use with setMode(). Puts the menu to the right of the 
     * content. 
     */ 
 public static final int RIGHT = 1;  
 
 /** 
     * Constant value for use with setMode(). Puts menus to the left and right 
     * of the content. 
     */ 
 public static final int LEFT_RIGHT = 2;  
 
 private CustomViewAbove mViewAbove;  
 
 private CustomViewBehind mViewBehind;  
 
 /** 整体的背景，用一个ImageView代替 */ 
 private ImageView mViewBackground;  
 
 private OnOpenListener mOpenListener;  
 
 private OnOpenListener mSecondaryOpenListner;  
 
 private OnCloseListener mCloseListener;  
 
 /** 
     * The listener interface for receiving onOpen events. The class that is 
     * interested in processing a onOpen event implements this interface, and 
     * the object created with that class is registered with a component using 
     * the component's <code>addOnOpenListener<code> method. When 
     * the onOpen event occurs, that object's appropriate 
     * method is invoked 
     */ 
 public interface OnOpenListener {  
 
 /** 
         * On open. 
         */ 
 public void onOpen();  
    }  
 
 /** 
     * The listener interface for receiving onOpened events. The class that is 
     * interested in processing a onOpened event implements this interface, and 
     * the object created with that class is registered with a component using 
     * the component's <code>addOnOpenedListener<code> method. When 
     * the onOpened event occurs, that object's appropriate 
     * method is invoked. 
     *  
     * @see OnOpenedEvent 
     */ 
 public interface OnOpenedListener {  
 
 /** 
         * On opened. 
         */ 
 public void onOpened();  
    }  
 
 /** 
     * The listener interface for receiving onClose events. The class that is 
     * interested in processing a onClose event implements this interface, and 
     * the object created with that class is registered with a component using 
     * the component's <code>addOnCloseListener<code> method. When 
     * the onClose event occurs, that object's appropriate 
     * method is invoked. 
     *  
     * @see OnCloseEvent 
     */ 
 public interface OnCloseListener {  
 
 /** 
         * On close. 
         */ 
 public void onClose();  
    }  
 
 /** 
     * The listener interface for receiving onClosed events. The class that is 
     * interested in processing a onClosed event implements this interface, and 
     * the object created with that class is registered with a component using 
     * the component's <code>addOnClosedListener<code> method. When 
     * the onClosed event occurs, that object's appropriate 
     * method is invoked. 
     *  
     * @see OnClosedEvent 
     */ 
 public interface OnClosedListener {  
 
 /** 
         * On closed. 
         */ 
 public void onClosed();  
    }  
 
 /** 
     * The Interface CanvasTransformer. 
     */ 
 public interface CanvasTransformer {  
 
 /** 
         * Transform canvas. 
         *  
         * @param canvas 
         *            the canvas 
         * @param percentOpen 
         *            the percent open 
         */ 
 public void transformCanvas(Canvas canvas, float percentOpen);  
    }  
 
 /** 
     * Instantiates a new SlidingMenu. 
     *  
     * @param context 
     *            the associated Context 
     */ 
 public SlidingMenu(Context context) {  
 this(context, null);  
    }  
 
 /** 
     * Instantiates a new SlidingMenu and attach to Activity. 
     *  
     * @param activity 
     *            the activity to attach slidingmenu 
     * @param slideStyle 
     *            the slidingmenu style 
     */ 
 public SlidingMenu(Activity activity, int slideStyle) {  
 this(activity, null);  
 this.attachToActivity(activity, slideStyle);  
    }  
 
 /** 
     * Instantiates a new SlidingMenu. 
     *  
     * @param context 
     *            the associated Context 
     * @param attrs 
     *            the attrs 
     */ 
 public SlidingMenu(Context context, AttributeSet attrs) {  
 this(context, attrs, 0);  
    }  
 
 /** 
     * Instantiates a new SlidingMenu. 
     *  
     * @param context 
     *            the associated Context 
     * @param attrs 
     *            the attrs 
     * @param defStyle 
     *            the def style 
     */ 
 public SlidingMenu(Context context, AttributeSet attrs, int defStyle) {  
 super(context, attrs, defStyle);  
 /** SlidingMenu是一个RelativeLayout，这里把背景图ImageView添加到RelativeLayout的最底层。*/ 
        LayoutParams backgroundParams = new LayoutParams(  
                LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);  
        mViewBackground = new ImageView(context);  
        mViewBackground.setScaleType(ImageView.ScaleType.CENTER_CROP);  
        addView(mViewBackground, backgroundParams);  
 
                LayoutParams behindParams = new LayoutParams(LayoutParams.MATCH_PARENT,  
                LayoutParams.MATCH_PARENT);  
        mViewBehind = new CustomViewBehind(context);  
        addView(mViewBehind, behindParams);  
        LayoutParams aboveParams = new LayoutParams(LayoutParams.MATCH_PARENT,  
                LayoutParams.MATCH_PARENT);  
        mViewAbove = new CustomViewAbove(context);  
        addView(mViewAbove, aboveParams);  
 // register the CustomViewBehind with the CustomViewAbove 
        mViewAbove.setCustomViewBehind(mViewBehind);  
        mViewBehind.setCustomViewAbove(mViewAbove);  
        mViewAbove.setOnPageChangeListener(new OnPageChangeListener() {  
 public static final int POSITION_OPEN = 0;  
 public static final int POSITION_CLOSE = 1;  
 public static final int POSITION_SECONDARY_OPEN = 2;  
 
 public void onPageScrolled(int position, float positionOffset,  
 int positionOffsetPixels) {  
            }  
 
 public void onPageSelected(int position) {  
 if (position == POSITION_OPEN && mOpenListener != null) {  
                    mOpenListener.onOpen();  
                } else if (position == POSITION_CLOSE && mCloseListener != null) {  
                    mCloseListener.onClose();  
                } else if (position == POSITION_SECONDARY_OPEN  
                        && mSecondaryOpenListner != null) {  
                    mSecondaryOpenListner.onOpen();  
                }  
            }  
        });  
 
 // now style everything! 
        TypedArray ta = context.obtainStyledAttributes(attrs,  
                R.styleable.SlidingMenu);  
 // set the above and behind views if defined in xml 
 int mode = ta.getInt(R.styleable.SlidingMenu_mode, LEFT);  
        setMode(mode);  
 int viewAbove = ta.getResourceId(R.styleable.SlidingMenu_viewAbove, -1);  
 if (viewAbove != -1) {  
            setContent(viewAbove);  
        } else {  
            setContent(new FrameLayout(context));  
        }  
 int viewBehind = ta.getResourceId(R.styleable.SlidingMenu_viewBehind,  
                -1);  
 if (viewBehind != -1) {  
            setMenu(viewBehind);  
        } else {  
            setMenu(new FrameLayout(context));  
        }  
 int touchModeAbove = ta.getInt(R.styleable.SlidingMenu_touchModeAbove,  
                TOUCHMODE_MARGIN);  
        setTouchModeAbove(touchModeAbove);  
 int touchModeBehind = ta.getInt(  
                R.styleable.SlidingMenu_touchModeBehind, TOUCHMODE_MARGIN);  
        setTouchModeBehind(touchModeBehind);  
 
 int offsetBehind = (int) ta.getDimension(  
                R.styleable.SlidingMenu_behindOffset, -1);  
 int widthBehind = (int) ta.getDimension(  
                R.styleable.SlidingMenu_behindWidth, -1);  
 if (offsetBehind != -1 && widthBehind != -1)  
 throw new IllegalStateException(  
 "Cannot set both behindOffset and behindWidth for a SlidingMenu");  
 else if (offsetBehind != -1)  
            setBehindOffset(offsetBehind);  
 else if (widthBehind != -1)  
            setBehindWidth(widthBehind);  
 else 
            setBehindOffset(0);  
 float scrollOffsetBehind = ta.getFloat(  
                R.styleable.SlidingMenu_behindScrollScale, 0.33f);  
        setBehindScrollScale(scrollOffsetBehind);  
 int shadowRes = ta.getResourceId(  
                R.styleable.SlidingMenu_shadowDrawable, -1);  
 if (shadowRes != -1) {  
            setShadowDrawable(shadowRes);  
        }  
 int shadowWidth = (int) ta.getDimension(  
                R.styleable.SlidingMenu_shadowWidth, 0);  
        setShadowWidth(shadowWidth);  
 boolean fadeEnabled = ta.getBoolean(  
                R.styleable.SlidingMenu_fadeEnabled, true);  
        setFadeEnabled(fadeEnabled);  
 float fadeDeg = ta.getFloat(R.styleable.SlidingMenu_fadeDegree, 0.33f);  
        setFadeDegree(fadeDeg);  
 boolean selectorEnabled = ta.getBoolean(  
                R.styleable.SlidingMenu_selectorEnabled, false);  
        setSelectorEnabled(selectorEnabled);  
 int selectorRes = ta.getResourceId(  
                R.styleable.SlidingMenu_selectorDrawable, -1);  
 if (selectorRes != -1)  
            setSelectorDrawable(selectorRes);  
        ta.recycle();  
    }  
 
 /** 
     * Attaches the SlidingMenu to an entire Activity 
     *  
     * @param activity 
     *            the Activity 
     * @param slideStyle 
     *            either SLIDING_CONTENT or SLIDING_WINDOW 
     */ 
 public void attachToActivity(Activity activity, int slideStyle) {  
        attachToActivity(activity, slideStyle, false);  
    }  
 
 /** 
     * Attaches the SlidingMenu to an entire Activity 
     *  
     * @param activity 
     *            the Activity 
     * @param slideStyle 
     *            either SLIDING_CONTENT or SLIDING_WINDOW 
     * @param actionbarOverlay 
     *            whether or not the ActionBar is overlaid 
     */ 
 public void attachToActivity(Activity activity, int slideStyle,  
 boolean actionbarOverlay) {  
 if (slideStyle != SLIDING_WINDOW && slideStyle != SLIDING_CONTENT)  
 throw new IllegalArgumentException(  
 "slideStyle must be either SLIDING_WINDOW or SLIDING_CONTENT");  
 
 if (getParent() != null)  
 throw new IllegalStateException(  
 "This SlidingMenu appears to already be attached");  
 
 // get the window background 
        TypedArray a = activity.getTheme().obtainStyledAttributes(  
 new int[] { android.R.attr.windowBackground });  
 int background = a.getResourceId(0, 0);  
        a.recycle();  
 
 switch (slideStyle) {  
 case SLIDING_WINDOW:  
            mActionbarOverlay = false;  
            ViewGroup decor = (ViewGroup) activity.getWindow().getDecorView();  
            ViewGroup decorChild = (ViewGroup) decor.getChildAt(0);  
 // save ActionBar themes that have transparent assets 
            decorChild.setBackgroundResource(background);  
            decor.removeView(decorChild);  
            decor.addView(this);  
            setContent(decorChild);  
 break;  
 case SLIDING_CONTENT:  
            mActionbarOverlay = actionbarOverlay;  
 // take the above view out of 
            ViewGroup contentParent = (ViewGroup) activity  
                    .findViewById(android.R.id.content);  
            View content = contentParent.getChildAt(0);  
            contentParent.removeView(content);  
            contentParent.addView(this);  
            setContent(content);  
 // save people from having transparent backgrounds 
 if (content.getBackground() == null)  
                content.setBackgroundResource(background);  
 break;  
        }  
    }  
 
 /** 
     * Set the above view content from a layout resource. The resource will be 
     * inflated, adding all top-level views to the above view. 
     *  
     * @param res 
     *            the new content 
     */ 
 public void setContent(int res) {  
        setContent(LayoutInflater.from(getContext()).inflate(res, null));  
    }  
 
 /** 
     * Set the above view content to the given View. 
     *  
     * @param view 
     *            The desired content to display. 
     */ 
 public void setContent(View view) {  
        mViewAbove.setContent(view);  
        showContent();  
    }  
 
 /** 
     * 设置背景图片 
     *  
     * @param resid 
     */ 
 public void setBackgroundImage(int resid) {  
        mViewBackground.setBackgroundResource(resid);  
    }  
 
 /** 
     * Retrieves the current content. 
     *  
     * @return the current content 
     */ 
 public View getContent() {  
 return mViewAbove.getContent();  
    }  
 
 /** 
     * Set the behind view (menu) content from a layout resource. The resource 
     * will be inflated, adding all top-level views to the behind view. 
     *  
     * @param res 
     *            the new content 
     */ 
 public void setMenu(int res) {  
        setMenu(LayoutInflater.from(getContext()).inflate(res, null));  
    }  
 
 /** 
     * Set the behind view (menu) content to the given View. 
     *  
     * @param view 
     *            The desired content to display. 
     */ 
 public void setMenu(View v) {  
        mViewBehind.setContent(v);  
    }  
 
 /** 
     * Retrieves the main menu. 
     *  
     * @return the main menu 
     */ 
 public View getMenu() {  
 return mViewBehind.getContent();  
    }  
 
 /** 
     * Set the secondary behind view (right menu) content from a layout 
     * resource. The resource will be inflated, adding all top-level views to 
     * the behind view. 
     *  
     * @param res 
     *            the new content 
     */ 
 public void setSecondaryMenu(int res) {  
        setSecondaryMenu(LayoutInflater.from(getContext()).inflate(res, null));  
    }  
 
 /** 
     * Set the secondary behind view (right menu) content to the given View. 
     *  
     * @param view 
     *            The desired content to display. 
     */ 
 public void setSecondaryMenu(View v) {  
        mViewBehind.setSecondaryContent(v);  
 // mViewBehind.invalidate(); 
    }  
 
 /** 
     * Retrieves the current secondary menu (right). 
     *  
     * @return the current menu 
     */ 
 public View getSecondaryMenu() {  
 return mViewBehind.getSecondaryContent();  
    }  
 
 /** 
     * Sets the sliding enabled. 
     *  
     * @param b 
     *            true to enable sliding, false to disable it. 
     */ 
 public void setSlidingEnabled(boolean b) {  
        mViewAbove.setSlidingEnabled(b);  
    }  
 
 /** 
     * Checks if is sliding enabled. 
     *  
     * @return true, if is sliding enabled 
     */ 
 public boolean isSlidingEnabled() {  
 return mViewAbove.isSlidingEnabled();  
    }  
 
 /** 
     * Sets which side the SlidingMenu should appear on. 
     *  
     * @param mode 
     *            must be either SlidingMenu.LEFT or SlidingMenu.RIGHT 
     */ 
 public void setMode(int mode) {  
 if (mode != LEFT && mode != RIGHT && mode != LEFT_RIGHT) {  
 throw new IllegalStateException(  
 "SlidingMenu mode must be LEFT, RIGHT, or LEFT_RIGHT");  
        }  
        mViewBehind.setMode(mode);  
    }  
 
 /** 
     * Returns the current side that the SlidingMenu is on. 
     *  
     * @return the current mode, either SlidingMenu.LEFT or SlidingMenu.RIGHT 
     */ 
 public int getMode() {  
 return mViewBehind.getMode();  
    }  
 
 /** 
     * Sets whether or not the SlidingMenu is in static mode (i.e. nothing is 
     * moving and everything is showing) 
     *  
     * @param b 
     *            true to set static mode, false to disable static mode. 
     */ 
 public void setStatic(boolean b) {  
 if (b) {  
            setSlidingEnabled(false);  
            mViewAbove.setCustomViewBehind(null);  
            mViewAbove.setCurrentItem(1);  
 // mViewBehind.setCurrentItem(0); 
        } else {  
            mViewAbove.setCurrentItem(1);  
 // mViewBehind.setCurrentItem(1); 
            mViewAbove.setCustomViewBehind(mViewBehind);  
            setSlidingEnabled(true);  
        }  
    }  
 
 /** 
     * Opens the menu and shows the menu view. 
     */ 
 public void showMenu() {  
        showMenu(true);  
    }  
 
 /** 
     * Opens the menu and shows the menu view. 
     *  
     * @param animate 
     *            true to animate the transition, false to ignore animation 
     */ 
 public void showMenu(boolean animate) {  
        mViewAbove.setCurrentItem(0, animate);  
    }  
 
 /** 
     * Opens the menu and shows the secondary menu view. Will default to the 
     * regular menu if there is only one. 
     */ 
 public void showSecondaryMenu() {  
        showSecondaryMenu(true);  
    }  
 
 /** 
     * Opens the menu and shows the secondary (right) menu view. Will default to 
     * the regular menu if there is only one. 
     *  
     * @param animate 
     *            true to animate the transition, false to ignore animation 
     */ 
 public void showSecondaryMenu(boolean animate) {  
        mViewAbove.setCurrentItem(2, animate);  
    }  
 
 /** 
     * Closes the menu and shows the above view. 
     */ 
 public void showContent() {  
        showContent(true);  
    }  
 
 /** 
     * Closes the menu and shows the above view. 
     *  
     * @param animate 
     *            true to animate the transition, false to ignore animation 
     */ 
 public void showContent(boolean animate) {  
        mViewAbove.setCurrentItem(1, animate);  
    }  
 
 /** 
     * Toggle the SlidingMenu. If it is open, it will be closed, and vice versa. 
     */ 
 public void toggle() {  
        toggle(true);  
    }  
 
 /** 
     * Toggle the SlidingMenu. If it is open, it will be closed, and vice versa. 
     *  
     * @param animate 
     *            true to animate the transition, false to ignore animation 
     */ 
 public void toggle(boolean animate) {  
 if (isMenuShowing()) {  
            showContent(animate);  
        } else {  
            showMenu(animate);  
        }  
    }  
 
 /** 
     * Checks if is the behind view showing. 
     *  
     * @return Whether or not the behind view is showing 
     */ 
 public boolean isMenuShowing() {  
 return mViewAbove.getCurrentItem() == 0 
                || mViewAbove.getCurrentItem() == 2;  
    }  
 
 /** 
     * Checks if is the behind view showing. 
     *  
     * @return Whether or not the behind view is showing 
     */ 
 public boolean isSecondaryMenuShowing() {  
 return mViewAbove.getCurrentItem() == 2;  
    }  
 
 /** 
     * Gets the behind offset. 
     *  
     * @return The margin on the right of the screen that the behind view 
     *         scrolls to 
     */ 
 public int getBehindOffset() {  
 return ((RelativeLayout.LayoutParams) mViewBehind.getLayoutParams()).rightMargin;  
    }  
 
 /** 
     * Sets the behind offset. 
     *  
     * @param i 
     *            The margin, in pixels, on the right of the screen that the 
     *            behind view scrolls to. 
     */ 
 public void setBehindOffset(int i) {  
 // RelativeLayout.LayoutParams params = 
 // ((RelativeLayout.LayoutParams)mViewBehind.getLayoutParams()); 
 // int bottom = params.bottomMargin; 
 // int top = params.topMargin; 
 // int left = params.leftMargin; 
 // params.setMargins(left, top, i, bottom); 
        mViewBehind.setWidthOffset(i);  
    }  
 
 /** 
     * Sets the behind offset. 
     *  
     * @param resID 
     *            The dimension resource id to be set as the behind offset. The 
     *            menu, when open, will leave this width margin on the right of 
     *            the screen. 
     */ 
 public void setBehindOffsetRes(int resID) {  
 int i = (int) getContext().getResources().getDimension(resID);  
        setBehindOffset(i);  
    }  
 
 /** 
     * Sets the above offset. 
     *  
     * @param i 
     *            the new above offset, in pixels 
     */ 
 public void setAboveOffset(int i) {  
        mViewAbove.setAboveOffset(i);  
    }  
 
 /** 
     * Sets the above offset. 
     *  
     * @param resID 
     *            The dimension resource id to be set as the above offset. 
     */ 
 public void setAboveOffsetRes(int resID) {  
 int i = (int) getContext().getResources().getDimension(resID);  
        setAboveOffset(i);  
    }  
 
 /** 
     * Sets the behind width. 
     *  
     * @param i 
     *            The width the Sliding Menu will open to, in pixels 
     */ 
 @SuppressWarnings("deprecation")  
 public void setBehindWidth(int i) {  
 int width;  
        Display display = ((WindowManager) getContext().getSystemService(  
                Context.WINDOW_SERVICE)).getDefaultDisplay();  
 try {  
            Class<?> cls = Display.class;  
            Class<?>[] parameterTypes = { Point.class };  
            Point parameter = new Point();  
            Method method = cls.getMethod("getSize", parameterTypes);  
            method.invoke(display, parameter);  
            width = parameter.x;  
        } catch (Exception e) {  
            width = display.getWidth();  
        }  
        setBehindOffset(width - i);  
    }  
 
 /** 
     * Sets the behind width. 
     *  
     * @param res 
     *            The dimension resource id to be set as the behind width 
     *            offset. The menu, when open, will open this wide. 
     */ 
 public void setBehindWidthRes(int res) {  
 int i = (int) getContext().getResources().getDimension(res);  
        setBehindWidth(i);  
    }  
 
 /** 
     * Gets the behind scroll scale. 
     *  
     * @return The scale of the parallax scroll 
     */ 
 public float getBehindScrollScale() {  
 return mViewBehind.getScrollScale();  
    }  
 
 /** 
     * Gets the touch mode margin threshold 
     *  
     * @return the touch mode margin threshold 
     */ 
 public int getTouchmodeMarginThreshold() {  
 return mViewBehind.getMarginThreshold();  
    }  
 
 /** 
     * Set the touch mode margin threshold 
     *  
     * @param touchmodeMarginThreshold 
     */ 
 public void setTouchmodeMarginThreshold(int touchmodeMarginThreshold) {  
        mViewBehind.setMarginThreshold(touchmodeMarginThreshold);  
    }  
 
 /** 
     * Sets the behind scroll scale. 
     *  
     * @param f 
     *            The scale of the parallax scroll (i.e. 1.0f scrolls 1 pixel 
     *            for every 1 pixel that the above view scrolls and 0.0f scrolls 
     *            0 pixels) 
     */ 
 public void setBehindScrollScale(float f) {  
 if (f < 0 && f > 1)  
 throw new IllegalStateException(  
 "ScrollScale must be between 0 and 1");  
        mViewBehind.setScrollScale(f);  
    }  
 
 /** 
     * Sets the behind canvas transformer. 
     *  
     * @param t 
     *            the new behind canvas transformer 
     */ 
 public void setBehindCanvasTransformer(CanvasTransformer t) {  
        mViewBehind.setCanvasTransformer(t);  
    }  
 
 /** 
     * 设置右侧视图的转场动画 
     *  
     * @param t 
     *            the new above canvas transformer 
     */ 
 public void setAboveCanvasTransformer(CanvasTransformer t) {  
        mViewAbove.setCanvasTransformer(t);  
    }  
 
 /** 
     * Gets the touch mode above. 
     *  
     * @return the touch mode above 
     */ 
 public int getTouchModeAbove() {  
 return mViewAbove.getTouchMode();  
    }  
 
 /** 
     * Controls whether the SlidingMenu can be opened with a swipe gesture. 
     * Options are {@link #TOUCHMODE_MARGIN TOUCHMODE_MARGIN}, 
     * {@link #TOUCHMODE_FULLSCREEN TOUCHMODE_FULLSCREEN}, or 
     * {@link #TOUCHMODE_NONE TOUCHMODE_NONE} 
     *  
     * @param i 
     *            the new touch mode 
     */ 
 public void setTouchModeAbove(int i) {  
 if (i != TOUCHMODE_FULLSCREEN && i != TOUCHMODE_MARGIN  
                && i != TOUCHMODE_NONE) {  
 throw new IllegalStateException(  
 "TouchMode must be set to either" 
                            + "TOUCHMODE_FULLSCREEN or TOUCHMODE_MARGIN or TOUCHMODE_NONE.");  
        }  
        mViewAbove.setTouchMode(i);  
    }  
 
 /** 
     * Controls whether the SlidingMenu can be opened with a swipe gesture. 
     * Options are {@link #TOUCHMODE_MARGIN TOUCHMODE_MARGIN}, 
     * {@link #TOUCHMODE_FULLSCREEN TOUCHMODE_FULLSCREEN}, or 
     * {@link #TOUCHMODE_NONE TOUCHMODE_NONE} 
     *  
     * @param i 
     *            the new touch mode 
     */ 
 public void setTouchModeBehind(int i) {  
 if (i != TOUCHMODE_FULLSCREEN && i != TOUCHMODE_MARGIN  
                && i != TOUCHMODE_NONE) {  
 throw new IllegalStateException(  
 "TouchMode must be set to either" 
                            + "TOUCHMODE_FULLSCREEN or TOUCHMODE_MARGIN or TOUCHMODE_NONE.");  
        }  
        mViewBehind.setTouchMode(i);  
    }  
 
 /** 
     * Sets the shadow drawable. 
     *  
     * @param resId 
     *            the resource ID of the new shadow drawable 
     */ 
 public void setShadowDrawable(int resId) {  
        setShadowDrawable(getContext().getResources().getDrawable(resId));  
    }  
 
 /** 
     * Sets the shadow drawable. 
     *  
     * @param d 
     *            the new shadow drawable 
     */ 
 public void setShadowDrawable(Drawable d) {  
        mViewBehind.setShadowDrawable(d);  
    }  
 
 /** 
     * Sets the secondary (right) shadow drawable. 
     *  
     * @param resId 
     *            the resource ID of the new shadow drawable 
     */ 
 public void setSecondaryShadowDrawable(int resId) {  
        setSecondaryShadowDrawable(getContext().getResources().getDrawable(  
                resId));  
    }  
 
 /** 
     * Sets the secondary (right) shadow drawable. 
     *  
     * @param d 
     *            the new shadow drawable 
     */ 
 public void setSecondaryShadowDrawable(Drawable d) {  
        mViewBehind.setSecondaryShadowDrawable(d);  
    }  
 
 /** 
     * Sets the shadow width. 
     *  
     * @param resId 
     *            The dimension resource id to be set as the shadow width. 
     */ 
 public void setShadowWidthRes(int resId) {  
        setShadowWidth((int) getResources().getDimension(resId));  
    }  
 
 /** 
     * Sets the shadow width. 
     *  
     * @param pixels 
     *            the new shadow width, in pixels 
     */ 
 public void setShadowWidth(int pixels) {  
        mViewBehind.setShadowWidth(pixels);  
    }  
 
 /** 
     * Enables or disables the SlidingMenu's fade in and out 
     *  
     * @param b 
     *            true to enable fade, false to disable it 
     */ 
 public void setFadeEnabled(boolean b) {  
        mViewBehind.setFadeEnabled(b);  
    }  
 
 /** 
     * Sets how much the SlidingMenu fades in and out. Fade must be enabled, see 
     * {@link #setFadeEnabled(boolean) setFadeEnabled(boolean)} 
     *  
     * @param f 
     *            the new fade degree, between 0.0f and 1.0f 
     */ 
 public void setFadeDegree(float f) {  
        mViewBehind.setFadeDegree(f);  
    }  
 
 /** 
     * Enables or disables whether the selector is drawn 
     *  
     * @param b 
     *            true to draw the selector, false to not draw the selector 
     */ 
 public void setSelectorEnabled(boolean b) {  
        mViewBehind.setSelectorEnabled(true);  
    }  
 
 /** 
     * Sets the selected view. The selector will be drawn here 
     *  
     * @param v 
     *            the new selected view 
     */ 
 public void setSelectedView(View v) {  
        mViewBehind.setSelectedView(v);  
    }  
 
 /** 
     * Sets the selector drawable. 
     *  
     * @param res 
     *            a resource ID for the selector drawable 
     */ 
 public void setSelectorDrawable(int res) {  
        mViewBehind.setSelectorBitmap(BitmapFactory.decodeResource(  
                getResources(), res));  
    }  
 
 /** 
     * Sets the selector drawable. 
     *  
     * @param b 
     *            the new selector bitmap 
     */ 
 public void setSelectorBitmap(Bitmap b) {  
        mViewBehind.setSelectorBitmap(b);  
    }  
 
 /** 
     * Add a View ignored by the Touch Down event when mode is Fullscreen 
     *  
     * @param v 
     *            a view to be ignored 
     */ 
 public void addIgnoredView(View v) {  
        mViewAbove.addIgnoredView(v);  
    }  
 
 /** 
     * Remove a View ignored by the Touch Down event when mode is Fullscreen 
     *  
     * @param v 
     *            a view not wanted to be ignored anymore 
     */ 
 public void removeIgnoredView(View v) {  
        mViewAbove.removeIgnoredView(v);  
    }  
 
 /** 
     * Clear the list of Views ignored by the Touch Down event when mode is 
     * Fullscreen 
     */ 
 public void clearIgnoredViews() {  
        mViewAbove.clearIgnoredViews();  
    }  
 
 /** 
     * Sets the OnOpenListener. {@link OnOpenListener#onOpen() 
     * OnOpenListener.onOpen()} will be called when the SlidingMenu is opened 
     *  
     * @param listener 
     *            the new OnOpenListener 
     */ 
 public void setOnOpenListener(OnOpenListener listener) {  
 // mViewAbove.setOnOpenListener(listener); 
        mOpenListener = listener;  
    }  
 
 /** 
     * Sets the OnOpenListner for secondary menu {@link OnOpenListener#onOpen() 
     * OnOpenListener.onOpen()} will be called when the secondary SlidingMenu is 
     * opened 
     *  
     * @param listener 
     *            the new OnOpenListener 
     */ 
 
 public void setSecondaryOnOpenListner(OnOpenListener listener) {  
        mSecondaryOpenListner = listener;  
    }  
 
 /** 
     * Sets the OnCloseListener. {@link OnCloseListener#onClose() 
     * OnCloseListener.onClose()} will be called when any one of the SlidingMenu 
     * is closed 
     *  
     * @param listener 
     *            the new setOnCloseListener 
     */ 
 public void setOnCloseListener(OnCloseListener listener) {  
 // mViewAbove.setOnCloseListener(listener); 
        mCloseListener = listener;  
    }  
 
 /** 
     * Sets the OnOpenedListener. {@link OnOpenedListener#onOpened() 
     * OnOpenedListener.onOpened()} will be called after the SlidingMenu is 
     * opened 
     *  
     * @param listener 
     *            the new OnOpenedListener 
     */ 
 public void setOnOpenedListener(OnOpenedListener listener) {  
        mViewAbove.setOnOpenedListener(listener);  
    }  
 
 /** 
     * Sets the OnClosedListener. {@link OnClosedListener#onClosed() 
     * OnClosedListener.onClosed()} will be called after the SlidingMenu is 
     * closed 
     *  
     * @param listener 
     *            the new OnClosedListener 
     */ 
 public void setOnClosedListener(OnClosedListener listener) {  
        mViewAbove.setOnClosedListener(listener);  
    }  
 
 public static class SavedState extends BaseSavedState {  
 
 private final int mItem;  
 
 public SavedState(Parcelable superState, int item) {  
 super(superState);  
            mItem = item;  
        }  
 
 private SavedState(Parcel in) {  
 super(in);  
            mItem = in.readInt();  
        }  
 
 public int getItem() {  
 return mItem;  
        }  
 
 /* 
         * (non-Javadoc) 
         *  
         * @see android.view.AbsSavedState#writeToParcel(android.os.Parcel, int) 
         */ 
 public void writeToParcel(Parcel out, int flags) {  
 super.writeToParcel(out, flags);  
            out.writeInt(mItem);  
        }  
 
 public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {  
 public SavedState createFromParcel(Parcel in) {  
 return new SavedState(in);  
            }  
 
 public SavedState[] newArray(int size) {  
 return new SavedState[size];  
            }  
        };  
 
    }  
 
 /* 
     * (non-Javadoc) 
     *  
     * @see android.view.View#onSaveInstanceState() 
     */ 
 @Override 
 protected Parcelable onSaveInstanceState() {  
        Parcelable superState = super.onSaveInstanceState();  
        SavedState ss = new SavedState(superState, mViewAbove.getCurrentItem());  
 return ss;  
    }  
 
 /* 
     * (non-Javadoc) 
     *  
     * @see android.view.View#onRestoreInstanceState(android.os.Parcelable) 
     */ 
 @Override 
 protected void onRestoreInstanceState(Parcelable state) {  
        SavedState ss = (SavedState) state;  
 super.onRestoreInstanceState(ss.getSuperState());  
        mViewAbove.setCurrentItem(ss.getItem());  
    }  
 
 /* 
     * (non-Javadoc) 
     *  
     * @see android.view.ViewGroup#fitSystemWindows(android.graphics.Rect) 
     */ 
 @SuppressLint("NewApi")  
 @Override 
 protected boolean fitSystemWindows(Rect insets) {  
 int leftPadding = insets.left;  
 int rightPadding = insets.right;  
 int topPadding = insets.top;  
 int bottomPadding = insets.bottom;  
 if (!mActionbarOverlay) {  
            Log.v(TAG, "setting padding!");  
            setPadding(leftPadding, topPadding, rightPadding, bottomPadding);  
        }  
 return true;  
    }  
 
 @TargetApi(Build.VERSION_CODES.HONEYCOMB)  
 public void manageLayers(float percentOpen) {  
 if (Build.VERSION.SDK_INT < 11)  
 return;  
 
 boolean layer = percentOpen > 0.0f && percentOpen < 1.0f;  
 final int layerType = layer ? View.LAYER_TYPE_HARDWARE  
                : View.LAYER_TYPE_NONE;  
 
 if (layerType != getContent().getLayerType()) {  
            getHandler().post(new Runnable() {  
 public void run() {  
                    Log.v(TAG, "changing layerType. hardware? " 
                            + (layerType == View.LAYER_TYPE_HARDWARE));  
                    getContent().setLayerType(layerType, null);  
                    getMenu().setLayerType(layerType, null);  
 if (getSecondaryMenu() != null) {  
                        getSecondaryMenu().setLayerType(layerType, null);  
                    }  
                }  
            });  
        }  
    }  
 
}  

public class CustomViewAbove extends ViewGroup {  
 
 private static final String TAG = "CustomViewAbove";  
 private static final boolean DEBUG = false;  
 
 private static final boolean USE_CACHE = false;  
 
 private static final int MAX_SETTLE_DURATION = 600; // ms 
 private static final int MIN_DISTANCE_FOR_FLING = 25; // dips 
 
 private static final Interpolator sInterpolator = new Interpolator() {  
 public float getInterpolation(float t) {  
            t -= 1.0f;  
 return t * t * t * t * t + 1.0f;  
        }  
    };  
 
 private View mContent;  
 
 private int mCurItem;  
 private Scroller mScroller;  
 
 private boolean mScrollingCacheEnabled;  
 
 private boolean mScrolling;  
 
 private boolean mIsBeingDragged;  
 private boolean mIsUnableToDrag;  
 private int mTouchSlop;  
 private float mInitialMotionX;  
 /** 
     * Position of the last motion event. 
     */ 
 private float mLastMotionX;  
 private float mLastMotionY;  
 /** 
     * ID of the active pointer. This is used to retain consistency during 
     * drags/flings if multiple pointers are used. 
     */ 
 protected int mActivePointerId = INVALID_POINTER;  
 /** 
     * Sentinel value for no current active pointer. 
     * Used by {@link #mActivePointerId}. 
     */ 
 private static final int INVALID_POINTER = -1;  
 /** 保存转场动画的变量*/ 
 private CanvasTransformer mTransformer;  
 
 /** 
     * Determines speed during touch scrolling 
     */ 
 protected VelocityTracker mVelocityTracker;  
 private int mMinimumVelocity;  
 protected int mMaximumVelocity;  
 private int mFlingDistance;  
 
 private CustomViewBehind mViewBehind;  
 //  private int mMode; 
 private boolean mEnabled = true;  
 
 private OnPageChangeListener mOnPageChangeListener;  
 private OnPageChangeListener mInternalPageChangeListener;  
 
 //  private OnCloseListener mCloseListener; 
 //  private OnOpenListener mOpenListener; 
 private OnClosedListener mClosedListener;  
 private OnOpenedListener mOpenedListener;  
 
 private List<View> mIgnoredViews = new ArrayList<View>();  
 
 //  private int mScrollState = SCROLL_STATE_IDLE; 
 
 /** 
     * Callback interface for responding to changing state of the selected page. 
     */ 
 public interface OnPageChangeListener {  
 
 /** 
         * This method will be invoked when the current page is scrolled, either as part 
         * of a programmatically initiated smooth scroll or a user initiated touch scroll. 
         * 
         * @param position Position index of the first page currently being displayed. 
         *                 Page position+1 will be visible if positionOffset is nonzero. 
         * @param positionOffset Value from [0, 1) indicating the offset from the page at position. 
         * @param positionOffsetPixels Value in pixels indicating the offset from position. 
         */ 
 public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels);  
 
 /** 
         * This method will be invoked when a new page becomes selected. Animation is not 
         * necessarily complete. 
         * 
         * @param position Position index of the new selected page. 
         */ 
 public void onPageSelected(int position);  
 
    }  
 
 /** 
     * Simple implementation of the {@link OnPageChangeListener} interface with stub 
     * implementations of each method. Extend this if you do not intend to override 
     * every method of {@link OnPageChangeListener}. 
     */ 
 public static class SimpleOnPageChangeListener implements OnPageChangeListener {  
 
 public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {  
 // This space for rent 
        }  
 
 public void onPageSelected(int position) {  
 // This space for rent 
        }  
 
 public void onPageScrollStateChanged(int state) {  
 // This space for rent 
        }  
 
    }  
 
 public CustomViewAbove(Context context) {  
 this(context, null);  
    }  
 
 public CustomViewAbove(Context context, AttributeSet attrs) {  
 super(context, attrs);  
        initCustomViewAbove();  
    }  
 
 void initCustomViewAbove() {  
        setWillNotDraw(false);  
        setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);  
        setFocusable(true);  
 final Context context = getContext();  
        mScroller = new Scroller(context, sInterpolator);  
 final ViewConfiguration configuration = ViewConfiguration.get(context);  
        mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration);  
        mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();  
        mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();  
        setInternalPageChangeListener(new SimpleOnPageChangeListener() {  
 public void onPageSelected(int position) {  
 if (mViewBehind != null) {  
 switch (position) {  
 case 0:  
 case 2:  
                        mViewBehind.setChildrenEnabled(true);  
 break;  
 case 1:  
                        mViewBehind.setChildrenEnabled(false);  
 break;  
                    }  
                }  
            }  
        });  
 
 final float density = context.getResources().getDisplayMetrics().density;  
        mFlingDistance = (int) (MIN_DISTANCE_FOR_FLING * density);  
    }  
 
 /** 
     * Set the currently selected page. If the CustomViewPager has already been through its first 
     * layout there will be a smooth animated transition between the current item and the 
     * specified item. 
     * 
     * @param item Item index to select 
     */ 
 public void setCurrentItem(int item) {  
        setCurrentItemInternal(item, true, false);  
    }  
 
 /** 
     * Set the currently selected page. 
     * 
     * @param item Item index to select 
     * @param smoothScroll True to smoothly scroll to the new item, false to transition immediately 
     */ 
 public void setCurrentItem(int item, boolean smoothScroll) {  
        setCurrentItemInternal(item, smoothScroll, false);  
    }  
 
 public int getCurrentItem() {  
 return mCurItem;  
    }  
 
 void setCurrentItemInternal(int item, boolean smoothScroll, boolean always) {  
        setCurrentItemInternal(item, smoothScroll, always, 0);  
    }  
 
 void setCurrentItemInternal(int item, boolean smoothScroll, boolean always, int velocity) {  
 if (!always && mCurItem == item) {  
            setScrollingCacheEnabled(false);  
 return;  
        }  
 
        item = mViewBehind.getMenuPage(item);  
 
 final boolean dispatchSelected = mCurItem != item;  
        mCurItem = item;  
 final int destX = getDestScrollX(mCurItem);  
 if (dispatchSelected && mOnPageChangeListener != null) {  
            mOnPageChangeListener.onPageSelected(item);  
        }  
 if (dispatchSelected && mInternalPageChangeListener != null) {  
            mInternalPageChangeListener.onPageSelected(item);  
        }  
 if (smoothScroll) {  
            smoothScrollTo(destX, 0, velocity);  
        } else {  
            completeScroll();  
            scrollTo(destX, 0);  
        }  
    }  
 
 /** 
     * Set a listener that will be invoked whenever the page changes or is incrementally 
     * scrolled. See {@link OnPageChangeListener}. 
     * 
     * @param listener Listener to set 
     */ 
 public void setOnPageChangeListener(OnPageChangeListener listener) {  
        mOnPageChangeListener = listener;  
    }  
 /* 
    public void setOnOpenListener(OnOpenListener l) { 
        mOpenListener = l; 
    } 
 
    public void setOnCloseListener(OnCloseListener l) { 
        mCloseListener = l; 
    } 
     */ 
 public void setOnOpenedListener(OnOpenedListener l) {  
        mOpenedListener = l;  
    }  
 
 public void setOnClosedListener(OnClosedListener l) {  
        mClosedListener = l;  
    }  
 
 /** 
     * Set a separate OnPageChangeListener for internal use by the support library. 
     * 
     * @param listener Listener to set 
     * @return The old listener that was set, if any. 
     */ 
    OnPageChangeListener setInternalPageChangeListener(OnPageChangeListener listener) {  
        OnPageChangeListener oldListener = mInternalPageChangeListener;  
        mInternalPageChangeListener = listener;  
 return oldListener;  
    }  
 
 public void addIgnoredView(View v) {  
 if (!mIgnoredViews.contains(v)) {  
            mIgnoredViews.add(v);  
        }  
    }  
 
 public void removeIgnoredView(View v) {  
        mIgnoredViews.remove(v);  
    }  
 
 public void clearIgnoredViews() {  
        mIgnoredViews.clear();  
    }  
 
 // We want the duration of the page snap animation to be influenced by the distance that 
 // the screen has to travel, however, we don't want this duration to be effected in a 
 // purely linear fashion. Instead, we use this method to moderate the effect that the distance 
 // of travel has on the overall snap duration. 
 float distanceInfluenceForSnapDuration(float f) {  
        f -= 0.5f; // center the values about 0. 
        f *= 0.3f * Math.PI / 2.0f;  
 return (float) FloatMath.sin(f);  
    }  
 
 public int getDestScrollX(int page) {  
 switch (page) {  
 case 0:  
 case 2:  
 return mViewBehind.getMenuLeft(mContent, page);  
 case 1:  
 return mContent.getLeft();  
        }  
 return 0;  
    }  
 
 private int getLeftBound() {  
 return mViewBehind.getAbsLeftBound(mContent);  
    }  
 
 private int getRightBound() {  
 return mViewBehind.getAbsRightBound(mContent);  
    }  
 
 public int getContentLeft() {  
 return mContent.getLeft() + mContent.getPaddingLeft();  
    }  
 
 public boolean isMenuOpen() {  
 return mCurItem == 0 || mCurItem == 2;  
    }  
 
 private boolean isInIgnoredView(MotionEvent ev) {  
        Rect rect = new Rect();  
 for (View v : mIgnoredViews) {  
            v.getHitRect(rect);  
 if (rect.contains((int)ev.getX(), (int)ev.getY())) return true;  
        }  
 return false;  
    }  
 
 public int getBehindWidth() {  
 if (mViewBehind == null) {  
 return 0;  
        } else {  
 return mViewBehind.getBehindWidth();  
        }  
    }  
 
 public int getChildWidth(int i) {  
 switch (i) {  
 case 0:  
 return getBehindWidth();  
 case 1:  
 return mContent.getWidth();  
 default:  
 return 0;  
        }  
    }  
 
 public boolean isSlidingEnabled() {  
 return mEnabled;  
    }  
 
 public void setSlidingEnabled(boolean b) {  
        mEnabled = b;  
    }  
 
 /** 
     * Like {@link View#scrollBy}, but scroll smoothly instead of immediately. 
     * 
     * @param x the number of pixels to scroll by on the X axis 
     * @param y the number of pixels to scroll by on the Y axis 
     */ 
 void smoothScrollTo(int x, int y) {  
        smoothScrollTo(x, y, 0);  
    }  
 
 /** 
     * Like {@link View#scrollBy}, but scroll smoothly instead of immediately. 
     * 
     * @param x the number of pixels to scroll by on the X axis 
     * @param y the number of pixels to scroll by on the Y axis 
     * @param velocity the velocity associated with a fling, if applicable. (0 otherwise) 
     */ 
 void smoothScrollTo(int x, int y, int velocity) {  
 if (getChildCount() == 0) {  
 // Nothing to do. 
            setScrollingCacheEnabled(false);  
 return;  
        }  
 int sx = getScrollX();  
 int sy = getScrollY();  
 int dx = x - sx;  
 int dy = y - sy;  
 if (dx == 0 && dy == 0) {  
            completeScroll();  
 if (isMenuOpen()) {  
 if (mOpenedListener != null)  
                    mOpenedListener.onOpened();  
            } else {  
 if (mClosedListener != null)  
                    mClosedListener.onClosed();  
            }  
 return;  
        }  
 
        setScrollingCacheEnabled(true);  
        mScrolling = true;  
 
 final int width = getBehindWidth();  
 final int halfWidth = width / 2;  
 final float distanceRatio = Math.min(1f, 1.0f * Math.abs(dx) / width);  
 final float distance = halfWidth + halfWidth *  
                distanceInfluenceForSnapDuration(distanceRatio);  
 
 int duration = 0;  
        velocity = Math.abs(velocity);  
 if (velocity > 0) {  
            duration = 4 * Math.round(1000 * Math.abs(distance / velocity));  
        } else {  
 final float pageDelta = (float) Math.abs(dx) / width;  
            duration = (int) ((pageDelta + 1) * 100);  
            duration = MAX_SETTLE_DURATION;  
        }  
        duration = Math.min(duration, MAX_SETTLE_DURATION);  
 
        mScroller.startScroll(sx, sy, dx, dy, duration);  
        invalidate();  
    }  
 
 public void setContent(View v) {  
 if (mContent != null)   
 this.removeView(mContent);  
        mContent = v;  
        addView(mContent);  
    }  
 
 public View getContent() {  
 return mContent;  
    }  
 
 public void setCustomViewBehind(CustomViewBehind cvb) {  
        mViewBehind = cvb;  
    }  
 
 @Override 
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
 
 int width = getDefaultSize(0, widthMeasureSpec);  
 int height = getDefaultSize(0, heightMeasureSpec);  
        setMeasuredDimension(width, height);  
 
 final int contentWidth = getChildMeasureSpec(widthMeasureSpec, 0, width);  
 final int contentHeight = getChildMeasureSpec(heightMeasureSpec, 0, height);  
        mContent.measure(contentWidth, contentHeight);  
    }  
 
 @Override 
 protected void onSizeChanged(int w, int h, int oldw, int oldh) {  
 super.onSizeChanged(w, h, oldw, oldh);  
 // Make sure scroll position is set correctly. 
 if (w != oldw) {  
 // [ChrisJ] - This fixes the onConfiguration change for orientation issue.. 
 // maybe worth having a look why the recomputeScroll pos is screwing 
 // up? 
            completeScroll();  
            scrollTo(getDestScrollX(mCurItem), getScrollY());  
        }  
    }  
 
 @Override 
 protected void onLayout(boolean changed, int l, int t, int r, int b) {  
 final int width = r - l;  
 final int height = b - t;  
        mContent.layout(0, 0, width, height);  
    }  
 
 public void setAboveOffset(int i) {  
 //      RelativeLayout.LayoutParams params = ((RelativeLayout.LayoutParams)mContent.getLayoutParams()); 
 //      params.setMargins(i, params.topMargin, params.rightMargin, params.bottomMargin); 
        mContent.setPadding(i, mContent.getPaddingTop(),   
                mContent.getPaddingRight(), mContent.getPaddingBottom());  
    }  
 
 
 @Override 
 public void computeScroll() {  
 if (!mScroller.isFinished()) {  
 if (mScroller.computeScrollOffset()) {  
 int oldX = getScrollX();  
 int oldY = getScrollY();  
 int x = mScroller.getCurrX();  
 int y = mScroller.getCurrY();  
 
 if (oldX != x || oldY != y) {  
                    scrollTo(x, y);  
                    pageScrolled(x);  
                }  
 
 // Keep on drawing until the animation has finished. 
                invalidate();  
 return;  
            }  
        }  
 
 // Done with scroll, clean up state. 
        completeScroll();  
    }  
 
 private void pageScrolled(int xpos) {  
 final int widthWithMargin = getWidth();  
 final int position = xpos / widthWithMargin;  
 final int offsetPixels = xpos % widthWithMargin;  
 final float offset = (float) offsetPixels / widthWithMargin;  
 
        onPageScrolled(position, offset, offsetPixels);  
    }  
 
 /** 
     * This method will be invoked when the current page is scrolled, either as part 
     * of a programmatically initiated smooth scroll or a user initiated touch scroll. 
     * If you override this method you must call through to the superclass implementation 
     * (e.g. super.onPageScrolled(position, offset, offsetPixels)) before onPageScrolled 
     * returns. 
     * 
     * @param position Position index of the first page currently being displayed. 
     *                 Page position+1 will be visible if positionOffset is nonzero. 
     * @param offset Value from [0, 1) indicating the offset from the page at position. 
     * @param offsetPixels Value in pixels indicating the offset from position. 
     */ 
 protected void onPageScrolled(int position, float offset, int offsetPixels) {  
 if (mOnPageChangeListener != null) {  
            mOnPageChangeListener.onPageScrolled(position, offset, offsetPixels);  
        }  
 if (mInternalPageChangeListener != null) {  
            mInternalPageChangeListener.onPageScrolled(position, offset, offsetPixels);  
        }  
    }  
 
 private void completeScroll() {  
 boolean needPopulate = mScrolling;  
 if (needPopulate) {  
 // Done with scroll, no longer want to cache view drawing. 
            setScrollingCacheEnabled(false);  
            mScroller.abortAnimation();  
 int oldX = getScrollX();  
 int oldY = getScrollY();  
 int x = mScroller.getCurrX();  
 int y = mScroller.getCurrY();  
 if (oldX != x || oldY != y) {  
                scrollTo(x, y);  
            }  
 if (isMenuOpen()) {  
 if (mOpenedListener != null)  
                    mOpenedListener.onOpened();  
            } else {  
 if (mClosedListener != null)  
                    mClosedListener.onClosed();  
            }  
        }  
        mScrolling = false;  
    }  
 
 protected int mTouchMode = SlidingMenu.TOUCHMODE_MARGIN;  
 
 public void setTouchMode(int i) {  
        mTouchMode = i;  
    }  
 
 public int getTouchMode() {  
 return mTouchMode;  
    }  
 
 private boolean thisTouchAllowed(MotionEvent ev) {  
 int x = (int) (ev.getX() + mScrollX);  
 if (isMenuOpen()) {  
 return mViewBehind.menuOpenTouchAllowed(mContent, mCurItem, x);  
        } else {  
 switch (mTouchMode) {  
 case SlidingMenu.TOUCHMODE_FULLSCREEN:  
 return !isInIgnoredView(ev);  
 case SlidingMenu.TOUCHMODE_NONE:  
 return false;  
 case SlidingMenu.TOUCHMODE_MARGIN:  
 return mViewBehind.marginTouchAllowed(mContent, x);  
            }  
        }  
 return false;  
    }  
 
 private boolean thisSlideAllowed(float dx) {  
 boolean allowed = false;  
 if (isMenuOpen()) {  
            allowed = mViewBehind.menuOpenSlideAllowed(dx);  
        } else {  
            allowed = mViewBehind.menuClosedSlideAllowed(dx);  
        }  
 if (DEBUG)  
            Log.v(TAG, "this slide allowed " + allowed + " dx: " + dx);  
 return allowed;  
    }  
 
 private int getPointerIndex(MotionEvent ev, int id) {  
 int activePointerIndex = MotionEventCompat.findPointerIndex(ev, id);  
 if (activePointerIndex == -1)  
            mActivePointerId = INVALID_POINTER;  
 return activePointerIndex;  
    }  
 
 private boolean mQuickReturn = false;  
 
 @Override 
 public boolean onInterceptTouchEvent(MotionEvent ev) {  
 
 if (!mEnabled)  
 return false;  
 
 final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;  
 
 if (DEBUG)  
 if (action == MotionEvent.ACTION_DOWN)  
                Log.v(TAG, "Received ACTION_DOWN");  
 
 if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP  
                || (action != MotionEvent.ACTION_DOWN && mIsUnableToDrag)) {  
            endDrag();  
 return false;  
        }  
 
 switch (action) {  
 case MotionEvent.ACTION_MOVE:  
            determineDrag(ev);  
 break;  
 case MotionEvent.ACTION_DOWN:  
 int index = MotionEventCompat.getActionIndex(ev);  
            mActivePointerId = MotionEventCompat.getPointerId(ev, index);  
 if (mActivePointerId == INVALID_POINTER)  
 break;  
            mLastMotionX = mInitialMotionX = MotionEventCompat.getX(ev, index);  
            mLastMotionY = MotionEventCompat.getY(ev, index);  
 if (thisTouchAllowed(ev)) {  
                mIsBeingDragged = false;  
                mIsUnableToDrag = false;  
 if (isMenuOpen() && mViewBehind.menuTouchInQuickReturn(mContent, mCurItem, ev.getX() + mScrollX)) {  
                    mQuickReturn = true;  
                }  
            } else {  
                mIsUnableToDrag = true;  
            }  
 break;  
 case MotionEventCompat.ACTION_POINTER_UP:  
            onSecondaryPointerUp(ev);  
 break;  
        }  
 
 if (!mIsBeingDragged) {  
 if (mVelocityTracker == null) {  
                mVelocityTracker = VelocityTracker.obtain();  
            }  
            mVelocityTracker.addMovement(ev);  
        }  
 return mIsBeingDragged || mQuickReturn;  
    }  
 
 
 @Override 
 public boolean onTouchEvent(MotionEvent ev) {  
 
 if (!mEnabled)  
 return false;  
 
 if (!mIsBeingDragged && !thisTouchAllowed(ev))  
 return false;  
 
 //      if (!mIsBeingDragged && !mQuickReturn) 
 //          return false; 
 
 final int action = ev.getAction();  
 
 if (mVelocityTracker == null) {  
            mVelocityTracker = VelocityTracker.obtain();  
        }  
        mVelocityTracker.addMovement(ev);  
 
 switch (action & MotionEventCompat.ACTION_MASK) {  
 case MotionEvent.ACTION_DOWN:  
 /* 
             * If being flinged and user touches, stop the fling. isFinished 
             * will be false if being flinged. 
             */ 
            completeScroll();  
 
 // Remember where the motion event started 
 int index = MotionEventCompat.getActionIndex(ev);  
            mActivePointerId = MotionEventCompat.getPointerId(ev, index);  
            mLastMotionX = mInitialMotionX = ev.getX();  
 break;  
 case MotionEvent.ACTION_MOVE:  
 if (!mIsBeingDragged) {   
                determineDrag(ev);  
 if (mIsUnableToDrag)  
 return false;  
            }  
 if (mIsBeingDragged) {  
 // Scroll to follow the motion event 
 final int activePointerIndex = getPointerIndex(ev, mActivePointerId);  
 if (mActivePointerId == INVALID_POINTER)  
 break;  
 final float x = MotionEventCompat.getX(ev, activePointerIndex);  
 final float deltaX = mLastMotionX - x;  
                mLastMotionX = x;  
 float oldScrollX = getScrollX();  
 float scrollX = oldScrollX + deltaX;  
 final float leftBound = getLeftBound();  
 final float rightBound = getRightBound();  
 if (scrollX < leftBound) {  
                    scrollX = leftBound;  
                } else if (scrollX > rightBound) {  
                    scrollX = rightBound;  
                }  
 // Don't lose the rounded component 
                mLastMotionX += scrollX - (int) scrollX;  
                scrollTo((int) scrollX, getScrollY());  
                pageScrolled((int) scrollX);  
            }  
 break;  
 case MotionEvent.ACTION_UP:  
 if (mIsBeingDragged) {  
 final VelocityTracker velocityTracker = mVelocityTracker;  
                velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);  
 int initialVelocity = (int) VelocityTrackerCompat.getXVelocity(  
                        velocityTracker, mActivePointerId);  
 final int scrollX = getScrollX();  
 final float pageOffset = (float) (scrollX - getDestScrollX(mCurItem)) / getBehindWidth();  
 final int activePointerIndex = getPointerIndex(ev, mActivePointerId);  
 if (mActivePointerId != INVALID_POINTER) {  
 final float x = MotionEventCompat.getX(ev, activePointerIndex);  
 final int totalDelta = (int) (x - mInitialMotionX);  
 int nextPage = determineTargetPage(pageOffset, initialVelocity, totalDelta);  
                    setCurrentItemInternal(nextPage, true, true, initialVelocity);  
                } else {      
                    setCurrentItemInternal(mCurItem, true, true, initialVelocity);  
                }  
                mActivePointerId = INVALID_POINTER;  
                endDrag();  
            } else if (mQuickReturn && mViewBehind.menuTouchInQuickReturn(mContent, mCurItem, ev.getX() + mScrollX)) {  
 // close the menu 
                setCurrentItem(1);  
                endDrag();  
            }  
 break;  
 case MotionEvent.ACTION_CANCEL:  
 if (mIsBeingDragged) {  
                setCurrentItemInternal(mCurItem, true, true);  
                mActivePointerId = INVALID_POINTER;  
                endDrag();  
            }  
 break;  
 case MotionEventCompat.ACTION_POINTER_DOWN: {  
 final int indexx = MotionEventCompat.getActionIndex(ev);  
            mLastMotionX = MotionEventCompat.getX(ev, indexx);  
            mActivePointerId = MotionEventCompat.getPointerId(ev, indexx);  
 break;  
        }  
 case MotionEventCompat.ACTION_POINTER_UP:  
            onSecondaryPointerUp(ev);  
 int pointerIndex = getPointerIndex(ev, mActivePointerId);  
 if (mActivePointerId == INVALID_POINTER)  
 break;  
            mLastMotionX = MotionEventCompat.getX(ev, pointerIndex);  
 break;  
        }  
 return true;  
    }  
 
 private void determineDrag(MotionEvent ev) {  
 final int activePointerId = mActivePointerId;  
 final int pointerIndex = getPointerIndex(ev, activePointerId);  
 if (activePointerId == INVALID_POINTER || pointerIndex == INVALID_POINTER)  
 return;  
 final float x = MotionEventCompat.getX(ev, pointerIndex);  
 final float dx = x - mLastMotionX;  
 final float xDiff = Math.abs(dx);  
 final float y = MotionEventCompat.getY(ev, pointerIndex);  
 final float dy = y - mLastMotionY;  
 final float yDiff = Math.abs(dy);  
 if (xDiff > (isMenuOpen()?mTouchSlop/2:mTouchSlop) && xDiff > yDiff && thisSlideAllowed(dx)) {          
            startDrag();  
            mLastMotionX = x;  
            mLastMotionY = y;  
            setScrollingCacheEnabled(true);  
 // TODO add back in touch slop check 
        } else if (xDiff > mTouchSlop) {  
            mIsUnableToDrag = true;  
        }  
    }  
 
 @Override 
 public void scrollTo(int x, int y) {  
 super.scrollTo(x, y);  
        mScrollX = x;  
        mViewBehind.scrollBehindTo(mContent, x, y);   
       ((SlidingMenu)getParent()).manageLayers(getPercentOpen());  
 
 if (mTransformer != null) {  
            invalidate();  
        }  
    }  
 
 private int determineTargetPage(float pageOffset, int velocity, int deltaX) {  
 int targetPage = mCurItem;  
 if (Math.abs(deltaX) > mFlingDistance && Math.abs(velocity) > mMinimumVelocity) {  
 if (velocity > 0 && deltaX > 0) {  
                targetPage -= 1;  
            } else if (velocity < 0 && deltaX < 0){  
                targetPage += 1;  
            }  
        } else {  
            targetPage = (int) Math.round(mCurItem + pageOffset);  
        }  
 return targetPage;  
    }  
 
 protected float getPercentOpen() {  
 return Math.abs(mScrollX-mContent.getLeft()) / getBehindWidth();  
    }  
 
 @Override 
 protected void dispatchDraw(Canvas canvas) {  
 // 这句要注释掉，否则会出现2个右侧的视图，一个有转场动画，一个没有转场动画 
 // super.dispatchDraw(canvas); 
 // Draw the margin drawable if needed. 
        mViewBehind.drawShadow(mContent, canvas);  
        mViewBehind.drawFade(mContent, canvas, getPercentOpen());  
        mViewBehind.drawSelector(mContent, canvas, getPercentOpen());  
 // 设置右侧视图的转场效果，主要是修改Canvas。 
 if (mTransformer != null) {  
            canvas.save();  
            mTransformer.transformCanvas(canvas, getPercentOpen());  
 super.dispatchDraw(canvas);  
            canvas.restore();  
        } else {  
 super.dispatchDraw(canvas);  
        }  
    }  
 
 // variables for drawing 
 private float mScrollX = 0.0f;  
 
 private void onSecondaryPointerUp(MotionEvent ev) {  
 if (DEBUG) Log.v(TAG, "onSecondaryPointerUp called");  
 final int pointerIndex = MotionEventCompat.getActionIndex(ev);  
 final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);  
 if (pointerId == mActivePointerId) {  
 // This was our active pointer going up. Choose a new 
 // active pointer and adjust accordingly. 
 final int newPointerIndex = pointerIndex == 0 ? 1 : 0;  
            mLastMotionX = MotionEventCompat.getX(ev, newPointerIndex);  
            mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);  
 if (mVelocityTracker != null) {  
                mVelocityTracker.clear();  
            }  
        }  
    }  
 
 private void startDrag() {  
        mIsBeingDragged = true;  
        mQuickReturn = false;  
    }  
 
 private void endDrag() {  
        mQuickReturn = false;  
        mIsBeingDragged = false;  
        mIsUnableToDrag = false;  
        mActivePointerId = INVALID_POINTER;  
 
 if (mVelocityTracker != null) {  
            mVelocityTracker.recycle();  
            mVelocityTracker = null;  
        }  
    }  
 
 private void setScrollingCacheEnabled(boolean enabled) {  
 if (mScrollingCacheEnabled != enabled) {  
            mScrollingCacheEnabled = enabled;  
 if (USE_CACHE) {  
 final int size = getChildCount();  
 for (int i = 0; i < size; ++i) {  
 final View child = getChildAt(i);  
 if (child.getVisibility() != GONE) {  
                        child.setDrawingCacheEnabled(enabled);  
                    }  
                }  
            }  
        }  
    }  
 
 /** 
     * 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 v passed should itself be checked for scrollability (true), 
     *               or just its children (false). 
     * @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 canScroll(View v, boolean checkV, int dx, int x, int y) {  
 if (v instanceof ViewGroup) {  
 final ViewGroup group = (ViewGroup) v;  
 final int scrollX = v.getScrollX();  
 final int scrollY = v.getScrollY();  
 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);  
 if (x + scrollX >= child.getLeft() && x + scrollX < child.getRight() &&  
                        y + scrollY >= child.getTop() && y + scrollY < child.getBottom() &&  
                        canScroll(child, true, dx, x + scrollX - child.getLeft(),  
                                y + scrollY - child.getTop())) {  
 return true;  
                }  
            }  
        }  
 
 return checkV && ViewCompat.canScrollHorizontally(v, -dx);  
    }  
 
 
 @Override 
 public boolean dispatchKeyEvent(KeyEvent event) {  
 // Let the focused view and/or our descendants get the key first 
 return super.dispatchKeyEvent(event) || executeKeyEvent(event);  
    }  
 
 /** 
     * You can call this function yourself to have the scroll view perform 
     * scrolling from a key event, just as if the event had been dispatched to 
     * it by the view hierarchy. 
     * 
     * @param event The key event to execute. 
     * @return Return true if the event was handled, else false. 
     */ 
 public boolean executeKeyEvent(KeyEvent event) {  
 boolean handled = false;  
 if (event.getAction() == KeyEvent.ACTION_DOWN) {  
 switch (event.getKeyCode()) {  
 case KeyEvent.KEYCODE_DPAD_LEFT:  
                handled = arrowScroll(FOCUS_LEFT);  
 break;  
 case KeyEvent.KEYCODE_DPAD_RIGHT:  
                handled = arrowScroll(FOCUS_RIGHT);  
 break;  
 case KeyEvent.KEYCODE_TAB:  
 if (Build.VERSION.SDK_INT >= 11) {  
 // The focus finder had a bug handling FOCUS_FORWARD and FOCUS_BACKWARD 
 // before Android 3.0. Ignore the tab key on those devices. 
 if (KeyEventCompat.hasNoModifiers(event)) {  
                        handled = arrowScroll(FOCUS_FORWARD);  
                    } else if (KeyEventCompat.hasModifiers(event, KeyEvent.META_SHIFT_ON)) {  
                        handled = arrowScroll(FOCUS_BACKWARD);  
                    }  
                }  
 break;  
            }  
        }  
 return handled;  
    }  
 
 public boolean arrowScroll(int direction) {  
        View currentFocused = findFocus();  
 if (currentFocused == this) currentFocused = null;  
 
 boolean handled = false;  
 
        View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused,  
                direction);  
 if (nextFocused != null && nextFocused != currentFocused) {  
 if (direction == View.FOCUS_LEFT) {  
                handled = nextFocused.requestFocus();  
            } else if (direction == View.FOCUS_RIGHT) {  
 // If there is nothing to the right, or this is causing us to 
 // jump to the left, then what we really want to do is page right. 
 if (currentFocused != null && nextFocused.getLeft() <= currentFocused.getLeft()) {  
                    handled = pageRight();  
                } else {  
                    handled = nextFocused.requestFocus();  
                }  
            }  
        } else if (direction == FOCUS_LEFT || direction == FOCUS_BACKWARD) {  
 // Trying to move left and nothing there; try to page. 
            handled = pageLeft();  
        } else if (direction == FOCUS_RIGHT || direction == FOCUS_FORWARD) {  
 // Trying to move right and nothing there; try to page. 
            handled = pageRight();  
        }  
 if (handled) {  
            playSoundEffect(SoundEffectConstants.getContantForFocusDirection(direction));  
        }  
 return handled;  
    }  
 
 boolean pageLeft() {  
 if (mCurItem > 0) {  
            setCurrentItem(mCurItem-1, true);  
 return true;  
        }  
 return false;  
    }  
 
 boolean pageRight() {  
 if (mCurItem < 1) {  
            setCurrentItem(mCurItem+1, true);  
 return true;  
        }  
 return false;  
    }  
 
 public void setCanvasTransformer(CanvasTransformer t) {  
        mTransformer = t;  
    }  
 
}  

SlidingMenu sm = getSlidingMenu();  
sm.setBehindOffsetRes(R.dimen.slidingmenu_offset);  
sm.setFadeEnabled(false);  
sm.setBehindScrollScale(0.25f);  
sm.setFadeDegree(0.25f);  
 
// 配置背景图片 
sm.setBackgroundImage(R.drawable.img_frame_background);  
// 设置专场动画效果 
sm.setBehindCanvasTransformer(new SlidingMenu.CanvasTransformer() {  
 @Override 
 public void transformCanvas(Canvas canvas, float percentOpen) {  
 float scale = (float) (percentOpen * 0.25 + 0.75);  
        canvas.scale(scale, scale, -canvas.getWidth() / 2,  
                canvas.getHeight() / 2);  
    }  
});  
 
sm.setAboveCanvasTransformer(new SlidingMenu.CanvasTransformer() {  
 @Override 
 public void transformCanvas(Canvas canvas, float percentOpen) {  
 float scale = (float) (1 - percentOpen * 0.25);  
        canvas.scale(scale, scale, 0, canvas.getHeight() / 2);  
    }  
});