コード例 #1
0
        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);
        }
コード例 #2
0
            public override bool OnTouchEvent(MotionEvent ev)
            {
                switch (ev.Action)
                {
                case MotionEventActions.Cancel:
                    #region Cancel
                    if (null != mVelocityTracker)
                    {
                        mVelocityTracker.Recycle();
                        mVelocityTracker = null;
                    }
                    #endregion
                    break;

                case MotionEventActions.Down:
                    #region Down
                    mVelocityTracker = VelocityTracker.Obtain();
                    mVelocityTracker.AddMovement(ev);

                    mLastTouchX = GetActiveX(ev);
                    mLastTouchY = GetActiveY(ev);
                    mIsDragging = false;
                    #endregion
                    break;

                case MotionEventActions.Move:
                    #region 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 = Math.Sqrt((dx * dx) + (dy * dy)) >= mTouchSlop;
                    }

                    if (mIsDragging)
                    {
                        mListener.OnDrag(dx, dy);
                        mLastTouchX = x;
                        mLastTouchY = y;

                        if (null != mVelocityTracker)
                        {
                            mVelocityTracker.AddMovement(ev);
                        }
                    }
                    #endregion
                    break;
                }

                return(true);
            }
コード例 #3
0
        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;
                }
            };
        }
コード例 #4
0
        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;
        }
コード例 #5
0
        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));
        }
コード例 #6
0
        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);
        }
コード例 #7
0
ファイル: InfoPane.cs プロジェクト: caodaiming/Moyeu
        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);
        }
コード例 #8
0
 private bool Down(MotionEvent motionEvent)
 {
     // TODO: ensure this is a finger, and set a flag
     _downX = motionEvent.RawX;
     _downY = motionEvent.RawY;
     if (_canDismiss(_token))
     {
         _pauseTimer(true);
         _velocityTracker = VelocityTracker.Obtain();
         _velocityTracker.AddMovement(motionEvent);
     }
     return(false);
 }
コード例 #9
0
        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);
        }
コード例 #10
0
        private bool Move(MotionEvent motionEvent)
        {
            _velocityTracker.AddMovement(motionEvent);
            var deltaX = motionEvent.RawX - _downX;
            var deltaY = motionEvent.RawY - _downY;

            if (Math.Abs(deltaX) > _slop && Math.Abs(deltaY) < Math.Abs(deltaX) / 2)
            {
                _swiping     = true;
                _swipingSlop = (deltaX > 0 ? _slop : -_slop);

                if (_view.Parent != null)
                {
                    _view.Parent.RequestDisallowInterceptTouchEvent(true);
                }

                // Cancel listview's touch
                var cancelEvent = MotionEvent.Obtain(motionEvent);
                cancelEvent.Action =
                    (MotionEventActions)
                    ((int)MotionEventActions.Cancel |
                     (motionEvent.ActionIndex << (int)MotionEventActions.PointerIndexShift));

                _view.OnTouchEvent(cancelEvent);
                cancelEvent.Recycle();
            }

            if (_swiping)
            {
                _translationX      = deltaX;
                _view.TranslationX = deltaX - _swipingSlop;
                // TODO: use an ease-out interpolator or such
                _view.Alpha = Math.Max(0f, Math.Min(1f, 1f - 2f * Math.Abs(deltaX) / _viewWidth));
                return(true);
            }
            return(false);
        }
コード例 #11
0
ファイル: DragLayout.cs プロジェクト: dove-team/Xam.Plugins
 private void HandleTouchEvent(MotionEvent @event)
 {
     velocityTracker.AddMovement(@event);
     gestureHelper.OnTouchEvent(@event);
     if (@event.Action == MotionEventActions.Down)
     {
         touching = true;
         ResetTouchStart(@event.GetX(), @event.GetY());
         if (!layerScroller.IsFinished)
         {
             layerScroller.AbortAnimation();
         }
     }
     else if (@event.Action == MotionEventActions.Up || @event.Action == MotionEventActions.Cancel)
     {
         touching = false;
     }
 }
コード例 #12
0
        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);
        }
コード例 #13
0
        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;
            }
        }
コード例 #14
0
        public override bool OnTouchEvent(MotionEvent ev)
        {
            var hist   = 0.0f;
            var deltaY = 0.0f;
            var listY  = 0.0f;

            _historyEvent = ev;
            vT.AddMovement(ev);
            if (_overscrolling)
            {
                var firstOverscroll = _firstOverscroll;
                _firstOverscroll = false;
                if (ev.Action == MotionEventActions.Move && ev.HistorySize >= 1)
                {
                    hist   = ev.GetHistoricalY(0, 0);
                    deltaY = ev.GetY() - hist;
                    listY  = _listView.GetY();

                    if (_header != null)
                    {
                        var headerY = _header.GetY();
                        if (deltaY > 0)
                        {
                            if ((int)Math.Ceiling(headerY) == (0))
                            {
                                return(_listView.DispatchTouchEvent(ev));
                            }

                            if (headerY + deltaY <= (0))
                            {
                                UpdateHeaderPosition(deltaY);
                                _listView.SetY(_listView.GetY() + deltaY);
                                _listView.LayoutParameters.Height = (int)Math.Ceiling(_listView.LayoutParameters.Height + deltaY);
                                _listView.Invalidate();
                                return(true);
                            }
                            if (headerY + deltaY > 0)
                            {
                                deltaY = 0 - headerY;
                                UpdateHeaderPosition(0 - headerY);
                                _listView.SetY(_listView.GetY() + deltaY);
                                _listView.LayoutParameters.Height = (int)Math.Ceiling(_listView.LayoutParameters.Height + deltaY);
                                _listView.Invalidate();
                                return(true);
                            }
                        }
                        if (deltaY < 0)
                        {
                            _overscrolling = false;
                        }
                    }


                    if (listY + deltaY <= 0)
                    {
                        deltaY         = 0 - listY;
                        _overscrolling = false;
                    }
                    else if (deltaY > 0)
                    {
                        deltaY *= 0.4f;
                    }
                    Log.Info("OverScrollingIntercept", "{0}", deltaY);
                    _listView.SetY(_listView.GetY() + deltaY);
                    _lastHistory = ev.HistorySize;
                }
                else if (ev.Action == MotionEventActions.Up)
                {
                    _overscrolling = false;
                    _lastHistory   = 0;
                    _listView.Animate().Y(_header != null ? _header.Height : 0.0f).SetDuration(250).Start();
                }


                Log.Info("Interceptor", "Overscrolling True");
                return(true);
            }
            var hitRect = new Rect();

            _header.GetHitRect(hitRect);

            if (hitRect.Contains((int)Math.Ceiling(ev.GetX()), (int)Math.Ceiling(ev.GetY())))
            {
                return(_header.DispatchTouchEvent(ev));
            }
            else
            {
                if (_header != null)
                {
                    var headerY = _header.GetY();
                    if (ev.Action == MotionEventActions.Move && ev.HistorySize >= 1)
                    {
                        hist   = ev.GetHistoricalY(0, 0);
                        deltaY = ev.GetY() - hist;

                        if (deltaY < 0)
                        {
                            if ((int)Math.Ceiling(headerY) == (0 - _header.Height))
                            {
                                return(_listView.DispatchTouchEvent(ev));
                            }

                            if (headerY + deltaY >= (0 - _header.Height))
                            {
                                UpdateHeaderPosition(deltaY);
                                _listView.SetY(_listView.GetY() + deltaY);
                                _listView.LayoutParameters.Height = (int)Math.Ceiling(_listView.LayoutParameters.Height - deltaY);
                                _listView.RequestLayout();
                                return(true);
                            }
                            else if (headerY + deltaY < (0 - _header.Height))
                            {
                                deltaY = 0 - (headerY + _header.Height);
                                UpdateHeaderPosition(deltaY);
                                _listView.SetY(_listView.GetY() + deltaY);
                                _listView.LayoutParameters.Height = (int)Math.Ceiling(_listView.LayoutParameters.Height - deltaY);
                                _listView.RequestLayout();
                                _listView.DispatchTouchEvent(ev);
                                return(true);
                            }
                        }
                        _listView.DispatchTouchEvent(ev);
                        return(true);
                    }
                    else if (ev.Action == MotionEventActions.Up || ev.Action == MotionEventActions.Cancel)
                    {
                        vT.ComputeCurrentVelocity(1);
                        long duration = Math.Abs((long)Math.Ceiling(Math.Abs(_header.Height) / vT.GetYVelocity(0)));

                        if (duration < 750)
                        {
                            _header.Animate()
                            .Y(0 - _header.Height)
                            .SetDuration(duration)
                            .SetInterpolator(new DecelerateInterpolator(1.0f))
                            .Start();
                            _listView.Animate()
                            .Y(0)
                            .SetDuration(duration)
                            .SetInterpolator(new DecelerateInterpolator(1.0f))
                            .Start();
                        }
                        return(_listView.DispatchTouchEvent(ev));
                    }
                }
                return(_listView.DispatchTouchEvent(ev));
            }
        }
コード例 #15
0
        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);
        }
コード例 #16
0
        public override bool OnInterceptTouchEvent(MotionEvent ev)
        {
            if (!mEnabled)
            {
                return(false);
            }

            MotionEventActions action = ev.Action & (MotionEventActions)MotionEventCompat.ActionMask;

            if (DEBUG)
            {
                if (action == MotionEventActions.Down)
                {
                    Console.WriteLine(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 = mInitialMotionX = MotionEventCompat.GetX(ev, index);
                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);
        }
コード例 #17
0
ファイル: ScrollHelper.cs プロジェクト: dove-team/Xam.Plugins
        /// <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;
            }
            }
        }
コード例 #18
0
        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);
        }
コード例 #19
0
        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);
        }
コード例 #20
0
        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);
        }
コード例 #21
0
        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);
        }
コード例 #22
0
ファイル: TrackingView.cs プロジェクト: taori/PCRemote2
        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);
        }
コード例 #23
0
        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);
        }
コード例 #24
0
        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);
        }
コード例 #25
0
        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);
        }