public bool onTouch(MotionEvent ev) { if (velocityTracker == null) { velocityTracker = VelocityTracker.Obtain(); } velocityTracker.AddMovement(ev); if (ev.Action == MotionEventActions.Down) { if (!scroller.IsFinished) { scroller.AbortAnimation(); } isSmoothScrolling = false; } else if (ev.Action == MotionEventActions.Move) { velocityTracker.AddMovement(ev); velocityTracker.ComputeCurrentVelocity(500); } else if (ev.Action == MotionEventActions.Up) { handleHorizontalScrolling(); velocityTracker.Recycle(); velocityTracker.Clear(); velocityTracker = null; isScrolling = false; } return(false); }
public override bool OnTouchEvent(MotionEvent ev) { if (ev.Action == MotionEventActions.Move) { tracker.AddMovement(ev); } if (ev.Action == MotionEventActions.Up) { tracker.ComputeCurrentVelocity(1000); var velocity = tracker.XVelocity; Console.WriteLine("Velocity: " + velocity); tracker.Clear(); if (Math.Abs(velocity) > 1000) { timer = new System.Timers.Timer(125); timer.Start(); timer.Elapsed += delegate { CallHandler(); timer.Stop(); timer.Dispose(); timer = null; }; } else { CallHandler(); } } return(base.OnTouchEvent(ev)); }
private void Up(MotionEvent motionEvent) { if (_velocityTracker == null) { return; } _pauseTimer(false); var deltaX = motionEvent.RawX - _downX; _velocityTracker.AddMovement(motionEvent); _velocityTracker.ComputeCurrentVelocity(1000); var velocityX = _velocityTracker.XVelocity; var absVelocityX = Math.Abs(velocityX); var absVelocityY = Math.Abs(_velocityTracker.YVelocity); var dismiss = false; var dismissRight = false; if (Math.Abs(deltaX) > _viewWidth / 2 && _swiping) { dismiss = true; dismissRight = deltaX > 0; } else if (_minFlingVelocity <= absVelocityX && absVelocityX <= _maxFlingVelocity && absVelocityY < absVelocityX && absVelocityY < absVelocityX && _swiping) { // dismiss only if flinging in the same direction as dragging dismiss = (velocityX < 0) == (deltaX < 0); dismissRight = _velocityTracker.XVelocity > 0; } if (dismiss) { // dismiss _view.Animate() .TranslationX(dismissRight ? _viewWidth : -_viewWidth) .Alpha(0) .SetDuration(_animationTime) .SetListener(this); } else if (_swiping) { // cancel _view.Animate() .TranslationX(0) .Alpha(1) .SetDuration(_animationTime) .SetListener(null); } if (_velocityTracker != null) { _velocityTracker.Recycle(); _velocityTracker = null; } _translationX = 0; _downX = 0; _downY = 0; _swiping = false; }
private void ListViewOnOnOverscrolled(object sender, OverscrollListenerListViewEventArgs overscrollListenerListViewEventArgs) { if (overscrollListenerListViewEventArgs.DeltaY < 0) { _overscrolling = true; vT.ComputeCurrentVelocity(1); if (_header != null && (int)Math.Ceiling(_header.GetY()) != 0 && _historyEvent.Action == MotionEventActions.Up || _historyEvent.Action == MotionEventActions.Cancel) { long duration = (long)Math.Ceiling(Math.Abs(_header.Height) / vT.GetYVelocity(0)); _header.Animate().Y(0).SetDuration(duration).SetInterpolator(new DecelerateInterpolator(1.0f)).Start(); _listView.Animate().Y(_header.Height).SetDuration(duration).SetInterpolator(new DecelerateInterpolator(1.0f)).Start(); } } else { _overscrolling = false; } }
protected override void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); // Set our view from the "main" layout resource SetContentView(Resource.Layout.Main); FindViewById(Android.Resource.Id.Content).SystemUiVisibility = (StatusBarVisibility)(SystemUiFlags.LayoutStable | SystemUiFlags.LayoutFullscreen | SystemUiFlags.HideNavigation); stiffness = FindViewById <SeekBar>(Resource.Id.stiffness); damping = FindViewById <SeekBar>(Resource.Id.damping); velocityTracker = VelocityTracker.Obtain(); View box = FindViewById(Resource.Id.box); box.Touch += (sender, args) => { switch (args.Event.Action) { case MotionEventActions.Down: downX = args.Event.GetX(); downY = args.Event.GetY(); velocityTracker.AddMovement(args.Event); break; case MotionEventActions.Move: box.TranslationX = args.Event.GetX() - downX; box.TranslationY = args.Event.GetY() - downY; velocityTracker.AddMovement(args.Event); break; case MotionEventActions.Up: case MotionEventActions.Cancel: velocityTracker.ComputeCurrentVelocity(1000); if (box.TranslationX != 0) { SpringAnimation animX = new SpringAnimation(box, DynamicAnimation.TranslationX, 0); animX.Spring.SetStiffness(Stiffness); animX.Spring.SetDampingRatio(Damping); animX.SetStartVelocity(velocityTracker.XVelocity); animX.Start(); } if (box.TranslationY != 0) { SpringAnimation animY = new SpringAnimation(box, DynamicAnimation.TranslationY, 0); animY.Spring.SetStiffness(Stiffness); animY.Spring.SetDampingRatio(Damping); animY.SetStartVelocity(velocityTracker.YVelocity); animY.Start(); } velocityTracker.Clear(); break; } }; }
public bool OnTouch(View view, MotionEvent motionEvent) { if (mViewWidth < 2) { mViewWidth = mListView.Width; } switch (motionEvent.ActionMasked) { case MotionEventActions.Down: if (mPaused) { return(false); } // TODO: ensure this is a finger, and set a flag // Find the child view that was touched (perform a hit test) Rect rect = new Rect(); int childCount = mListView.ChildCount; int[] listViewCoords = new int[2]; mListView.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 = mListView.GetChildAt(i); child.GetHitRect(rect); if (rect.Contains(x, y)) { mDownView = child; break; } } if (mDownView != null) { mDownX = motionEvent.RawX; mDownY = motionEvent.RawY; mDownPosition = mListView.GetPositionForView(mDownView); if (mCallbacks.canDismiss(mDownPosition)) { mVelocityTracker = VelocityTracker.Obtain(); mVelocityTracker.AddMovement(motionEvent); } else { mDownView = null; } } return(false); case MotionEventActions.Cancel: { if (mVelocityTracker == null) { break; } if (mDownView != null && mSwiping) { // cancel mDownView.Animate() .TranslationX(0) .Alpha(1) .SetDuration(mAnimationTime) .SetListener(null); } mVelocityTracker.Recycle(); mVelocityTracker = null; mDownX = 0; mDownY = 0; mDownView = null; mDownPosition = ListView.InvalidPosition; mSwiping = false; break; } case MotionEventActions.Up: { if (mVelocityTracker == null) { break; } float deltaX = motionEvent.RawX - mDownX; mVelocityTracker.AddMovement(motionEvent); mVelocityTracker.ComputeCurrentVelocity(1000); float velocityX = mVelocityTracker.XVelocity; float absVelocityX = Math.Abs(velocityX); float absVelocityY = Math.Abs(mVelocityTracker.YVelocity); bool dismiss = false; bool dismissRight = false; if (Math.Abs(deltaX) > mViewWidth / 2) { dismiss = true; dismissRight = deltaX > 0; } else if (mMinFlingVelocity <= absVelocityX && absVelocityX <= mMaxFlingVelocity && absVelocityY < absVelocityX && mSwiping) { // dismiss only if flinging in the same direction as dragging dismiss = (velocityX < 0) == (deltaX < 0); dismissRight = mVelocityTracker.XVelocity > 0; } if (dismiss && mDownPosition != ListView.InvalidPosition) { // dismiss View downView = mDownView; // mDownView gets null'd before animation ends int downPosition = mDownPosition; ++mDismissAnimationRefCount; var anim = mDownView.Animate() .TranslationX(dismissRight ? mViewWidth : -mViewWidth) .Alpha(0) .SetDuration(mAnimationTime) .SetListener(new DownAnimatorListenerAdapter(this, downView, downPosition)); } else { // cancel mDownView.Animate() .TranslationX(0) .Alpha(1) .SetDuration(mAnimationTime) .SetListener(null); } mVelocityTracker.Recycle(); mVelocityTracker = null; mDownX = 0; mDownY = 0; mDownView = null; mDownPosition = ListView.InvalidPosition; mSwiping = false; break; } case MotionEventActions.Move: { if (mVelocityTracker == null || mPaused) { break; } mVelocityTracker.AddMovement(motionEvent); float deltaX = motionEvent.RawX - mDownX; float deltaY = motionEvent.RawY - mDownY; if (Math.Abs(deltaX) > mSlop && Math.Abs(deltaY) < Math.Abs(deltaX) / 2) { mSwiping = true; mSwipingSlop = (deltaX > 0 ? mSlop : -mSlop); mListView.RequestDisallowInterceptTouchEvent(true); // Cancel ListView's touch (un-highlighting the item) MotionEvent cancelEvent = MotionEvent.Obtain(motionEvent); cancelEvent.Action = (Android.Views.MotionEventActions)((int)MotionEventActions.Cancel | ((int)motionEvent.ActionIndex << (int)MotionEventActions.PointerIndexShift)); mListView.OnTouchEvent(cancelEvent); cancelEvent.Recycle(); } if (mSwiping) { mDownView.TranslationX = deltaX - mSwipingSlop; mDownView.Alpha = Math.Max(0f, Math.Min(1f, 1f - 2f * Math.Abs(deltaX) / mViewWidth)); return(true); } break; } } return(false); }
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 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 = LeftBound; float rightBound = RightBound; 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)) / BehindWidth; 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 CurrentItem = 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); }
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 DispatchTouchEvent(MotionEvent e) { var index = e.ActionIndex; var action = e.ActionMasked; var pointerId = e.GetPointerId(index); switch (action & MotionEventActions.Mask) { case MotionEventActions.PointerDown: MultiTouchGesture?.Invoke(this, EventArgs.Empty); break; case MotionEventActions.Up: if ((DateTime.Now - _downTime).TotalMilliseconds < 200) { SingleTapGesture?.Invoke(this, EventArgs.Empty); } break; } switch (action) { case MotionEventActions.Down: _downTime = DateTime.Now; if (_velocityTracker == null) { _velocityTracker = VelocityTracker.Obtain(); } else { // Reset the velocity tracker back to its initial state. _velocityTracker.Clear(); } if (IfVelocityTrackerIsNull()) { return(true); } _velocityTracker.AddMovement(e); break; case MotionEventActions.Move: if (IfVelocityTrackerIsNull()) { return(true); } _velocityTracker.AddMovement(e); _velocityTracker.ComputeCurrentVelocity(Sensitivity); TryExportVelocity(_velocityTracker.GetXVelocity(pointerId), _velocityTracker.GetYVelocity(pointerId)); break; case MotionEventActions.Up: case MotionEventActions.Cancel: if (IfVelocityTrackerIsNull()) { return(true); } _velocityTracker.Recycle(); _velocityTracker = null; break; } return(true); }
public override bool OnTouchEvent(MotionEvent @event) { if (@event.Action == MotionEventActions.Up) { PerformClick(); } HandleTouchEvent(@event); var resetTouch = false; var vertical = false; var horizontal = false; switch (gestureHelper.Gesture) { case GestureHelper.GESTURE_RIGHT: case GestureHelper.GESTURE_LEFT: if (LayerScrollY != 0) { vertical = true; } else { horizontal = true; } break; case GestureHelper.GESTURE_DOWN: case GestureHelper.GESTURE_UP: if (LayerScrollX != 0) { horizontal = true; } else { vertical = true; } break; default: if (@event.Action == MotionEventActions.Up || @event.Action == MotionEventActions.Cancel) { ReleaseTouch(); } break; } if (vertical) { float rangeY = @event.GetY() - touchStartY; int dy = (int)(touchScrollStartY - rangeY); if (!CanVerticalScrollTo(dy)) { resetTouch = true; if (dy < 0) { dy = VerticalLayerScrollMin; } else if (dy > 0) { dy = VerticalLayerScrollMax; } } if (touchScrollable) { LayerScrollTo(LayerScrollX, dy); } if (@event.Action == MotionEventActions.Up || @event.Action == MotionEventActions.Cancel) { velocityTracker.ComputeCurrentVelocity(1000); if (LayerScrollY < 0) { if (velocityTracker.YVelocity > 0) { if (CanOpenTop(velocityTracker.XVelocity, velocityTracker.YVelocity)) { SmoothLayerScrollTo(LayerScrollX, VerticalLayerScrollMin); } else { SmoothLayerScrollTo(0, 0); } } else { SmoothLayerScrollTo(0, 0); } } else if (LayerScrollY > 0) { if (velocityTracker.YVelocity < 0) { if (CanOpenBottom(velocityTracker.XVelocity, velocityTracker.YVelocity)) { SmoothLayerScrollTo(LayerScrollX, VerticalLayerScrollMax); } else { SmoothLayerScrollTo(0, 0); } } else { SmoothLayerScrollTo(0, 0); } } } } else if (horizontal) { float rangeX = @event.GetX() - touchStartX; int dx = (int)(touchScrollStartX - rangeX); if (!CanHorizontalScrollTo(dx)) { resetTouch = true; if (dx < 0) { dx = HorizontalLayerScrollMin; } else if (dx > 0) { dx = HorizontalLayerScrollMax; } } if (touchScrollable) { LayerScrollTo(dx, ScrollY); } if (@event.Action == MotionEventActions.Up || @event.Action == MotionEventActions.Cancel) { velocityTracker.ComputeCurrentVelocity(1000); if (LayerScrollX < 0) { if (velocityTracker.XVelocity > 0) { if (CanOpenLeft(velocityTracker.XVelocity, velocityTracker.YVelocity)) { SmoothLayerScrollTo(HorizontalLayerScrollMin, LayerScrollY); } else { SmoothLayerScrollTo(0, 0); } } else { SmoothLayerScrollTo(0, 0); } } else if (LayerScrollX > 0) { if (velocityTracker.XVelocity < 0) { if (CanOpenRight(velocityTracker.XVelocity, velocityTracker.YVelocity)) { SmoothLayerScrollTo(HorizontalLayerScrollMax, LayerScrollY); } else { SmoothLayerScrollTo(0, 0); } } else { SmoothLayerScrollTo(0, 0); } } } } if (resetTouch) { ResetTouchStart(@event.GetX(), @event.GetY()); } return(true); }
/// <summary> /// 触发触摸事件 /// </summary> /// <param name="event">事件</param> public void OnTouchEvent(MotionEvent @event) { GestureHelper.OnTouchEvent(@event); VelocityTracker.AddMovement(@event); switch (@event.Action) { case MotionEventActions.Down: { SetStartPosition(@event.GetX(), @event.GetY()); break; } case MotionEventActions.Move: { if (CanScroll) { float rangeX = @event.GetX() - startTouchX; float rangeY = @event.GetY() - startTouchY; int dstX = (int)(startScrollX - rangeX); int dstY = (int)(startScrollY - rangeY); if (dstX < GetMinHorizontallyScroll) { dstX = 0; startTouchX = @event.GetX(); startScrollX = dstX; } else if (dstX > GetMaxHorizontallyScroll) { dstX = GetViewHorizontallyScrollSize(); startTouchX = @event.GetX(); startScrollX = dstX; } if (dstY < GetMinVerticallyScroll) { dstY = 0; startTouchY = @event.GetY(); startScrollY = dstY; } else if (dstY > GetMaxVerticallyScroll) { dstY = GetViewVerticallyScrollSize(); startTouchY = @event.GetY(); startScrollY = dstY; } ViewScrollTo(dstX, dstY); } break; } case MotionEventActions.Up: case MotionEventActions.Cancel: { VelocityTracker.ComputeCurrentVelocity(1000); if (CanScroll) { float xv = VelocityTracker.XVelocity; float yv = VelocityTracker.YVelocity; ViewFling(xv, yv); } break; } } }
public override bool OnTouchEvent(MotionEvent ev) { if (ev.Action == MotionEventActions.Down && ev.EdgeFlags != 0) { // Don't handle edge touches immediately -- they may actually belong to one of our // descendants. return(false); } if (!CanScroll) { return(false); } if (mVelocityTracker == null) { mVelocityTracker = VelocityTracker.Obtain(); } mVelocityTracker.AddMovement(ev); MotionEventActions action = ev.Action; float y = ev.GetY(); float 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 (!mScroller.IsFinished) { mScroller.AbortAnimation(); } // Remember where the motion event started mLastMotionY = y; mLastMotionX = x; break; case MotionEventActions.Move: // Scroll to follow the motion event int deltaX = (int)(mLastMotionX - x); int deltaY = (int)(mLastMotionY - y); mLastMotionX = x; mLastMotionY = y; if (deltaX < 0) { if (ScrollX < 0) { deltaX = 0; } } else if (deltaX > 0) { int rightEdge = Width - PaddingRight; int availableToScroll = GetChildAt(0).Right - ScrollX - rightEdge; if (availableToScroll > 0) { deltaX = System.Math.Min(availableToScroll, deltaX); } else { deltaX = 0; } } if (deltaY < 0) { if (ScrollY < 0) { deltaY = 0; } } else if (deltaY > 0) { int bottomEdge = Height - PaddingBottom; int availableToScroll = GetChildAt(0).Bottom - ScrollY - bottomEdge; if (availableToScroll > 0) { deltaY = System.Math.Min(availableToScroll, deltaY); } else { deltaY = 0; } } if (deltaY != 0 || deltaX != 0) { ScrollBy(deltaX, deltaY); } break; case MotionEventActions.Up: VelocityTracker velocityTracker = mVelocityTracker; velocityTracker.ComputeCurrentVelocity(1000, mMaximumVelocity); int initialXVelocity = (int)velocityTracker.XVelocity; int initialYVelocity = (int)velocityTracker.YVelocity; if ((System.Math.Abs(initialXVelocity) + System.Math.Abs(initialYVelocity) > mMinimumVelocity) && ChildCount > 0) { Fling(-initialXVelocity, -initialYVelocity); } if (mVelocityTracker != null) { mVelocityTracker.Recycle(); mVelocityTracker = null; } break; } return(true); }
public override bool OnTouchEvent(MotionEvent e) { if (mLocked) { return(true); } if (mTracking) { mVelocityTracker.AddMovement(e); MotionEventActions action = e.Action; switch (action) { case MotionEventActions.Move: moveHandle((int)(mVertical ? e.GetY() : e.GetX()) - mTouchDelta); break; case MotionEventActions.Up: case MotionEventActions.Cancel: { VelocityTracker velocityTracker = mVelocityTracker; velocityTracker.ComputeCurrentVelocity(mVelocityUnits); float yVelocity = velocityTracker.YVelocity; float xVelocity = velocityTracker.XVelocity; Boolean negative; Boolean vertical = mVertical; if (vertical) { negative = yVelocity < 0; if (xVelocity < 0) { xVelocity = -xVelocity; } // fix by Maciej Ciemięga. if ((!mInvert && xVelocity > mMaximumMinorVelocity) || (mInvert && xVelocity < mMaximumMinorVelocity)) { xVelocity = mMaximumMinorVelocity; } } else { negative = xVelocity < 0; if (yVelocity < 0) { yVelocity = -yVelocity; } // fix by Maciej Ciemięga. if ((!mInvert && yVelocity > mMaximumMinorVelocity) || (mInvert && yVelocity < mMaximumMinorVelocity)) { yVelocity = mMaximumMinorVelocity; } } float velocity = (float)Java.Lang.Math.Hypot(xVelocity, yVelocity); if (negative) { velocity = -velocity; } int handleTop = mHandle.Top; int handleLeft = mHandle.Left; int handleBottom = mHandle.Bottom; int handleRight = mHandle.Right; if (Math.Abs(velocity) < mMaximumTapVelocity) { Boolean c1; Boolean c2; Boolean c3; Boolean c4; if (mInvert) { c1 = (mExpanded && (Bottom - handleBottom) < mTapThreshold + mBottomOffset); c2 = (!mExpanded && handleTop < mTopOffset + mHandleHeight - mTapThreshold); c3 = (mExpanded && (Right - handleRight) < mTapThreshold + mBottomOffset); c4 = (!mExpanded && handleLeft > mTopOffset + mHandleWidth + mTapThreshold); } else { c1 = (mExpanded && handleTop < mTapThreshold + mTopOffset); c2 = (!mExpanded && handleTop > mBottomOffset + Bottom - Top - mHandleHeight - mTapThreshold); c3 = (mExpanded && handleLeft < mTapThreshold + mTopOffset); c4 = (!mExpanded && handleLeft > mBottomOffset + Right - Left - mHandleWidth - mTapThreshold); } if (vertical ? c1 || c2 : c3 || c4) { if (mAllowSingleTap) { PlaySoundEffect(SoundEffects.Click); if (mExpanded) { animateClose(vertical ? handleTop : handleLeft); } else { animateOpen(vertical ? handleTop : handleLeft); } } else { performFling(vertical ? handleTop : handleLeft, velocity, false); } } else { performFling(vertical ? handleTop : handleLeft, velocity, false); } } else { performFling(vertical ? handleTop : handleLeft, velocity, false); } } break; } } return(mTracking || mAnimating || base.OnTouchEvent(e)); }
public override bool OnTouchEvent(MotionEvent e) { if (mVelocityTracker == null) { mVelocityTracker = VelocityTracker.Obtain(); } mVelocityTracker.AddMovement(e); MotionEventActions action = e.Action; if (action == MotionEventActions.Down) { x = e.GetX(); if (IsSlided()) { dispatched = DispatchTouchEventToView(GetChildAt(0), e); } else { dispatched = DispatchTouchEventToView(GetChildAt(1), e); } } else if (action == MotionEventActions.Move) { if (dispatched) { if (IsSlided()) { DispatchTouchEventToView(GetChildAt(0), e); } else { DispatchTouchEventToView(GetChildAt(1), e); } } else { float dx = e.GetX() - x; View view = this.GetChildAt(1); int left = (int)(view.Left + dx); if (left >= 0) { view.Layout(left, view.Top, view.Width + left, view.Top + view.Height); } } x = e.GetX(); } else if (action == MotionEventActions.Cancel || action == MotionEventActions.Up) { if (dispatched) { if (IsSlided()) { DispatchTouchEventToView(GetChildAt(0), e); } else { DispatchTouchEventToView(GetChildAt(1), e); } } else { mVelocityTracker.ComputeCurrentVelocity(1000); int velocityX = (int)mVelocityTracker.GetXVelocity(0); if (velocityX > VELOCITY_X_SPEED) { SetSlided(true); } else if (velocityX < -VELOCITY_X_SPEED) { SetSlided(false); } else { View view = GetChildAt(1); if (view.Left >= view.Width / 2) { SetSlided(true); } else { SetSlided(false); } } if (mVelocityTracker != null) { try { mVelocityTracker.Recycle(); } catch { } } } } else if (!IsSlided()) { DispatchTouchEventToView(GetChildAt(1), e); } return(true); }
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); }
public override bool OnTouchEvent(MotionEvent ev) { if (_mVelocityTracker == null) { _mVelocityTracker = VelocityTracker.Obtain(); } _mVelocityTracker.AddMovement(ev); MotionEventActions action = ev.Action; float 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 (!_mScroller.IsFinished) { _mScroller.AbortAnimation(); } // Remember where the motion event started _mLastMotionX = x; _mTouchState = _mScroller.IsFinished ? TOUCH_STATE_REST : TOUCH_STATE_HORIZONTAL_SCROLLING; break; case MotionEventActions.Move: var xDiff = (int)Math.Abs(x - _mLastMotionX); bool xMoved = xDiff > _mTouchSlop; if (xMoved) { // Scroll if the user moved far enough along the X axis _mTouchState = TOUCH_STATE_HORIZONTAL_SCROLLING; } if (_mTouchState == TOUCH_STATE_HORIZONTAL_SCROLLING) { // Scroll to follow the motion event var deltaX = (int)(_mLastMotionX - x); _mLastMotionX = x; int scrollX = ScrollX; if (deltaX < 0) { if (scrollX > 0) { ScrollBy(Math.Max(-scrollX, deltaX), 0); } } else if (deltaX > 0) { int availableToScroll = GetChildAt(ChildCount - 1).Right - scrollX - Width; if (availableToScroll > 0) { ScrollBy(Math.Min(availableToScroll, deltaX), 0); } } } break; case MotionEventActions.Up: if (_mTouchState == TOUCH_STATE_HORIZONTAL_SCROLLING) { VelocityTracker velocityTracker = _mVelocityTracker; velocityTracker.ComputeCurrentVelocity(VELOCITY_UNIT_PIXELS_PER_SECOND, _mMaximumVelocity); var velocityX = (int)velocityTracker.XVelocity; if (velocityX > mDensityAdjustedSnapVelocity && _mCurrentScreen > 0) { // Fling hard enough to move left SnapToScreen(_mCurrentScreen - 1); } else if (velocityX < -mDensityAdjustedSnapVelocity && _mCurrentScreen < ChildCount - 1) { // Fling hard enough to move right 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; } return(true); }