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