public override bool OnTouchEvent(MotionEvent e) { var index = e.ActionIndex; var action = (MotionEventActions)e.ActionMasked; var pointerId = e.GetPointerId(index); switch (action) { case MotionEventActions.Down: if (this._velocityTracket == null) { this._velocityTracket = VelocityTracker.Obtain(); } else { this._velocityTracket.Clear(); } this._velocityTracket.AddMovement(e); break; case MotionEventActions.Move: this._velocityTracket.AddMovement(e); this._velocityTracket.ComputeCurrentVelocity(1000); Log.Debug(DebugTag, "X velocity: " + VelocityTrackerCompat.GetXVelocity(this._velocityTracket, pointerId)); Log.Debug(DebugTag, "Y velocity: " + VelocityTrackerCompat.GetYVelocity(this._velocityTracket, pointerId)); break; case MotionEventActions.Cancel: case MotionEventActions.Up: this._velocityTracket.Recycle(); break; default: break; } return true; }
public NodeTouchEvent(MotionEvent motion, VelocityTracker velocity) { this.velocity = velocity; velocity.AddMovement (motion); point = new Point (motion.GetX (), motion.GetY ()); if (motion.Action == MotionEventActions.Move) { type = TouchType.Move; } else if (motion.Action == MotionEventActions.Down) { type = TouchType.Down; } else if (motion.Action == MotionEventActions.Up) { type = TouchType.Up; } }
public override bool OnTouchEvent(MotionEvent ev) { if (_velocityTracker == null) { _velocityTracker = VelocityTracker.Obtain(); } _velocityTracker.AddMovement(ev); var action = ev.Action; var x = ev.GetX(); switch (action) { case MotionEventActions.Down: /* * If being flinged and user touches, stop the fling. isFinished will be false if being flinged. */ if (!_scroller.IsFinished) { _scroller.AbortAnimation(); } // Remember where the motion event started _lastMotionX = x; _touchState = _scroller.IsFinished ? TOUCH_STATE_REST : TOUCH_STATE_SCROLLING; break; case MotionEventActions.Move: var xDiff = (int) Math.Abs(x - _lastMotionX); var xMoved = xDiff > _touchSlop; if (xMoved) { // Scroll if the user moved far enough along the X axis _touchState = TOUCH_STATE_SCROLLING; } if (_touchState == TOUCH_STATE_SCROLLING) { // Scroll to follow the motion event var deltaX = (int) (_lastMotionX - x); _lastMotionX = x; var scrollX = ScrollX; if (deltaX < 0) { if (scrollX > 0) { ScrollBy(Math.Max(-scrollX, deltaX), 0); } } else if (deltaX > 0) { var availableToScroll = GetChildAt(ChildCount - 1).Right - scrollX - Width; if (availableToScroll > 0) { ScrollBy(Math.Min(availableToScroll, deltaX), 0); } } } break; case MotionEventActions.Up: if (_touchState == TOUCH_STATE_SCROLLING) { var velocityTracker = _velocityTracker; velocityTracker.ComputeCurrentVelocity(1000, _maximumVelocity); var velocityX = (int) velocityTracker.XVelocity; if (velocityX > SNAP_VELOCITY && _currentScreen > 0) { // Fling hard enough to move left SnapToScreen(_currentScreen - 1); } else if (velocityX < -SNAP_VELOCITY && _currentScreen < ChildCount - 1) { // Fling hard enough to move right SnapToScreen(_currentScreen + 1); } else { SnapToDestination(); } if (_velocityTracker != null) { _velocityTracker.Recycle(); _velocityTracker = null; } } _touchState = TOUCH_STATE_REST; break; case MotionEventActions.Cancel: _touchState = TOUCH_STATE_REST; break; } return true; }
public override bool OnTouchEvent(MotionEvent ev) { if (!_enabled) return false; if (!_isBeingDragged && !ThisTouchAllowed(ev)) return false; if (VelocityTracker == null) VelocityTracker = VelocityTracker.Obtain(); VelocityTracker.AddMovement(ev); var action = (int)ev.Action & MotionEventCompat.ActionMask; switch (action) { case (int) MotionEventActions.Down: CompleteScroll(); var index = MotionEventCompat.GetActionIndex(ev); ActivePointerId = MotionEventCompat.GetPointerId(ev, index); _lastMotionX = _initialMotionX = ev.GetX(); break; case (int) MotionEventActions.Move: if (!_isBeingDragged) { DetermineDrag(ev); if (_isUnableToDrag) return false; } if (_isBeingDragged) { var activePointerIndex = GetPointerIndex(ev, ActivePointerId); if (ActivePointerId == InvalidPointer) break; var x = MotionEventCompat.GetX(ev, activePointerIndex); var deltaX = _lastMotionX - x; _lastMotionX = x; var oldScrollX = ScrollX; var scrollX = oldScrollX + deltaX; var leftBound = LeftBound; var rightBound = RightBound; if (scrollX < leftBound) scrollX = leftBound; else if (scrollX > rightBound) scrollX = rightBound; _lastMotionX += scrollX - (int) scrollX; ScrollTo((int) scrollX, ScrollY); OnPageScrolled((int)scrollX); } break; case (int) MotionEventActions.Up: if (_isBeingDragged) { var velocityTracker = VelocityTracker; velocityTracker.ComputeCurrentVelocity(1000, MaximumVelocity); var initialVelocity = (int) VelocityTrackerCompat.GetXVelocity(velocityTracker, ActivePointerId); var scrollX = ScrollX; var pageOffset = (float) (scrollX - GetDestScrollX(_curItem)) / BehindWidth; var activePointerIndex = GetPointerIndex(ev, ActivePointerId); if (ActivePointerId != InvalidPointer) { var x = MotionEventCompat.GetX(ev, activePointerIndex); var totalDelta = (int) (x - _initialMotionX); var nextPage = DetermineTargetPage(pageOffset, initialVelocity, totalDelta); SetCurrentItemInternal(nextPage, true, true, initialVelocity); } else SetCurrentItemInternal(_curItem, true, true, initialVelocity); ActivePointerId = InvalidPointer; EndDrag(); } else if (_quickReturn && _viewBehind.MenuTouchInQuickReturn(_content, _curItem, ev.GetX() + _scrollX)) { SetCurrentItem(1); EndDrag(); } break; case (int) MotionEventActions.Cancel: if (_isBeingDragged) { SetCurrentItemInternal(_curItem, true, true); ActivePointerId = InvalidPointer; EndDrag(); } break; case MotionEventCompat.ActionPointerDown: var indexx = MotionEventCompat.GetActionIndex(ev); _lastMotionX = MotionEventCompat.GetX(ev, indexx); ActivePointerId = MotionEventCompat.GetPointerId(ev, indexx); break; case MotionEventCompat.ActionPointerUp: OnSecondaryPointerUp(ev); var pointerIndex = GetPointerIndex(ev, ActivePointerId); if (ActivePointerId == InvalidPointer) break; _lastMotionX = MotionEventCompat.GetX(ev, pointerIndex); break; } return true; }
bool OnUp (MotionEvent motionEvent) { if (_velocityTracker == null) { return false; } float deltaX = motionEvent.RawX - mDownX; _velocityTracker.AddMovement (motionEvent); _velocityTracker.ComputeCurrentVelocity (1000); float velocityX = _velocityTracker.XVelocity; float absVelocityX = Math.Abs (velocityX); float absVelocityY = Math.Abs (_velocityTracker.YVelocity); bool dismiss = false; bool dismissRight = false; if (Math.Abs (deltaX) > _viewWidth / 2 && isSwiping) { dismiss = true; dismissRight = deltaX > 0; } else if (FlingingSameDirectionAsDragging (absVelocityX, absVelocityY)) { dismiss = (velocityX < 0) == (deltaX < 0); dismissRight = _velocityTracker.XVelocity > 0; } if (dismiss && _downPosition != AdapterView.InvalidPosition) { View downView = _downView; int downPosition = _downPosition; ++mDismissAnimationRefCount; AnimateDismissStart (_downView, dismissRight, new SwipeAnimatorListenerAdapter (_ => AnimateDismissEnd (downView, downPosition))); } else { AnimateDismissCancel (_downView); } _velocityTracker.Recycle (); _velocityTracker = null; mDownX = 0; mDownY = 0; _downView = null; InvalidateDownPosition (); isSwiping = false; return false; }
bool OnDown (MotionEvent motionEvent) { if (_paused) { return false; } var rect = new Rect (); int childCount = _listView.ChildCount; var listViewCoords = new int[2]; _listView.GetLocationOnScreen (listViewCoords); int x = (int)motionEvent.RawX - listViewCoords [0]; int y = (int)motionEvent.RawY - listViewCoords [1]; View child; for (int i = 0; i < childCount; i++) { child = _listView.GetChildAt (i); child.GetHitRect (rect); if (rect.Contains (x, y)) { _downView = child; break; } } if (_downView != null) { mDownX = motionEvent.RawX; mDownY = motionEvent.RawY; _downPosition = _listView.GetPositionForView (_downView); if (_dismissCommand.CanExecute (_downPosition)) { _velocityTracker = VelocityTracker.Obtain (); _velocityTracker.AddMovement (motionEvent); } else { _downView = null; } } return false; }
bool CaptureMovementCheck(MotionEvent ev) { if (ev.Action == MotionEventActions.Down) { oldY = startY = (int)ev.GetY (); if (!Opened) return false; velocityTracker = VelocityTracker.Obtain (); velocityTracker.AddMovement (ev); preTracking = true; stateBeforeTracking = state; return false; } if (ev.Action == MotionEventActions.Up) preTracking = isTracking = false; if (!preTracking) return false; velocityTracker.AddMovement (ev); if (ev.Action == MotionEventActions.Move) { // Check we are going in the right direction, if not cancel the current gesture if (!MoveDirectionTest (ev)) { preTracking = false; return false; } // If the current gesture has not gone long enough don't intercept it just yet var distance = Math.Abs (ev.GetY () - startY); if (distance < pagingTouchSlop) return false; } oldY = startY = (int)ev.GetY (); isTracking = true; return true; }
private void InitVelocityTrackerIfNotExists() { if (this.velocityTracker == null) { this.velocityTracker = VelocityTracker.Obtain(); } }
public override bool OnTouchEvent(MotionEvent e) { if (mVelocityTracker == null) mVelocityTracker = VelocityTracker.Obtain(); mVelocityTracker.AddMovement(e); MotionEventActions action = e.Action; float x = e.GetX(); switch (action) { case MotionEventActions.Down: if (!mScroller.IsFinished) mScroller.AbortAnimation(); mLastMotionX = x; if (mScroller.IsFinished) mTouchState = TOUCH_STATE_REST; else mTouchState = TOUCH_STATE_HORIZONTAL_SCROLLING; break; case MotionEventActions.Move: int xDiff = (int)Math.Abs(x - mLastMotionX); bool xMoved = xDiff > mTouchSlop; if (xMoved) mTouchState = TOUCH_STATE_HORIZONTAL_SCROLLING; if (mTouchState == TOUCH_STATE_HORIZONTAL_SCROLLING) { int deltaX = (int)(mLastMotionX - x); mLastMotionX = x; int scrollX = this.ScrollX; if (deltaX < 0) { if (scrollX > 0) ScrollBy(Math.Max(-scrollX, deltaX), 0); } else if (deltaX > 0) { if (this.ChildCount >= 1) { int avalableToScroll = this.GetChildAt(this.ChildCount - 1).Right - scrollX - Width; if (avalableToScroll > 0) ScrollBy(Math.Min(avalableToScroll, deltaX), 0); } } } break; case MotionEventActions.Up: if (mTouchState == TOUCH_STATE_HORIZONTAL_SCROLLING) { VelocityTracker velocityTracker = mVelocityTracker; velocityTracker.ComputeCurrentVelocity(VELOCITY_UNIT_PIXELS_PER_SECOND, mMaximumVelocity); int velocityX = (int)velocityTracker.XVelocity; if (velocityX > mDensityAdjustedSnapVelocity && mCurrentScreen > 0) SnapToScreen(mCurrentScreen - 1); else if (velocityX < -mDensityAdjustedSnapVelocity && mCurrentScreen < this.ChildCount - 1) SnapToScreen(mCurrentScreen + 1); else SnapToDestination(); if (mVelocityTracker != null) { mVelocityTracker.Recycle(); mVelocityTracker = null; } mTouchState = TOUCH_STATE_REST; } break; case MotionEventActions.Cancel: mTouchState = TOUCH_STATE_REST; break; default: break; } return true; }
private bool handleDownEvent(View view, MotionEvent motionEvent) { if (!mSwipeEnabled) { return false; } View downView = findDownView(motionEvent); if (downView == null) { return false; } int downPosition = AdapterViewUtil.getPositionForView(mListViewWrapper, downView); mCanDismissCurrent = isDismissable(downPosition); /* Check if we are processing the item at this position */ if (mCurrentPosition == downPosition || downPosition >= mVirtualListCount) { return false; } if (view != null) { view.OnTouchEvent(motionEvent); } disableHorizontalScrollContainerIfNecessary(motionEvent, downView); mDownX = motionEvent.GetX(); mDownY = motionEvent.GetY(); mCurrentView = downView; mSwipingView = getSwipeView(downView); mCurrentPosition = downPosition; mVelocityTracker = VelocityTracker.Obtain(); mVelocityTracker.AddMovement(motionEvent); return true; }
//@Override public override bool OnTouchEvent(MotionEvent ev) { if (!mEnabled) return false; if (!mIsBeingDragged && !thisTouchAllowed(ev)) return false; // if (!mIsBeingDragged && !mQuickReturn) // return false; MotionEventActions action = ev.Action; if (mVelocityTracker == null) { mVelocityTracker = VelocityTracker.Obtain(); } mVelocityTracker.AddMovement(ev); switch (action & (MotionEventActions)MotionEventCompat.ActionMask) { case MotionEventActions.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 MotionEventActions.Move: if (!mIsBeingDragged) { determineDrag(ev); if (mIsUnableToDrag) return false; } if (mIsBeingDragged) { // Scroll to follow the motion event int activePointerIndex = getPointerIndex(ev, mActivePointerId); if (mActivePointerId == INVALID_POINTER) break; float x = MotionEventCompat.GetX(ev, activePointerIndex); float deltaX = mLastMotionX - x; mLastMotionX = x; float oldScrollX = ScrollX; float scrollX = oldScrollX + deltaX; float leftBound = getLeftBound(); 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, ScrollY); pageScrolled((int)scrollX); } break; case MotionEventActions.Up: if (mIsBeingDragged) { VelocityTracker velocityTracker = mVelocityTracker; velocityTracker.ComputeCurrentVelocity(1000, mMaximumVelocity); int initialVelocity = (int)VelocityTrackerCompat.GetXVelocity( velocityTracker, mActivePointerId); int scrollX = ScrollX; float pageOffset = (float)(scrollX - getDestScrollX(mCurItem)) / getBehindWidth(); int activePointerIndex = getPointerIndex(ev, mActivePointerId); if (mActivePointerId != INVALID_POINTER) { float x = MotionEventCompat.GetX(ev, activePointerIndex); 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 MotionEventActions.Cancel: if (mIsBeingDragged) { setCurrentItemInternal(mCurItem, true, true); mActivePointerId = INVALID_POINTER; endDrag(); } break; case (MotionEventActions)MotionEventCompat.ActionPointerDown: { int indexx = MotionEventCompat.GetActionIndex(ev); mLastMotionX = MotionEventCompat.GetX(ev, indexx); mActivePointerId = MotionEventCompat.GetPointerId(ev, indexx); break; } case (MotionEventActions)MotionEventCompat.ActionPointerUp: onSecondaryPointerUp(ev); int pointerIndex = getPointerIndex(ev, mActivePointerId); if (mActivePointerId == INVALID_POINTER) break; mLastMotionX = MotionEventCompat.GetX(ev, pointerIndex); break; } return true; }
//@Override public override bool OnInterceptTouchEvent(MotionEvent ev) { if (!mEnabled) return false; MotionEventActions action =ev.Action & (MotionEventActions)MotionEventCompat.ActionMask; if (DEBUG) if (action == MotionEventActions.Down) Log.Verbose(TAG, "Received ACTION_DOWN"); if (action == MotionEventActions.Cancel || action == MotionEventActions.Up || (action != MotionEventActions.Down && mIsUnableToDrag)) { endDrag(); return false; } switch (action) { case MotionEventActions.Move: determineDrag(ev); break; case MotionEventActions.Down: int index = MotionEventCompat.GetActionIndex(ev); mActivePointerId = MotionEventCompat.GetPointerId(ev, index); if (mActivePointerId == INVALID_POINTER) break; mLastMotionX = MotionEventCompat.GetX(ev, index); mInitialMotionX = mLastMotionX; 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 (MotionEventActions)MotionEventCompat.ActionPointerUp: onSecondaryPointerUp(ev); break; } if (!mIsBeingDragged) { if (mVelocityTracker == null) { mVelocityTracker = VelocityTracker.Obtain(); } mVelocityTracker.AddMovement(ev); } return mIsBeingDragged || mQuickReturn; }
private void endDrag() { mQuickReturn = false; mIsBeingDragged = false; mIsUnableToDrag = false; mActivePointerId = INVALID_POINTER; if (mVelocityTracker != null) { mVelocityTracker.Recycle(); mVelocityTracker = null; } }
public override bool OnTouchEvent(MotionEvent e) { if (this._velocityTracker == null) { this._velocityTracker = VelocityTracker.Obtain(); } this._velocityTracker.AddMovement(e); VelocityTracker velocityTracker = this._velocityTracker; velocityTracker.ComputeCurrentVelocity(VelocityUnitPixelsPerSecond, this.MaximumVelocity); this.Velocity = (int)velocityTracker.XVelocity; if (e.Action == MotionEventActions.Up) { if (this._velocityTracker != null) { this.Velocity = 0; this._velocityTracker.Recycle(); this._velocityTracker = null; } } return this._gestureScanner.OnTouchEvent(e) || base.OnTouchEvent(e); }
public virtual bool OnTouchEvent(Android.Views.MotionEvent ev) { switch (ev.Action) { case MotionEventActions.Down: { mVelocityTracker = VelocityTracker.Obtain(); if (null != mVelocityTracker) { mVelocityTracker.AddMovement(ev); } else { Log.Info(LOG_TAG, "Velocity tracker is null"); } mLastTouchX = GetActiveX(ev); mLastTouchY = GetActiveY(ev); mIsDragging = false; break; } case MotionEventActions.Move: { float x = GetActiveX(ev); float y = GetActiveY(ev); float dx = x - mLastTouchX, dy = y - mLastTouchY; if (!mIsDragging) { // Use Pythagoras to see if drag length is larger than // touch slop mIsDragging = FloatMath.Sqrt((dx * dx) + (dy * dy)) >= mTouchSlop; } if (mIsDragging) { mListener.OnDrag(dx, dy); mLastTouchX = x; mLastTouchY = y; if (null != mVelocityTracker) { mVelocityTracker.AddMovement(ev); } } break; } case MotionEventActions.Cancel: { // Recycle Velocity Tracker if (null != mVelocityTracker) { mVelocityTracker.Recycle(); mVelocityTracker = null; } break; } case MotionEventActions.Up: { if (mIsDragging) { if (null != mVelocityTracker) { mLastTouchX = GetActiveX(ev); mLastTouchY = GetActiveY(ev); // Compute velocity within the last 1000ms mVelocityTracker.AddMovement(ev); mVelocityTracker.ComputeCurrentVelocity(1000); float vX = mVelocityTracker.GetXVelocity(0), vY = mVelocityTracker .GetYVelocity(0); // If the velocity is greater than minVelocity, call // listener if (Math.Max(Math.Abs(vX), Math.Abs(vY)) >= mMinimumVelocity) { mListener.OnFling(mLastTouchX, mLastTouchY, -vX, -vY); } } } // Recycle Velocity Tracker if (null != mVelocityTracker) { mVelocityTracker.Recycle(); mVelocityTracker = null; } break; } } return true; }
public override bool OnTouchEvent(MotionEvent e) { if (e.Action == MotionEventActions.Down) { down = new Point (e.RawX, e.RawY); } else if (e.Action == MotionEventActions.Up) { up = new Point (e.RawX, e.RawY); } if (node.TouchEvents) { if (e.Action == MotionEventActions.Move || e.Action == MotionEventActions.Down || e.Action == MotionEventActions.Up) { if (e.Action == MotionEventActions.Down || velocity == null) velocity = VelocityTracker.Obtain (); var result = node.Touch (new NodeTouchEvent (e, velocity)); if (e.Action == MotionEventActions.Up) velocity = null; return result; } } return base.OnTouchEvent (e); }
/** * Resets the fields to the initial values, ready to start over. */ private void reset() { if (mVelocityTracker != null) { mVelocityTracker.Recycle(); } mVelocityTracker = null; mDownX = 0; mDownY = 0; mCurrentView = null; mSwipingView = null; mCurrentPosition = AdapterView.InvalidPosition; mSwiping = false; mCanDismissCurrent = false; }
private void CreateVelocityTracker(MotionEvent e) { if (mVelocityTracker == null) { mVelocityTracker = VelocityTracker.Obtain(); } mVelocityTracker.AddMovement(e); }
private void InitOrResetVelocityTracker() { if (this.velocityTracker == null) { this.velocityTracker = VelocityTracker.Obtain(); } else { this.velocityTracker.Clear(); } }
private void RecycleVelocityTracker() { mVelocityTracker.Recycle(); mVelocityTracker = null; }
private void RecycleVelocityTracker() { if (this.velocityTracker != null) { this.velocityTracker.Recycle(); this.velocityTracker = null; } }
public override bool OnTouchEvent(MotionEvent ev) { if (mVelocityTracker == null) { mVelocityTracker = VelocityTracker.Obtain(); } mVelocityTracker.AddMovement(ev); MotionEventActions action = ev.Action; float x = ev.GetX(); float y = ev.GetY(); switch (action) { case MotionEventActions.Down: if (!mScroller.IsFinished) { mScroller.AbortAnimation(); } mLastMotionX = x; mLastMotionY = y; if (ScrollX == -getMenuViewWidth() && mLastMotionX < getMenuViewWidth()) { return false; } if (ScrollX == getDetailViewWidth() && mLastMotionX > getMenuViewWidth()) { return false; } break; case MotionEventActions.Move: if (mIsBeingDragged) { enableChildrenCache(); float deltaX = mLastMotionX - x; mLastMotionX = x; float oldScrollX = ScrollX; float scrollX = oldScrollX + deltaX; if (deltaX < 0 && oldScrollX < 0) { // left view float leftBound = 0; float rightBound = -getMenuViewWidth(); if (scrollX > leftBound) { scrollX = leftBound; } else if (scrollX < rightBound) { scrollX = rightBound; } // mDetailView.setVisibility(View.INVISIBLE); // mMenuView.setVisibility(View.VISIBLE); } else if (deltaX > 0 && oldScrollX > 0) { // right view float rightBound = getDetailViewWidth(); float leftBound = 0; if (scrollX < leftBound) { scrollX = leftBound; } else if (scrollX > rightBound) { scrollX = rightBound; } // mDetailView.setVisibility(View.VISIBLE); // mMenuView.setVisibility(View.INVISIBLE); } ScrollTo((int)scrollX, ScrollY); } break; case MotionEventActions.Cancel: case MotionEventActions.Up: if (mIsBeingDragged) { VelocityTracker velocityTracker = mVelocityTracker; velocityTracker.ComputeCurrentVelocity(1000); //����--------- int velocityX = (int)velocityTracker.GetXVelocity(10); velocityX = 0; //Log.e("ad", "velocityX == " + velocityX); int oldScrollX = ScrollX; int dx = 0; if (oldScrollX < 0) { if (oldScrollX < -getMenuViewWidth() / 2 || velocityX > SNAP_VELOCITY) { dx = -getMenuViewWidth() - oldScrollX; } else if (oldScrollX >= -getMenuViewWidth() / 2 || velocityX < -SNAP_VELOCITY) { dx = -oldScrollX; } } else { if (oldScrollX > getDetailViewWidth() / 2 || velocityX < -SNAP_VELOCITY) { dx = getDetailViewWidth() - oldScrollX; } else if (oldScrollX <= getDetailViewWidth() / 2 || velocityX > SNAP_VELOCITY) { dx = -oldScrollX; } } smoothScrollTo(dx); clearChildrenCache(); } break; } if (mVelocityTracker != null) { mVelocityTracker.Recycle(); mVelocityTracker = null; } return true; }
bool CaptureMovementCheck(MotionEvent ev) { if (ev.Action == MotionEventActions.Down) { startX = (int)ev.GetX (); startY = (int)ev.GetY (); // Only work if the initial touch was in the start strip when the menu is closed // When the menu is opened, anywhere will do if (!opened && (startX > Context.ToPixels (30))) return false; velocityTracker = VelocityTracker.Obtain (); velocityTracker.AddMovement (ev); preTracking = true; stateBeforeTracking = opened; return false; } if (ev.Action == MotionEventActions.Up) preTracking = isTracking = false; if (!preTracking) return false; velocityTracker.AddMovement (ev); if (ev.Action == MotionEventActions.Move) { // Check we are going in the right direction, if not cancel the current gesture if (!MoveDirectionTest (ev)) { preTracking = false; return false; } // If the current gesture has not gone long enough don't intercept it just yet var distance = Math.Sqrt (Math.Pow (ev.GetX () - startX, 2) + Math.Pow (ev.GetY () - startY, 2)); if (distance < pagingTouchSlop) return false; } startX = (int)ev.GetX (); startY = (int)ev.GetY (); isTracking = true; return true; }
public override bool OnInterceptTouchEvent (MotionEvent ev) { /* * This method JUST determines whether we want to intercept the motion. * If we return true, onTouchEvent will be called and we do the actual * scrolling there. */ // Begin tracking velocity even before we have intercepted touch events. if (mVelocityTracker == null) { mVelocityTracker = VelocityTracker.Obtain(); } mVelocityTracker.AddMovement(ev); /* * Shortcut the most recurring case: the user is in the dragging * state and he is moving his finger. We want to intercept this * motion. */ var action = ev.Action; if (mIsVerbose) { Log.Verbose(TAG, "onInterceptTouchEvent: " + (ev.Action & MotionEventActions.Mask)); } if (((action & MotionEventActions.Mask) == MotionEventActions.Move) && (mTouchState == TOUCH_STATE_SCROLLING)) { if (mIsVerbose) { Log.Verbose(TAG, "Intercepting touch events"); } return true; } switch (action & MotionEventActions.Mask) { case MotionEventActions.Move: { if (mLocked) { // we're locked on the current screen, don't allow moving break; } /* * Locally do absolute value. mDownMotionX is set to the y value * of the down event. */ int pointerIndex = MotionEventCompat.FindPointerIndex(ev, mActivePointerId); float x = MotionEventCompat.GetX(ev, pointerIndex); float y = MotionEventCompat.GetY(ev, pointerIndex); int xDiff = (int) Java.Lang.Math.Abs(x - mDownMotionX); int yDiff = (int) Java.Lang.Math.Abs(y - mDownMotionY); bool xPaged = xDiff > mPagingTouchSlop; bool xMoved = xDiff > mTouchSlop; bool yMoved = yDiff > mTouchSlop; if (xMoved || yMoved) { if (xPaged) { // Scroll if the user moved far enough along the X axis mTouchState = TOUCH_STATE_SCROLLING; } // Either way, cancel any pending longpress if (mAllowLongPress) { mAllowLongPress = false; // Try canceling the long press. It could also have been scheduled // by a distant descendant, so use the mAllowLongPress flag to block // everything View currentScreen = GetScreenAt(mCurrentScreen); if (currentScreen != null) { currentScreen.CancelLongPress(); } } } break; } case MotionEventActions.Down: { float x = ev.GetX(); float y = ev.GetY(); // Remember location of down touch mDownMotionX = x; mDownMotionY = y; mDownScrollX = ScrollX; mActivePointerId = MotionEventCompat.GetPointerId(ev, 0); mAllowLongPress = true; /* * If being flinged and user touches the screen, initiate drag; * otherwise don't. mScroller.isFinished should be false when * being flinged. */ mTouchState = mScroller.IsFinished ? TOUCH_STATE_REST : TOUCH_STATE_SCROLLING; break; } case MotionEventActions.Cancel: case MotionEventActions.Up: // Release the drag mTouchState = TOUCH_STATE_REST; mAllowLongPress = false; mActivePointerId = INVALID_POINTER; if (mVelocityTracker == null) { mVelocityTracker.Recycle(); mVelocityTracker = null; } break; case MotionEventActions.PointerUp: OnSecondaryPointerUp(ev); break; } /* * The only time we want to intercept motion events is if we are in the * drag mode. */ bool intercept = mTouchState != TOUCH_STATE_REST; if (mIsVerbose) { Log.Verbose(TAG, "Intercepting touch events: " + intercept); } return intercept; }
bool OnCancel (MotionEvent motionEvent) { if (_velocityTracker == null) { return false; } if (_downView != null && isSwiping) { AnimateDismissCancel (_downView); } _velocityTracker.Recycle (); _velocityTracker = null; mDownX = 0; mDownY = 0; _downView = null; _downPosition = AdapterView.InvalidPosition; isSwiping = false; return false; }
public override bool OnTouchEvent (MotionEvent ev) { if (mIsVerbose) { Log.Verbose(TAG, "onTouchEvent: " + ((int)ev.Action & MotionEventCompat.ActionMask)); } if (mVelocityTracker == null) { mVelocityTracker = VelocityTracker.Obtain(); } mVelocityTracker.AddMovement(ev); var action = ev.Action; switch ((int)action & MotionEventCompat.ActionMask) { case (int)MotionEventActions.Down: // If being flinged and user touches, stop the fling. isFinished // will be false if being flinged. if (!mScroller.IsFinished) { mScroller.AbortAnimation(); } // Remember where the motion event started mDownMotionX = ev.GetX(); mDownMotionY = ev.GetY(); mDownScrollX = ScrollX; mActivePointerId = MotionEventCompat.GetPointerId(ev, 0); break; case (int)MotionEventActions.Move: if (mIsVerbose) { Log.Verbose(TAG, "mTouchState=" + mTouchState); } if (mTouchState == TOUCH_STATE_SCROLLING) { // Scroll to follow the motion event int pointerIndex = MotionEventCompat.FindPointerIndex(ev, mActivePointerId); float x = MotionEventCompat.GetX(ev, pointerIndex); View lastChild = GetChildAt(ChildCount - 1); int maxScrollX = lastChild.Right - Width; ScrollTo(Math.Max(0, Math.Min(maxScrollX, (int)(mDownScrollX + mDownMotionX - x ))), 0); if (mOnScrollListener != null) { mOnScrollListener.OnScroll(GetCurrentScreenFraction()); } } else if (mTouchState == TOUCH_STATE_REST) { if (mLocked) { // we're locked on the current screen, don't allow moving break; } /* * Locally do absolute value. mLastMotionX is set to the y value * of the down event. */ int pointerIndex = MotionEventCompat.FindPointerIndex(ev, mActivePointerId); float x = MotionEventCompat.GetX(ev, pointerIndex); float y = MotionEventCompat.GetY(ev, pointerIndex); int xDiff = (int) Math.Abs(x - mDownMotionX); int yDiff = (int) Math.Abs(y - mDownMotionY); bool xPaged = xDiff > mPagingTouchSlop; bool xMoved = xDiff > mTouchSlop; bool yMoved = yDiff > mTouchSlop; if (xMoved || yMoved) { if (xPaged) { // Scroll if the user moved far enough along the X axis mTouchState = TOUCH_STATE_SCROLLING; } // Either way, cancel any pending longpress if (mAllowLongPress) { mAllowLongPress = false; // Try canceling the long press. It could also have been scheduled // by a distant descendant, so use the mAllowLongPress flag to block // everything View currentScreen = GetScreenAt(mCurrentScreen); if (currentScreen != null) { currentScreen.CancelLongPress(); } } } } break; case (int)MotionEventActions.Up: if (mTouchState == TOUCH_STATE_SCROLLING) { int activePointerId = mActivePointerId; int pointerIndex = MotionEventCompat.FindPointerIndex(ev, activePointerId); float x = MotionEventCompat.GetX(ev, pointerIndex); VelocityTracker velocityTracker = mVelocityTracker; velocityTracker.ComputeCurrentVelocity(1000, mMaximumVelocity); //TODO(minsdk8): int velocityX = (int) MotionEventUtils.getXVelocity(velocityTracker, activePointerId); int velocityX = (int) velocityTracker.XVelocity; bool isFling = Math.Abs(mDownMotionX - x) > MIN_LENGTH_FOR_FLING; float scrolledPos = GetCurrentScreenFraction(); int whichScreen = Math.Round(scrolledPos); if (isFling && mIsVerbose) { Log.Verbose(TAG, "isFling, whichScreen=" + whichScreen + " scrolledPos=" + scrolledPos + " mCurrentScreen=" + mCurrentScreen + " velocityX=" + velocityX); } if (isFling && velocityX > SNAP_VELOCITY && mCurrentScreen > 0) { // Fling hard enough to move left // Don't fling across more than one screen at a time. int bound = scrolledPos <= whichScreen ? mCurrentScreen - 1 : mCurrentScreen; SnapToScreen(Math.Min(whichScreen, bound)); } else if (isFling && velocityX < -SNAP_VELOCITY && mCurrentScreen < ChildCount - 1) { // Fling hard enough to move right // Don't fling across more than one screen at a time. int bound = scrolledPos >= whichScreen ? mCurrentScreen + 1 : mCurrentScreen; SnapToScreen(Math.Max(whichScreen, bound)); } else { SnapToDestination(); } } else { PerformClick(); } mTouchState = TOUCH_STATE_REST; mActivePointerId = INVALID_POINTER; // Can't do this -> // Intentially fall through to cancel mTouchState = TOUCH_STATE_REST; mActivePointerId = INVALID_POINTER; if (mVelocityTracker != null) { mVelocityTracker.Recycle(); mVelocityTracker = null; } break; case (int)MotionEventActions.Cancel: mTouchState = TOUCH_STATE_REST; mActivePointerId = INVALID_POINTER; if (mVelocityTracker != null) { mVelocityTracker.Recycle(); mVelocityTracker = null; } break; case (int)MotionEventCompat.ActionPointerUp: OnSecondaryPointerUp(ev); break; } return true; }
public override bool OnInterceptTouchEvent(MotionEvent ev) { if (!_enabled) return false; var action = (int) ev.Action & MotionEventCompat.ActionMask; #if DEBUG if (action == (int) MotionEventActions.Down) Log.Verbose(Tag, "Recieved ACTION_DOWN"); #endif if (action == (int) MotionEventActions.Cancel || action == (int) MotionEventActions.Up || (action != (int) MotionEventActions.Down && _isUnableToDrag)) { EndDrag(); return false; } switch (action) { case (int) MotionEventActions.Move: DetermineDrag(ev); break; case (int) MotionEventActions.Down: var index = MotionEventCompat.GetActionIndex(ev); ActivePointerId = MotionEventCompat.GetPointerId(ev, index); if (ActivePointerId == InvalidPointer) break; _lastMotionX = _initialMotionX = MotionEventCompat.GetX(ev, index); _lastMotionY = MotionEventCompat.GetY(ev, index); if (ThisTouchAllowed(ev)) { _isBeingDragged = false; _isUnableToDrag = false; if (IsMenuOpen && _viewBehind.MenuTouchInQuickReturn(_content, _curItem, ev.GetX() + _scrollX)) _quickReturn = true; } else _isUnableToDrag = true; break; case (int) MotionEventActions.PointerUp: OnSecondaryPointerUp(ev); break; } if (!_isBeingDragged) { if (VelocityTracker == null) VelocityTracker = VelocityTracker.Obtain(); VelocityTracker.AddMovement(ev); } return _isBeingDragged || _quickReturn; }
public override bool OnInterceptTouchEvent(MotionEvent e) { if (node.TouchEvents) { if (e.Action == MotionEventActions.Move || e.Action == MotionEventActions.Down || e.Action == MotionEventActions.Up) { if (e.Action == MotionEventActions.Down || velocity == null) velocity = VelocityTracker.Obtain (); node.Touch (new NodeTouchEvent (e, velocity)); if (e.Action == MotionEventActions.Up) velocity = null; } } return false; }
private void EndDrag() { _quickReturn = false; _isBeingDragged = false; _isUnableToDrag = false; ActivePointerId = InvalidPointer; if (VelocityTracker == null) return; VelocityTracker.Recycle(); VelocityTracker = null; }
private void stopTracking() { mHandle.Pressed = false; mTracking = false; if ( mOnDrawerScrollListener != null ) { mOnDrawerScrollListener.onScrollEnded(); } if ( mVelocityTracker != null ) { mVelocityTracker.Recycle(); mVelocityTracker = null; } }