Ejemplo n.º 1
0
 /**
  * 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);
   }
 }
Ejemplo n.º 2
0
 boolean pageRight() {
   if (mCurItem < 1) {
     setCurrentItem(mCurItem + 1, true);
     return true;
   }
   return false;
 }
Ejemplo n.º 3
0
 boolean pageLeft() {
   if (mCurItem > 0) {
     setCurrentItem(mCurItem - 1, true);
     return true;
   }
   return false;
 }
Ejemplo n.º 4
0
 /* (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());
 }
Ejemplo n.º 5
0
 /**
  * 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);
 }
Ejemplo n.º 6
0
 /**
  * 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);
 }
Ejemplo n.º 7
0
 /**
  * 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);
 }
Ejemplo n.º 8
0
  @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;
  }