Android Open Source - mint Sliding Menu






From Project

Back to project page mint.

License

The source code is released under:

GNU General Public License

If you think the Android project mint listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.

Java Source Code

package com.slidingmenu.lib;
/* www .j  av a  2 s .co  m*/
import java.lang.reflect.Method;

import android.annotation.SuppressLint;
import android.annotation.TargetApi;
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.Point;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.os.Handler;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Display;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.FrameLayout;
import android.widget.RelativeLayout;

import com.slidingmenu.lib.CustomViewAbove.OnPageChangeListener;

public class SlidingMenu extends RelativeLayout {

  private static final String TAG = "SlidingMenu";

  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;

  private OnOpenListener mOpenListener;

  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);

    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 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();
        }
      }
    });

    // 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, 0, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
      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();
  }

  /**
   * 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();
  }

  /**
   * 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);
  }

  /**
   * 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 OnCloseListener. {@link OnCloseListener#onClose() OnCloseListener.onClose()} will be called when 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;
  }
  
  private Handler mHandler = new Handler();

  @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()) {
      mHandler.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);
          }
        }
      });
    }
  }

}




Java Source Code List

com.gmail.altakey.mint.activity.ConfigActivity.java
com.gmail.altakey.mint.activity.MainActivity.java
com.gmail.altakey.mint.activity.TaskEditActivity.java
com.gmail.altakey.mint.activity.TaskListActivity.java
com.gmail.altakey.mint.activity.WelcomeActivity.java
com.gmail.altakey.mint.fragment.NavigationFragment.java
com.gmail.altakey.mint.fragment.TaskEditFragment.java
com.gmail.altakey.mint.fragment.TaskGroupListFragment.java
com.gmail.altakey.mint.fragment.TaskListFragment.java
com.gmail.altakey.mint.fragment.TaskPostFragment.java
com.gmail.altakey.mint.fragment.TaskStatusListFragment.java
com.gmail.altakey.mint.fragment.WelcomeFragment.java
com.gmail.altakey.mint.konst.ConfigKey.java
com.gmail.altakey.mint.model.Schema.java
com.gmail.altakey.mint.model.TaskContext.java
com.gmail.altakey.mint.model.TaskFolder.java
com.gmail.altakey.mint.model.TaskStatus.java
com.gmail.altakey.mint.model.Task.java
com.gmail.altakey.mint.provider.BaseProvider.java
com.gmail.altakey.mint.provider.ProviderMap.java
com.gmail.altakey.mint.provider.TaskContextProvider.java
com.gmail.altakey.mint.provider.TaskCountProvider.java
com.gmail.altakey.mint.provider.TaskFolderProvider.java
com.gmail.altakey.mint.provider.TaskProvider.java
com.gmail.altakey.mint.service.ToodledoClientService.java
com.gmail.altakey.mint.service.ToodledoClient.java
com.gmail.altakey.mint.util.Authenticator.java
com.gmail.altakey.mint.util.FilterType.java
com.gmail.altakey.mint.util.Joiner.java
com.gmail.altakey.mint.util.LoaderUtil.java
com.gmail.altakey.mint.util.Notifier.java
com.gmail.altakey.mint.util.ProviderUtils.java
com.gmail.altakey.mint.util.SyncPoker.java
com.gmail.altakey.mint.util.VolatileDialog.java
com.slidingmenu.example.AttachExample.java
com.slidingmenu.example.BaseActivity.java
com.slidingmenu.example.ExampleListActivity.java
com.slidingmenu.example.LeftAndRightActivity.java
com.slidingmenu.example.PropertiesActivity.java
com.slidingmenu.example.SampleListFragment.java
com.slidingmenu.example.SlidingContent.java
com.slidingmenu.example.SlidingTitleBar.java
com.slidingmenu.example.Util.java
com.slidingmenu.example.ViewPagerActivity.java
com.slidingmenu.example.anim.CustomAnimation.java
com.slidingmenu.example.anim.CustomScaleAnimation.java
com.slidingmenu.example.anim.CustomSlideAnimation.java
com.slidingmenu.example.anim.CustomZoomAnimation.java
com.slidingmenu.example.fragments.BirdActivity.java
com.slidingmenu.example.fragments.BirdGridFragment.java
com.slidingmenu.example.fragments.BirdMenuFragment.java
com.slidingmenu.example.fragments.ColorFragment.java
com.slidingmenu.example.fragments.ColorMenuFragment.java
com.slidingmenu.example.fragments.FragmentChangeActivity.java
com.slidingmenu.example.fragments.ResponsiveUIActivity.java
com.slidingmenu.lib.CanvasTransformerBuilder.java
com.slidingmenu.lib.CustomViewAbove.java
com.slidingmenu.lib.CustomViewBehind.java
com.slidingmenu.lib.MenuInterface.java
com.slidingmenu.lib.SlidingMenu.java
com.slidingmenu.lib.app.SlidingActivityBase.java
com.slidingmenu.lib.app.SlidingActivityHelper.java
com.slidingmenu.lib.app.SlidingActivity.java
com.slidingmenu.lib.app.SlidingFragmentActivity.java
com.slidingmenu.lib.app.SlidingListActivity.java
com.slidingmenu.lib.app.SlidingMapActivity.java
com.slidingmenu.lib.app.SlidingPreferenceActivity.java