private void setContext(android.view.MotionEvent curr) { if (mCurrEvent != null) { mCurrEvent.recycle(); } mCurrEvent = android.view.MotionEvent.obtain(curr); mCurrLen = -1; mPrevLen = -1; mScaleFactor = -1; android.view.MotionEvent prev = mPrevEvent; int prevIndex0 = prev.findPointerIndex(mActiveId0); int prevIndex1 = prev.findPointerIndex(mActiveId1); int currIndex0 = curr.findPointerIndex(mActiveId0); int currIndex1 = curr.findPointerIndex(mActiveId1); if (prevIndex0 < 0 || prevIndex1 < 0 || currIndex0 < 0 || currIndex1 < 0) { mInvalidGesture = true; android.util.Log.e(TAG, "Invalid MotionEvent stream detected.", new System.Exception ()); if (mGestureInProgress) { mListener.onScaleEnd(this); } return; } float px0 = prev.getX(prevIndex0); float py0 = prev.getY(prevIndex0); float px1 = prev.getX(prevIndex1); float py1 = prev.getY(prevIndex1); float cx0 = curr.getX(currIndex0); float cy0 = curr.getY(currIndex0); float cx1 = curr.getX(currIndex1); float cy1 = curr.getY(currIndex1); float pvx = px1 - px0; float pvy = py1 - py0; float cvx = cx1 - cx0; float cvy = cy1 - cy0; mPrevFingerDiffX = pvx; mPrevFingerDiffY = pvy; mCurrFingerDiffX = cvx; mCurrFingerDiffY = cvy; mFocusX = cx0 + cvx * 0.5f; mFocusY = cy0 + cvy * 0.5f; mTimeDelta = curr.getEventTime() - prev.getEventTime(); mCurrPressure = curr.getPressure(currIndex0) + curr.getPressure(currIndex1); mPrevPressure = prev.getPressure(prevIndex0) + prev.getPressure(prevIndex1); }
/// <summary>MotionEvent has no getRawX(int) method; simulate it pending future API approval. /// </summary> /// <remarks>MotionEvent has no getRawX(int) method; simulate it pending future API approval. /// </remarks> private static float getRawX(android.view.MotionEvent @event, int pointerIndex) { if (pointerIndex < 0) { return(float.MinValue); } if (pointerIndex == 0) { return(@event.getRawX()); } float offset = @event.getRawX() - @event.getX(); return(@event.getX(pointerIndex) + offset); }
internal virtual bool onInterceptTouchEvent(android.view.MotionEvent ev) { switch (ev.getActionMasked()) { case android.view.MotionEvent.ACTION_DOWN: { if (mState > STATE_NONE && isPointInside(ev.getX(), ev.getY())) { if (!mList.isInScrollingContainer()) { beginDrag(); return(true); } mInitialTouchY = ev.getY(); startPendingDrag(); } break; } case android.view.MotionEvent.ACTION_UP: case android.view.MotionEvent.ACTION_CANCEL: { cancelPendingDrag(); break; } } return(false); }
private void trackTouchEvent(android.view.MotionEvent @event) { int width = getWidth(); int available = width - mPaddingLeft - mPaddingRight; int x = (int)@event.getX(); float scale; float progress = 0; if (x < mPaddingLeft) { scale = 0.0f; } else { if (x > width - mPaddingRight) { scale = 1.0f; } else { scale = (float)(x - mPaddingLeft) / (float)available; progress = mTouchProgressOffset; } } int max = getMax(); progress += scale * max; setProgress((int)progress, true); }
public override bool dispatchTouchEvent(android.view.MotionEvent ev) { if (mDefaultTouchRecepient == null) { return(base.dispatchTouchEvent(ev)); } if (base.dispatchTouchEvent(ev)) { return(true); } mTempRect.set(0, 0, 0, 0); offsetRectIntoDescendantCoords(mDefaultTouchRecepient, mTempRect); ev.setLocation(ev.getX() + mTempRect.left, ev.getY() + mTempRect.top); return(mDefaultTouchRecepient.dispatchTouchEvent(ev)); }
private bool isConsideredDoubleTap(android.view.MotionEvent firstDown, android.view.MotionEvent firstUp, android.view.MotionEvent secondDown) { if (!mAlwaysInBiggerTapRegion) { return(false); } if (secondDown.getEventTime() - firstUp.getEventTime() > DOUBLE_TAP_TIMEOUT) { return(false); } int deltaX = (int)firstDown.getX() - (int)secondDown.getX(); int deltaY = (int)firstDown.getY() - (int)secondDown.getY(); return(deltaX * deltaX + deltaY * deltaY < mDoubleTapSlopSquare); }
public virtual bool onTouch(android.view.View v, android.view.MotionEvent @event) { int action = @event.getAction(); if (@event.getPointerCount() > 1) { // ZoomButtonsController doesn't handle mutitouch. Give up control. return(false); } if (mReleaseTouchListenerOnUp) { // The controls were dismissed but we need to throw away all events until the up if (action == android.view.MotionEvent.ACTION_UP || action == android.view.MotionEvent .ACTION_CANCEL) { mOwnerView.setOnTouchListener(null); setTouchTargetView(null); mReleaseTouchListenerOnUp = false; } // Eat this event return(true); } dismissControlsDelayed(ZOOM_CONTROLS_TIMEOUT); android.view.View targetView = mTouchTargetView; switch (action) { case android.view.MotionEvent.ACTION_DOWN: { targetView = findViewForTouch((int)@event.getRawX(), (int)@event.getRawY()); setTouchTargetView(targetView); break; } case android.view.MotionEvent.ACTION_UP: case android.view.MotionEvent.ACTION_CANCEL: { setTouchTargetView(null); break; } } if (targetView != null) { // The upperleft corner of the target view in raw coordinates int targetViewRawX = mContainerRawLocation[0] + mTouchTargetWindowLocation[0]; int targetViewRawY = mContainerRawLocation[1] + mTouchTargetWindowLocation[1]; android.view.MotionEvent containerEvent = android.view.MotionEvent.obtain(@event); // Convert the motion event into the target view's coordinates (from // owner view's coordinates) containerEvent.offsetLocation(mOwnerViewRawLocation[0] - targetViewRawX, mOwnerViewRawLocation [1] - targetViewRawY); // These are floats because we need to potentially offset away this exact amount float containerX = containerEvent.getX(); float containerY = containerEvent.getY(); if (containerX < 0 && containerX > -ZOOM_CONTROLS_TOUCH_PADDING) { containerEvent.offsetLocation(-containerX, 0); } if (containerY < 0 && containerY > -ZOOM_CONTROLS_TOUCH_PADDING) { containerEvent.offsetLocation(0, -containerY); } bool retValue = targetView.dispatchTouchEvent(containerEvent); containerEvent.recycle(); return(retValue); } else { return(false); } }
public virtual bool onTouchEvent(android.view.MotionEvent @event) { if (mInputEventConsistencyVerifier != null) { mInputEventConsistencyVerifier.onTouchEvent(@event, 0); } int action = @event.getActionMasked(); if (action == android.view.MotionEvent.ACTION_DOWN) { reset(); } // Start fresh bool handled = true; if (mInvalidGesture) { handled = false; } else { if (!mGestureInProgress) { switch (action) { case android.view.MotionEvent.ACTION_DOWN: { mActiveId0 = @event.getPointerId(0); mActive0MostRecent = true; break; } case android.view.MotionEvent.ACTION_UP: { reset(); break; } case android.view.MotionEvent.ACTION_POINTER_DOWN: { // We have a new multi-finger gesture // as orientation can change, query the metrics in touch down android.util.DisplayMetrics metrics = mContext.getResources().getDisplayMetrics(); mRightSlopEdge = metrics.widthPixels - mEdgeSlop; mBottomSlopEdge = metrics.heightPixels - mEdgeSlop; if (mPrevEvent != null) { mPrevEvent.recycle(); } mPrevEvent = android.view.MotionEvent.obtain(@event); mTimeDelta = 0; int index1 = @event.getActionIndex(); int index0 = @event.findPointerIndex(mActiveId0); mActiveId1 = @event.getPointerId(index1); if (index0 < 0 || index0 == index1) { // Probably someone sending us a broken event stream. index0 = findNewActiveIndex(@event, index0 == index1 ? -1 : mActiveId1, index0); mActiveId0 = @event.getPointerId(index0); } mActive0MostRecent = false; setContext(@event); // Check if we have a sloppy gesture. If so, delay // the beginning of the gesture until we're sure that's // what the user wanted. Sloppy gestures can happen if the // edge of the user's hand is touching the screen, for example. float edgeSlop = mEdgeSlop; float rightSlop = mRightSlopEdge; float bottomSlop = mBottomSlopEdge; float x0 = getRawX(@event, index0); float y0 = getRawY(@event, index0); float x1 = getRawX(@event, index1); float y1 = getRawY(@event, index1); bool p0sloppy = x0 <edgeSlop || y0 <edgeSlop || x0> rightSlop || y0> bottomSlop; bool p1sloppy = x1 <edgeSlop || y1 <edgeSlop || x1> rightSlop || y1> bottomSlop; if (p0sloppy && p1sloppy) { mFocusX = -1; mFocusY = -1; mSloppyGesture = true; } else { if (p0sloppy) { mFocusX = @event.getX(index1); mFocusY = @event.getY(index1); mSloppyGesture = true; } else { if (p1sloppy) { mFocusX = @event.getX(index0); mFocusY = @event.getY(index0); mSloppyGesture = true; } else { mSloppyGesture = false; mGestureInProgress = mListener.onScaleBegin(this); } } } break; } case android.view.MotionEvent.ACTION_MOVE: { if (mSloppyGesture) { // Initiate sloppy gestures if we've moved outside of the slop area. float edgeSlop = mEdgeSlop; float rightSlop = mRightSlopEdge; float bottomSlop = mBottomSlopEdge; int index0 = @event.findPointerIndex(mActiveId0); int index1 = @event.findPointerIndex(mActiveId1); float x0 = getRawX(@event, index0); float y0 = getRawY(@event, index0); float x1 = getRawX(@event, index1); float y1 = getRawY(@event, index1); bool p0sloppy = x0 <edgeSlop || y0 <edgeSlop || x0> rightSlop || y0> bottomSlop; bool p1sloppy = x1 <edgeSlop || y1 <edgeSlop || x1> rightSlop || y1> bottomSlop; if (p0sloppy) { // Do we have a different pointer that isn't sloppy? int index = findNewActiveIndex(@event, mActiveId1, index0); if (index >= 0) { index0 = index; mActiveId0 = @event.getPointerId(index); x0 = getRawX(@event, index); y0 = getRawY(@event, index); p0sloppy = false; } } if (p1sloppy) { // Do we have a different pointer that isn't sloppy? int index = findNewActiveIndex(@event, mActiveId0, index1); if (index >= 0) { index1 = index; mActiveId1 = @event.getPointerId(index); x1 = getRawX(@event, index); y1 = getRawY(@event, index); p1sloppy = false; } } if (p0sloppy && p1sloppy) { mFocusX = -1; mFocusY = -1; } else { if (p0sloppy) { mFocusX = @event.getX(index1); mFocusY = @event.getY(index1); } else { if (p1sloppy) { mFocusX = @event.getX(index0); mFocusY = @event.getY(index0); } else { mSloppyGesture = false; mGestureInProgress = mListener.onScaleBegin(this); } } } } break; } case android.view.MotionEvent.ACTION_POINTER_UP: { if (mSloppyGesture) { int pointerCount = @event.getPointerCount(); int actionIndex = @event.getActionIndex(); int actionId = @event.getPointerId(actionIndex); if (pointerCount > 2) { if (actionId == mActiveId0) { int newIndex = findNewActiveIndex(@event, mActiveId1, actionIndex); if (newIndex >= 0) { mActiveId0 = @event.getPointerId(newIndex); } } else { if (actionId == mActiveId1) { int newIndex = findNewActiveIndex(@event, mActiveId0, actionIndex); if (newIndex >= 0) { mActiveId1 = @event.getPointerId(newIndex); } } } } else { // Set focus point to the remaining finger int index = @event.findPointerIndex(actionId == mActiveId0 ? mActiveId1 : mActiveId0 ); if (index < 0) { mInvalidGesture = true; android.util.Log.e(TAG, "Invalid MotionEvent stream detected.", new System.Exception ()); if (mGestureInProgress) { mListener.onScaleEnd(this); } return(false); } mActiveId0 = @event.getPointerId(index); mActive0MostRecent = true; mActiveId1 = -1; mFocusX = @event.getX(index); mFocusY = @event.getY(index); } } break; } } } else { switch (action) { case android.view.MotionEvent.ACTION_POINTER_DOWN: { // Transform gesture in progress - attempt to handle it // End the old gesture and begin a new one with the most recent two fingers. mListener.onScaleEnd(this); int oldActive0 = mActiveId0; int oldActive1 = mActiveId1; reset(); mPrevEvent = android.view.MotionEvent.obtain(@event); mActiveId0 = mActive0MostRecent ? oldActive0 : oldActive1; mActiveId1 = @event.getPointerId(@event.getActionIndex()); mActive0MostRecent = false; int index0 = @event.findPointerIndex(mActiveId0); if (index0 < 0 || mActiveId0 == mActiveId1) { // Probably someone sending us a broken event stream. android.util.Log.e(TAG, "Got " + android.view.MotionEvent.actionToString(action) + " with bad state while a gesture was in progress. " + "Did you forget to pass an event to " + "ScaleGestureDetector#onTouchEvent?"); index0 = findNewActiveIndex(@event, mActiveId0 == mActiveId1 ? -1 : mActiveId1, index0 ); mActiveId0 = @event.getPointerId(index0); } setContext(@event); mGestureInProgress = mListener.onScaleBegin(this); break; } case android.view.MotionEvent.ACTION_POINTER_UP: { int pointerCount = @event.getPointerCount(); int actionIndex = @event.getActionIndex(); int actionId = @event.getPointerId(actionIndex); bool gestureEnded = false; if (pointerCount > 2) { if (actionId == mActiveId0) { int newIndex = findNewActiveIndex(@event, mActiveId1, actionIndex); if (newIndex >= 0) { mListener.onScaleEnd(this); mActiveId0 = @event.getPointerId(newIndex); mActive0MostRecent = true; mPrevEvent = android.view.MotionEvent.obtain(@event); setContext(@event); mGestureInProgress = mListener.onScaleBegin(this); } else { gestureEnded = true; } } else { if (actionId == mActiveId1) { int newIndex = findNewActiveIndex(@event, mActiveId0, actionIndex); if (newIndex >= 0) { mListener.onScaleEnd(this); mActiveId1 = @event.getPointerId(newIndex); mActive0MostRecent = false; mPrevEvent = android.view.MotionEvent.obtain(@event); setContext(@event); mGestureInProgress = mListener.onScaleBegin(this); } else { gestureEnded = true; } } } mPrevEvent.recycle(); mPrevEvent = android.view.MotionEvent.obtain(@event); setContext(@event); } else { gestureEnded = true; } if (gestureEnded) { // Gesture ended setContext(@event); // Set focus point to the remaining finger int activeId = actionId == mActiveId0 ? mActiveId1 : mActiveId0; int index = @event.findPointerIndex(activeId); mFocusX = @event.getX(index); mFocusY = @event.getY(index); mListener.onScaleEnd(this); reset(); mActiveId0 = activeId; mActive0MostRecent = true; } break; } case android.view.MotionEvent.ACTION_CANCEL: { mListener.onScaleEnd(this); reset(); break; } case android.view.MotionEvent.ACTION_UP: { reset(); break; } case android.view.MotionEvent.ACTION_MOVE: { setContext(@event); // Only accept the event if our relative pressure is within // a certain limit - this can help filter shaky data as a // finger is lifted. if (mCurrPressure / mPrevPressure > PRESSURE_THRESHOLD) { bool updatePrevious = mListener.onScale(this); if (updatePrevious) { mPrevEvent.recycle(); mPrevEvent = android.view.MotionEvent.obtain(@event); } } break; } } } } if (!handled && mInputEventConsistencyVerifier != null) { mInputEventConsistencyVerifier.onUnhandledEvent(@event, 0); } return(handled); }
/// <summary> /// Will forward touch events to the delegate view if the event is within the bounds /// specified in the constructor. /// </summary> /// <remarks> /// Will forward touch events to the delegate view if the event is within the bounds /// specified in the constructor. /// </remarks> /// <param name="event">The touch event to forward</param> /// <returns>True if the event was forwarded to the delegate, false otherwise.</returns> public virtual bool onTouchEvent(android.view.MotionEvent @event) { int x = (int)@event.getX(); int y = (int)@event.getY(); bool sendToDelegate = false; bool hit = true; bool handled = false; switch (@event.getAction()) { case android.view.MotionEvent.ACTION_DOWN: { android.graphics.Rect bounds = mBounds; if (bounds.contains(x, y)) { mDelegateTargeted = true; sendToDelegate = true; } break; } case android.view.MotionEvent.ACTION_UP: case android.view.MotionEvent.ACTION_MOVE: { sendToDelegate = mDelegateTargeted; if (sendToDelegate) { android.graphics.Rect slopBounds = mSlopBounds; if (!slopBounds.contains(x, y)) { hit = false; } } break; } case android.view.MotionEvent.ACTION_CANCEL: { sendToDelegate = mDelegateTargeted; mDelegateTargeted = false; break; } } if (sendToDelegate) { android.view.View delegateView = mDelegateView; if (hit) { // Offset event coordinates to be inside the target view @event.setLocation(delegateView.getWidth() / 2, delegateView.getHeight() / 2); } else { // Offset event coordinates to be outside the target view (in case it does // something like tracking pressed state) int slop = mSlop; @event.setLocation(-(slop * 2), -(slop * 2)); } handled = delegateView.dispatchTouchEvent(@event); } return(handled); }
public override bool onTouchEvent(android.view.MotionEvent @event) { if (!mIsUserSeekable || !isEnabled()) { return(false); } switch (@event.getAction()) { case android.view.MotionEvent.ACTION_DOWN: { if (isInScrollingContainer()) { mTouchDownX = @event.getX(); } else { setPressed(true); if (mThumb != null) { invalidate(mThumb.getBounds()); } // This may be within the padding region onStartTrackingTouch(); trackTouchEvent(@event); attemptClaimDrag(); } break; } case android.view.MotionEvent.ACTION_MOVE: { if (mIsDragging) { trackTouchEvent(@event); } else { float x = @event.getX(); if (System.Math.Abs(x - mTouchDownX) > mScaledTouchSlop) { setPressed(true); if (mThumb != null) { invalidate(mThumb.getBounds()); } // This may be within the padding region onStartTrackingTouch(); trackTouchEvent(@event); attemptClaimDrag(); } } break; } case android.view.MotionEvent.ACTION_UP: { if (mIsDragging) { trackTouchEvent(@event); onStopTrackingTouch(); setPressed(false); } else { // Touch up when we never crossed the touch slop threshold should // be interpreted as a tap-seek to that location. onStartTrackingTouch(); trackTouchEvent(@event); onStopTrackingTouch(); } // ProgressBar doesn't know to repaint the thumb drawable // in its inactive state when the touch stops (because the // value has not apparently changed) invalidate(); break; } case android.view.MotionEvent.ACTION_CANCEL: { if (mIsDragging) { onStopTrackingTouch(); setPressed(false); } invalidate(); // see above explanation break; } } return(true); }
/// <summary> /// Analyzes the given motion event and if applicable triggers the /// appropriate callbacks on the /// <see cref="OnGestureListener">OnGestureListener</see> /// supplied. /// </summary> /// <param name="ev">The current motion event.</param> /// <returns> /// true if the /// <see cref="OnGestureListener">OnGestureListener</see> /// consumed the event, /// else false. /// </returns> public virtual bool onTouchEvent(android.view.MotionEvent ev) { if (mInputEventConsistencyVerifier != null) { mInputEventConsistencyVerifier.onTouchEvent(ev, 0); } int action = ev.getAction(); float y = ev.getY(); float x = ev.getX(); if (mVelocityTracker == null) { mVelocityTracker = android.view.VelocityTracker.obtain(); } mVelocityTracker.addMovement(ev); bool handled = false; switch (action & android.view.MotionEvent.ACTION_MASK) { case android.view.MotionEvent.ACTION_POINTER_DOWN: { if (mIgnoreMultitouch) { // Multitouch event - abort. cancel(); } break; } case android.view.MotionEvent.ACTION_POINTER_UP: { // Ending a multitouch gesture and going back to 1 finger if (mIgnoreMultitouch && ev.getPointerCount() == 2) { int index = (((action & android.view.MotionEvent.ACTION_POINTER_INDEX_MASK) >> android.view.MotionEvent .ACTION_POINTER_INDEX_SHIFT) == 0) ? 1 : 0; mLastMotionX = ev.getX(index); mLastMotionY = ev.getY(index); mVelocityTracker.recycle(); mVelocityTracker = android.view.VelocityTracker.obtain(); } break; } case android.view.MotionEvent.ACTION_DOWN: { if (mDoubleTapListener != null) { bool hadTapMessage = mHandler.hasMessages(TAP); if (hadTapMessage) { mHandler.removeMessages(TAP); } if ((mCurrentDownEvent != null) && (mPreviousUpEvent != null) && hadTapMessage && isConsideredDoubleTap(mCurrentDownEvent, mPreviousUpEvent, ev)) { // This is a second tap mIsDoubleTapping = true; // Give a callback with the first tap of the double-tap handled |= mDoubleTapListener.onDoubleTap(mCurrentDownEvent); // Give a callback with down event of the double-tap handled |= mDoubleTapListener.onDoubleTapEvent(ev); } else { // This is a first tap mHandler.sendEmptyMessageDelayed(TAP, DOUBLE_TAP_TIMEOUT); } } mLastMotionX = x; mLastMotionY = y; if (mCurrentDownEvent != null) { mCurrentDownEvent.recycle(); } mCurrentDownEvent = android.view.MotionEvent.obtain(ev); mAlwaysInTapRegion = true; mAlwaysInBiggerTapRegion = true; mStillDown = true; mInLongPress = false; if (mIsLongpressEnabled) { mHandler.removeMessages(LONG_PRESS); mHandler.sendEmptyMessageAtTime(LONG_PRESS, mCurrentDownEvent.getDownTime() + TAP_TIMEOUT + LONGPRESS_TIMEOUT); } mHandler.sendEmptyMessageAtTime(SHOW_PRESS, mCurrentDownEvent.getDownTime() + TAP_TIMEOUT ); handled |= mListener.onDown(ev); break; } case android.view.MotionEvent.ACTION_MOVE: { if (mInLongPress || (mIgnoreMultitouch && ev.getPointerCount() > 1)) { break; } float scrollX = mLastMotionX - x; float scrollY = mLastMotionY - y; if (mIsDoubleTapping) { // Give the move events of the double-tap handled |= mDoubleTapListener.onDoubleTapEvent(ev); } else { if (mAlwaysInTapRegion) { int deltaX = (int)(x - mCurrentDownEvent.getX()); int deltaY = (int)(y - mCurrentDownEvent.getY()); int distance = (deltaX * deltaX) + (deltaY * deltaY); if (distance > mTouchSlopSquare) { handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY); mLastMotionX = x; mLastMotionY = y; mAlwaysInTapRegion = false; mHandler.removeMessages(TAP); mHandler.removeMessages(SHOW_PRESS); mHandler.removeMessages(LONG_PRESS); } if (distance > mBiggerTouchSlopSquare) { mAlwaysInBiggerTapRegion = false; } } else { if ((System.Math.Abs(scrollX) >= 1) || (System.Math.Abs(scrollY) >= 1)) { handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY); mLastMotionX = x; mLastMotionY = y; } } } break; } case android.view.MotionEvent.ACTION_UP: { mStillDown = false; android.view.MotionEvent currentUpEvent = android.view.MotionEvent.obtain(ev); if (mIsDoubleTapping) { // Finally, give the up event of the double-tap handled |= mDoubleTapListener.onDoubleTapEvent(ev); } else { if (mInLongPress) { mHandler.removeMessages(TAP); mInLongPress = false; } else { if (mAlwaysInTapRegion) { handled = mListener.onSingleTapUp(ev); } else { // A fling must travel the minimum tap distance android.view.VelocityTracker velocityTracker = mVelocityTracker; velocityTracker.computeCurrentVelocity(1000, mMaximumFlingVelocity); float velocityY = velocityTracker.getYVelocity(); float velocityX = velocityTracker.getXVelocity(); if ((System.Math.Abs(velocityY) > mMinimumFlingVelocity) || (System.Math.Abs(velocityX ) > mMinimumFlingVelocity)) { handled = mListener.onFling(mCurrentDownEvent, ev, velocityX, velocityY); } } } } if (mPreviousUpEvent != null) { mPreviousUpEvent.recycle(); } // Hold the event we obtained above - listeners may have changed the original. mPreviousUpEvent = currentUpEvent; mVelocityTracker.recycle(); mVelocityTracker = null; mIsDoubleTapping = false; mHandler.removeMessages(SHOW_PRESS); mHandler.removeMessages(LONG_PRESS); break; } case android.view.MotionEvent.ACTION_CANCEL: { cancel(); break; } } if (!handled && mInputEventConsistencyVerifier != null) { mInputEventConsistencyVerifier.onUnhandledEvent(ev, 0); } return(handled); }
public override bool onTouchEvent(android.view.MotionEvent ev) { mVelocityTracker.addMovement(ev); int action = ev.getActionMasked(); switch (action) { case android.view.MotionEvent.ACTION_DOWN: { float x = ev.getX(); float y = ev.getY(); if (isEnabled() && hitThumb(x, y)) { mTouchMode = TOUCH_MODE_DOWN; mTouchX = x; mTouchY = y; } break; } case android.view.MotionEvent.ACTION_MOVE: { switch (mTouchMode) { case TOUCH_MODE_IDLE: { // Didn't target the thumb, treat normally. break; } case TOUCH_MODE_DOWN: { float x = ev.getX(); float y = ev.getY(); if (System.Math.Abs(x - mTouchX) > mTouchSlop || System.Math.Abs(y - mTouchY) > mTouchSlop) { mTouchMode = TOUCH_MODE_DRAGGING; getParent().requestDisallowInterceptTouchEvent(true); mTouchX = x; mTouchY = y; return(true); } break; } case TOUCH_MODE_DRAGGING: { float x = ev.getX(); float dx = x - mTouchX; float newPos = System.Math.Max(0, System.Math.Min(mThumbPosition + dx, getThumbScrollRange ())); if (newPos != mThumbPosition) { mThumbPosition = newPos; mTouchX = x; invalidate(); } return(true); } } break; } case android.view.MotionEvent.ACTION_UP: case android.view.MotionEvent.ACTION_CANCEL: { if (mTouchMode == TOUCH_MODE_DRAGGING) { stopDrag(ev); return(true); } mTouchMode = TOUCH_MODE_IDLE; mVelocityTracker.clear(); break; } } return(base.onTouchEvent(ev)); }
public void run() { __this._renderer.setAngle(__value.getX()); }
internal virtual bool onTouchEvent(android.view.MotionEvent me) { if (mState == STATE_NONE) { return(false); } int action = me.getAction(); if (action == android.view.MotionEvent.ACTION_DOWN) { if (isPointInside(me.getX(), me.getY())) { if (!mList.isInScrollingContainer()) { beginDrag(); return(true); } mInitialTouchY = me.getY(); startPendingDrag(); } } else { if (action == android.view.MotionEvent.ACTION_UP) { // don't add ACTION_CANCEL here if (mPendingDrag) { // Allow a tap to scroll. beginDrag(); int viewHeight = mList.getHeight(); // Jitter int newThumbY = (int)me.getY() - mThumbH + 10; if (newThumbY < 0) { newThumbY = 0; } else { if (newThumbY + mThumbH > viewHeight) { newThumbY = viewHeight - mThumbH; } } mThumbY = newThumbY; scrollTo((float)mThumbY / (viewHeight - mThumbH)); cancelPendingDrag(); } // Will hit the STATE_DRAGGING check below if (mState == STATE_DRAGGING) { if (mList != null) { // ViewGroup does the right thing already, but there might // be other classes that don't properly reset on touch-up, // so do this explicitly just in case. mList.requestDisallowInterceptTouchEvent(false); mList.reportScrollStateChange(android.widget.AbsListView.OnScrollListenerClass.SCROLL_STATE_IDLE ); } setState(STATE_VISIBLE); android.os.Handler handler = mHandler; handler.removeCallbacks(mScrollFade); if (!mAlwaysShow) { handler.postDelayed(mScrollFade, 1000); } mList.invalidate(); return(true); } } else { if (action == android.view.MotionEvent.ACTION_MOVE) { if (mPendingDrag) { float y = me.getY(); if (System.Math.Abs(y - mInitialTouchY) > mScaledTouchSlop) { setState(STATE_DRAGGING); if (mListAdapter == null && mList != null) { getSectionsFromIndexer(); } if (mList != null) { mList.requestDisallowInterceptTouchEvent(true); mList.reportScrollStateChange(android.widget.AbsListView.OnScrollListenerClass.SCROLL_STATE_TOUCH_SCROLL ); } cancelFling(); cancelPendingDrag(); } } // Will hit the STATE_DRAGGING check below if (mState == STATE_DRAGGING) { int viewHeight = mList.getHeight(); // Jitter int newThumbY = (int)me.getY() - mThumbH + 10; if (newThumbY < 0) { newThumbY = 0; } else { if (newThumbY + mThumbH > viewHeight) { newThumbY = viewHeight - mThumbH; } } if (System.Math.Abs(mThumbY - newThumbY) < 2) { return(true); } mThumbY = newThumbY; // If the previous scrollTo is still pending if (mScrollCompleted) { scrollTo((float)mThumbY / (viewHeight - mThumbH)); } return(true); } } else { if (action == android.view.MotionEvent.ACTION_CANCEL) { cancelPendingDrag(); } } } } return(false); }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: @Override public boolean onTouchEvent(final android.view.MotionEvent event) public override bool onTouchEvent(MotionEvent @event) { bool handled = false; OfficeThing touchedThing; int xTouchLogical; int yTouchLogical; int pointerId; int actionIndex = @event.ActionIndex; // get touch event coordinates and make transparent wrapper from it switch (@event.ActionMasked) { case MotionEvent.ACTION_DOWN: // first pointer, clear the pointer mSelectedThing = null; xTouchLogical = screenToModel((int) @event.getX(0)); yTouchLogical = screenToModel((int) @event.getY(0)); // check if we've touched inside something touchedThing = getTouchedThing(xTouchLogical, yTouchLogical); if (touchedThing == null) { mSelectedThingChangeListener.thingChanged(null); break; } mSelectedThing = touchedThing; if (null != mSelectedThingChangeListener) { mSelectedThingChangeListener.thingChanged(touchedThing); } touchedThing.setzIndex(mOfficeLayout.HighestzIndex + 1); Log.v(TAG, "Selected " + touchedThing); handled = true; break; case MotionEvent.ACTION_MOVE: pointerId = @event.getPointerId(actionIndex); if (pointerId > 0) { break; } xTouchLogical = screenToModel((int) @event.getX(actionIndex)); yTouchLogical = screenToModel((int) @event.getY(actionIndex)); touchedThing = mSelectedThing; if (null == touchedThing) { break; } moveThing(touchedThing, xTouchLogical, yTouchLogical); handled = true; break; case MotionEvent.ACTION_UP: mSelectedThing = null; invalidate(); handled = true; break; case MotionEvent.ACTION_CANCEL: handled = true; break; } return base.onTouchEvent(@event) || handled; }
public override bool onTouchEvent(android.widget.TextView widget, android.text.Spannable buffer, android.view.MotionEvent @event) { int initialScrollX = -1; int initialScrollY = -1; int action = @event.getAction(); if (action == android.view.MotionEvent.ACTION_UP) { initialScrollX = android.text.method.Touch.getInitialScrollX(widget, buffer); initialScrollY = android.text.method.Touch.getInitialScrollY(widget, buffer); } bool handled = android.text.method.Touch.onTouchEvent(widget, buffer, @event); if (widget.isFocused() && !widget.didTouchFocusSelect()) { if (action == android.view.MotionEvent.ACTION_DOWN) { if (isSelecting(buffer)) { int offset = widget.getOffsetForPosition(@event.getX(), @event.getY()); buffer.setSpan(LAST_TAP_DOWN, offset, offset, android.text.SpannedClass.SPAN_POINT_POINT ); // Disallow intercepting of the touch events, so that // users can scroll and select at the same time. // without this, users would get booted out of select // mode once the view detected it needed to scroll. widget.getParent().requestDisallowInterceptTouchEvent(true); } } else { if (action == android.view.MotionEvent.ACTION_MOVE) { if (isSelecting(buffer) && handled) { // Before selecting, make sure we've moved out of the "slop". // handled will be true, if we're in select mode AND we're // OUT of the slop // Turn long press off while we're selecting. User needs to // re-tap on the selection to enable long press widget.cancelLongPress(); // Update selection as we're moving the selection area. // Get the current touch position int offset = widget.getOffsetForPosition(@event.getX(), @event.getY()); android.text.Selection.extendSelection(buffer, offset); return(true); } } else { if (action == android.view.MotionEvent.ACTION_UP) { // If we have scrolled, then the up shouldn't move the cursor, // but we do need to make sure the cursor is still visible at // the current scroll offset to avoid the scroll jumping later // to show it. if ((initialScrollY >= 0 && initialScrollY != widget.getScrollY()) || (initialScrollX >= 0 && initialScrollX != widget.getScrollX())) { widget.moveCursorToVisibleOffset(); return(true); } int offset = widget.getOffsetForPosition(@event.getX(), @event.getY()); if (isSelecting(buffer)) { buffer.removeSpan(LAST_TAP_DOWN); android.text.Selection.extendSelection(buffer, offset); } else { if (!widget.shouldIgnoreActionUpEvent()) { android.text.Selection.setSelection(buffer, offset); } } android.text.method.MetaKeyKeyListener.adjustMetaAfterKeypress(buffer); android.text.method.MetaKeyKeyListener.resetLockedMeta(buffer); return(true); } } } } return(handled); }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: @Override public boolean onTouchEvent(final android.view.MotionEvent event) public override bool onTouchEvent(MotionEvent @event) { bool handled = false; OfficeThing touchedThing; int xTouchLogical; int yTouchLogical; int pointerId; int actionIndex = @event.ActionIndex; // get touch event coordinates and make transparent wrapper from it switch (@event.ActionMasked) { case MotionEvent.ACTION_DOWN: // first pointer, clear the pointer mSelectedThing = null; xTouchLogical = screenToModel((int)@event.getX(0)); yTouchLogical = screenToModel((int)@event.getY(0)); // check if we've touched inside something touchedThing = getTouchedThing(xTouchLogical, yTouchLogical); if (touchedThing == null) { mSelectedThingChangeListener.thingChanged(null); break; } mSelectedThing = touchedThing; if (null != mSelectedThingChangeListener) { mSelectedThingChangeListener.thingChanged(touchedThing); } touchedThing.setzIndex(mOfficeLayout.HighestzIndex + 1); Log.v(TAG, "Selected " + touchedThing); handled = true; break; case MotionEvent.ACTION_MOVE: pointerId = @event.getPointerId(actionIndex); if (pointerId > 0) { break; } xTouchLogical = screenToModel((int)@event.getX(actionIndex)); yTouchLogical = screenToModel((int)@event.getY(actionIndex)); touchedThing = mSelectedThing; if (null == touchedThing) { break; } moveThing(touchedThing, xTouchLogical, yTouchLogical); handled = true; break; case MotionEvent.ACTION_UP: mSelectedThing = null; invalidate(); handled = true; break; case MotionEvent.ACTION_CANCEL: handled = true; break; } return(base.onTouchEvent(@event) || handled); }
public void run() { __this._renderer.setColor(__value.getX() / __this.getWidth(), __value.getY() / __this.getHeight(), 1.0f); __this._renderer.setAngle(__value.getX() / 10); }
/// <summary> /// Analyzes the given motion event and if applicable triggers the /// appropriate callbacks on the /// <see cref="OnGestureListener">OnGestureListener</see> /// supplied. /// </summary> /// <param name="ev">The current motion event.</param> /// <returns> /// true if the /// <see cref="OnGestureListener">OnGestureListener</see> /// consumed the event, /// else false. /// </returns> public virtual bool onTouchEvent(android.view.MotionEvent ev) { if (mInputEventConsistencyVerifier != null) { mInputEventConsistencyVerifier.onTouchEvent(ev, 0); } int action = ev.getAction(); float y = ev.getY(); float x = ev.getX(); if (mVelocityTracker == null) { mVelocityTracker = android.view.VelocityTracker.obtain(); } mVelocityTracker.addMovement(ev); bool handled = false; switch (action & android.view.MotionEvent.ACTION_MASK) { case android.view.MotionEvent.ACTION_POINTER_DOWN: { if (mIgnoreMultitouch) { // Multitouch event - abort. cancel(); } break; } case android.view.MotionEvent.ACTION_POINTER_UP: { // Ending a multitouch gesture and going back to 1 finger if (mIgnoreMultitouch && ev.getPointerCount() == 2) { int index = (((action & android.view.MotionEvent.ACTION_POINTER_INDEX_MASK) >> android.view.MotionEvent .ACTION_POINTER_INDEX_SHIFT) == 0) ? 1 : 0; mLastMotionX = ev.getX(index); mLastMotionY = ev.getY(index); mVelocityTracker.recycle(); mVelocityTracker = android.view.VelocityTracker.obtain(); } break; } case android.view.MotionEvent.ACTION_DOWN: { if (mDoubleTapListener != null) { bool hadTapMessage = mHandler.hasMessages(TAP); if (hadTapMessage) { mHandler.removeMessages(TAP); } if ((mCurrentDownEvent != null) && (mPreviousUpEvent != null) && hadTapMessage && isConsideredDoubleTap(mCurrentDownEvent, mPreviousUpEvent, ev)) { // This is a second tap mIsDoubleTapping = true; // Give a callback with the first tap of the double-tap handled |= mDoubleTapListener.onDoubleTap(mCurrentDownEvent); // Give a callback with down event of the double-tap handled |= mDoubleTapListener.onDoubleTapEvent(ev); } else { // This is a first tap mHandler.sendEmptyMessageDelayed(TAP, DOUBLE_TAP_TIMEOUT); } } mLastMotionX = x; mLastMotionY = y; if (mCurrentDownEvent != null) { mCurrentDownEvent.recycle(); } mCurrentDownEvent = android.view.MotionEvent.obtain(ev); mAlwaysInTapRegion = true; mAlwaysInBiggerTapRegion = true; mStillDown = true; mInLongPress = false; if (mIsLongpressEnabled) { mHandler.removeMessages(LONG_PRESS); mHandler.sendEmptyMessageAtTime(LONG_PRESS, mCurrentDownEvent.getDownTime() + TAP_TIMEOUT + LONGPRESS_TIMEOUT); } mHandler.sendEmptyMessageAtTime(SHOW_PRESS, mCurrentDownEvent.getDownTime() + TAP_TIMEOUT ); handled |= mListener.onDown(ev); break; } case android.view.MotionEvent.ACTION_MOVE: { if (mInLongPress || (mIgnoreMultitouch && ev.getPointerCount() > 1)) { break; } float scrollX = mLastMotionX - x; float scrollY = mLastMotionY - y; if (mIsDoubleTapping) { // Give the move events of the double-tap handled |= mDoubleTapListener.onDoubleTapEvent(ev); } else { if (mAlwaysInTapRegion) { int deltaX = (int)(x - mCurrentDownEvent.getX()); int deltaY = (int)(y - mCurrentDownEvent.getY()); int distance = (deltaX * deltaX) + (deltaY * deltaY); if (distance > mTouchSlopSquare) { handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY); mLastMotionX = x; mLastMotionY = y; mAlwaysInTapRegion = false; mHandler.removeMessages(TAP); mHandler.removeMessages(SHOW_PRESS); mHandler.removeMessages(LONG_PRESS); } if (distance > mBiggerTouchSlopSquare) { mAlwaysInBiggerTapRegion = false; } } else { if ((System.Math.Abs(scrollX) >= 1) || (System.Math.Abs(scrollY) >= 1)) { handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY); mLastMotionX = x; mLastMotionY = y; } } } break; } case android.view.MotionEvent.ACTION_UP: { mStillDown = false; android.view.MotionEvent currentUpEvent = android.view.MotionEvent.obtain(ev); if (mIsDoubleTapping) { // Finally, give the up event of the double-tap handled |= mDoubleTapListener.onDoubleTapEvent(ev); } else { if (mInLongPress) { mHandler.removeMessages(TAP); mInLongPress = false; } else { if (mAlwaysInTapRegion) { handled = mListener.onSingleTapUp(ev); } else { // A fling must travel the minimum tap distance android.view.VelocityTracker velocityTracker = mVelocityTracker; velocityTracker.computeCurrentVelocity(1000, mMaximumFlingVelocity); float velocityY = velocityTracker.getYVelocity(); float velocityX = velocityTracker.getXVelocity(); if ((System.Math.Abs(velocityY) > mMinimumFlingVelocity) || (System.Math.Abs(velocityX ) > mMinimumFlingVelocity)) { handled = mListener.onFling(mCurrentDownEvent, ev, velocityX, velocityY); } } } } if (mPreviousUpEvent != null) { mPreviousUpEvent.recycle(); } // Hold the event we obtained above - listeners may have changed the original. mPreviousUpEvent = currentUpEvent; mVelocityTracker.recycle(); mVelocityTracker = null; mIsDoubleTapping = false; mHandler.removeMessages(SHOW_PRESS); mHandler.removeMessages(LONG_PRESS); break; } case android.view.MotionEvent.ACTION_CANCEL: { cancel(); break; } } if (!handled && mInputEventConsistencyVerifier != null) { mInputEventConsistencyVerifier.onUnhandledEvent(ev, 0); } return handled; }