示例#1
0
  @Override
  public boolean onTouch(View v, MotionEvent ev) {
    mDetector.onTouchEvent(ev);
    if (mRemoveEnabled
        && mDragging
        && (mRemoveMode == FLING_RIGHT_REMOVE || mRemoveMode == FLING_LEFT_REMOVE)) {
      mFlingRemoveDetector.onTouchEvent(ev);
    }

    int action = ev.getAction() & MotionEvent.ACTION_MASK;

    switch (action) {
      case MotionEvent.ACTION_DOWN:
        mCurrX = (int) ev.getX();
        mCurrY = (int) ev.getY();
        break;
      case MotionEvent.ACTION_UP:
        if (mRemoveEnabled) {
          final int x = (int) ev.getX();
          int thirdW = mDslv.getWidth() / 3;
          int twoThirdW = mDslv.getWidth() - thirdW;
          if ((mRemoveMode == SLIDE_RIGHT_REMOVE && x > twoThirdW)
              || (mRemoveMode == SLIDE_LEFT_REMOVE && x < thirdW)) {
            mDslv.stopDrag(true);
          }
        }
      case MotionEvent.ACTION_CANCEL:
        mDragging = false;
        break;
    }

    return false;
  }
  @Override
  public boolean onTouch(View v, MotionEvent ev) {
    if (!mDslv.isDragEnabled() || mDslv.listViewIntercepted()) {
      return false;
    }

    mDetector.onTouchEvent(ev);
    if (mRemoveEnabled && mDragging && mRemoveMode == FLING_REMOVE) {
      mFlingRemoveDetector.onTouchEvent(ev);
    }

    int action = ev.getAction() & MotionEvent.ACTION_MASK;
    switch (action) {
      case MotionEvent.ACTION_DOWN:
        mCurrX = (int) ev.getX();
        mCurrY = (int) ev.getY();
        break;
      case MotionEvent.ACTION_UP:
        if (mRemoveEnabled && mIsRemoving) {
          int x = mPositionX >= 0 ? mPositionX : -mPositionX;
          int removePoint = mDslv.getWidth() / 2;
          if (x > removePoint) {
            mDslv.stopDragWithVelocity(true, 0);
          }
        }
      case MotionEvent.ACTION_CANCEL:
        mIsRemoving = false;
        mDragging = false;
        break;
    }

    return false;
  }
  @Test
  public void test_setNextOnTouchEventReturnValue() throws Exception {
    assertTrue(detector.onTouchEvent(motionEvent));

    shadowOf(detector).setNextOnTouchEventReturnValue(true);
    assertTrue(detector.onTouchEvent(motionEvent));

    shadowOf(detector).setNextOnTouchEventReturnValue(false);
    assertFalse(detector.onTouchEvent(motionEvent));
  }
  // glView onTouch Event handler
  public boolean onTouch(View v, MotionEvent event) {
    boolean result = false;

    for (int i = 0; i < buttons.length; ++i) {
      if (buttons[i].processTouch(v, event)) {
        result = true;
        break;
      }
    }

    if (result != true) {
      gestureDetector.onTouchEvent(event);

      for (int i = 0; i < joysticks.length; ++i) {
        JoystickBase joy = joysticks[i];
        if (joy != null) {
          if (joy.processTouch(v, event)) {
            result = true;
          }
        }
      }
    }

    return result;
  }
 @Override
 public boolean dispatchTouchEvent(MotionEvent ev) {
   if (gd != null) {
     if (gd.onTouchEvent(ev)) return true;
   }
   return super.dispatchTouchEvent(ev);
 }
 public void onTouchEvent(MotionEvent event) {
   mGestureDetector.onTouchEvent(event);
   mScaleDetector.onTouchEvent(event);
   if (event.getAction() == MotionEvent.ACTION_UP) {
     mListener.onUp(event.getX(), event.getY());
   }
 }
示例#7
0
  @Override
  public boolean dispatchTouchEvent(MotionEvent event) {
    boolean ret = false;

    if (mIsScroll && event.getAction() == MotionEvent.ACTION_UP) {
      if (mScrollX > 0 && mScrollX < mMaxDistance) {
        unFold();
        ret = true;
      }
      event.setAction(MotionEvent.ACTION_CANCEL);
      mIsScroll = false;
    } else if (mGestureDetector != null && mGestureDetector.onTouchEvent(event)) {
      event.setAction(MotionEvent.ACTION_CANCEL);
      ret = true;
    }

    if (super.dispatchTouchEvent(event)) {
      ret = true;
    }

    if (ret) {
      invalidate();
    }
    return ret;
  }
示例#8
0
  @Override
  public boolean onInterceptTouchEvent(MotionEvent ev) {
    // TODO Auto-generated method stub
    boolean spend = false;
    spend = detector.onTouchEvent(ev);
    switch (ev.getAction()) {
      case MotionEvent.ACTION_DOWN:
        // log("onInterceptTouchEvent.ACTION_DOWN, " + spend);
        break;
      case MotionEvent.ACTION_MOVE:
        // log("onInterceptTouchEvent.ACTION_MOVE, " + spend);
        // detector.onTouchEvent(ev);
        break;
      case MotionEvent.ACTION_UP:
        // log("onInterceptTouchEvent.ACTION_UP, " + spend);
        // onTouchRelease();
        ov.clear();
        break;
      case MotionEvent.ACTION_CANCEL:
        // log("onInterceptTouchEvent.ACTION_CANCEL, " + spend);
        // onTouchRelease();
        break;
    }

    return spend;
  }
 @Override
 public boolean onTouchEvent(MotionEvent event) {
   // 触摸时停止自动播放
   flipStop(); // 点击事件后,停止自动播放
   gestureDetector.onTouchEvent(event); // 注册手势事件
   return true;
 }
示例#10
0
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    if (mGesture.onTouchEvent(event)) {
      return true;
    }
    switch (event.getAction()) {
      case MotionEvent.ACTION_MOVE:
        int moveX = (int) event.getRawX();
        int deltaX = tempX - moveX;
        tempX = moveX;
        if (moveX - downX > mTouchSlop && Math.abs((int) event.getRawY() - downY) < mTouchSlop) {
          isSilding = true;
        }

        if (moveX - downX >= 0 && isSilding) {
          mContentView.scrollBy(deltaX, 0);
        }
        break;
      case MotionEvent.ACTION_UP:
        isSilding = false;
        if (mContentView.getScrollX() <= -viewWidth / 2) {
          isFinish = true;
          scrollRight();
        } else {
          scrollOrigin();
          isFinish = false;
        }
        break;
    }

    return true;
  }
示例#11
0
 @Override
 public boolean dispatchTouchEvent(MotionEvent ev) {
   super.dispatchTouchEvent(ev);
   boolean consumed = gesturedetector.onTouchEvent(ev);
   if (!consumed && ev.getAction() == MotionEvent.ACTION_DOWN) return true;
   else return consumed;
 }
示例#12
0
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    if (!isEnabled()) return false;

    switch (event.getAction()) {
      case MotionEvent.ACTION_UP:
      case MotionEvent.ACTION_CANCEL:
        if (!knobState) {
          innerContentAnimator =
              ObjectAnimator.ofFloat(AnSwitch.this, innerContentProperty, innerContentRate, 1.0F);
          innerContentAnimator.setDuration(300L);
          innerContentAnimator.setInterpolator(new DecelerateInterpolator());

          innerContentAnimator.start();
        }

        knobExpandAnimator =
            ObjectAnimator.ofFloat(AnSwitch.this, knobExpandProperty, knobExpandRate, 0.0F);
        knobExpandAnimator.setDuration(300L);
        knobExpandAnimator.setInterpolator(new DecelerateInterpolator());

        knobExpandAnimator.start();

        mIsChecked = knobState;

        if (AnSwitch.this.onSwitchStateChangeListener != null && mIsChecked != preIsOn) {
          AnSwitch.this.onSwitchStateChangeListener.onSwitchStateChange(mIsChecked);
        }

        break;
    }

    return gestureDetector.onTouchEvent(event);
  }
示例#13
0
  /** 事件拦截操作 */
  @Override
  public boolean onInterceptTouchEvent(MotionEvent ev) {

    // 处理ViewPager冲突问题
    ViewPager mViewPager = getTouchViewPager(mViewPagers, ev);
    Log.i(TAG, "mViewPager = " + mViewPager);

    if (mViewPager != null && mViewPager.getCurrentItem() != 0) {
      return super.onInterceptTouchEvent(ev);
    }

    // 如果是左右滑动事件,则不将事件传递给子view
    if (mGesture.onTouchEvent(ev)) {
      return true;
    }

    switch (ev.getAction()) {
      case MotionEvent.ACTION_DOWN:
        downX = tempX = (int) ev.getRawX();
        downY = (int) ev.getRawY();
        break;
      case MotionEvent.ACTION_MOVE:
        int moveX = (int) ev.getRawX();
        // 满足此条件屏蔽SildingFinishLayout里面子类的touch事件
        if (moveX - downX > mTouchSlop && Math.abs((int) ev.getRawY() - downY) < mTouchSlop) {
          return true;
        }
        break;
    }

    return super.onInterceptTouchEvent(ev);
  }
示例#14
0
 @Override
 public boolean onTouchEvent(@NonNull MotionEvent ev) {
   stopAnimationsOnTouch = true;
   mScaleDetector.onTouchEvent(ev);
   if (!mScaleDetector.isInProgress()) mGestureDetector.onTouchEvent(ev);
   return true;
 }
 @Override
 public boolean onTouchEvent(VisualizationView view, MotionEvent event) {
   if (visible) {
     Preconditions.checkNotNull(pose);
     if (event.getAction() == MotionEvent.ACTION_MOVE) {
       Vector3 orientationVector =
           camera
               .toWorldCoordinates(new Point((int) event.getX(), (int) event.getY()))
               .subtract(pose.getTranslation());
       if (orientationVector.length() > 0) {
         pose.setRotation(
             Quaternion.rotationBetweenVectors(new Vector3(1, 0, 0), orientationVector));
       } else {
         pose.setRotation(Quaternion.newIdentityQuaternion());
       }
       shape.setTransform(pose);
       requestRender();
       return true;
     } else if (event.getAction() == MotionEvent.ACTION_UP) {
       posePublisher.publish(
           pose.toPoseStampedMessage(
               camera.getFixedFrame(),
               connectedNode.getCurrentTime(),
               posePublisher.newMessage()));
       visible = false;
       requestRender();
       return true;
     }
   }
   gestureDetector.onTouchEvent(event);
   return false;
 }
示例#16
0
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    mScaleGestureDetector.onTouchEvent(event);

    if (!mScaling) mGestureDetector.onTouchEvent(event);

    if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
      mUserInteracting = true;
    }
    if (event.getActionMasked() == MotionEvent.ACTION_UP) {
      mScrollDisabled = false;
      mUserInteracting = false;

      View v = mChildViews.get(mCurrent);
      if (v != null) {
        if (mScroller.isFinished()) {
          // If, at the end of user interaction, there is no
          // current inertial scroll in operation then animate
          // the view onto screen if necessary
          slideViewOntoScreen(v);
        }

        if (mScroller.isFinished()) {
          // If still there is no inertial scroll in operation
          // then the layout is stable
          postSettle(v);
        }
      }
    }

    requestLayout();
    return true;
  }
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    // Avoid short-circuit logic evaluation - ensure all gesture detectors see all events so
    // that they generate correct notifications.
    boolean handled = mScroller.onTouchEvent(event);
    handled |= mZoomer.onTouchEvent(event);
    handled |= mTapDetector.onTouchEvent(event);
    mSwipePinchDetector.onTouchEvent(event);

    switch (event.getActionMasked()) {
      case MotionEvent.ACTION_DOWN:
        mViewer.setAnimationEnabled(false);
        mSuppressCursorMovement = false;
        mSuppressFling = false;
        mSwipeCompleted = false;
        break;

      case MotionEvent.ACTION_POINTER_DOWN:
        mTotalMotionY = 0;
        break;

      case MotionEvent.ACTION_UP:
        releaseAnyHeldButton();
        break;

      default:
        break;
    }
    return handled;
  }
  @Override
  public boolean onInterceptTouchEvent(RecyclerView view, MotionEvent event) {
    childView = view.findChildViewUnder(event.getX(), event.getY());
    childViewPosition = view.getChildPosition(childView);

    return childView != null && gestureDetector.onTouchEvent(event);
  }
  public boolean onTouch(View v, MotionEvent event) {
    boolean result = false;

    for (int i = 0; i < buttons.length; ++i) {
      if (buttons[i].processTouch(v, event)) {
        result = true;
        break;
      }
    }

    if (result != true) {
      gestureDetector.onTouchEvent(event);

      for (int i = 0; i < joysticks.length; ++i) {
        JoystickBase joy = joysticks[i];
        if (joy != null) {
          if (joy.processTouch(v, event)) {

            result = true;
          }
        }
      }
    }

    //		if (event.getAction() == MotionEvent.ACTION_MOVE) {
    //		    // Trying to avoid flooding of ACTION_MOVE events
    //			try {
    //				Thread.sleep(33);
    //			} catch (InterruptedException e) {
    //				e.printStackTrace();
    //			}
    //		}

    return result;
  }
示例#20
0
文件: Panel.java 项目: 357016138/dxt
        public boolean onTouch(View v, MotionEvent event) {
          if (mState == State.ANIMATING) {
            // we are animating
            return false;
          }

          int action = event.getAction();
          if (action == MotionEvent.ACTION_DOWN) {
            //	           if (mBringToFront) {
            bringToFront();
            //	            }
            touchX = event.getX();
            touchY = event.getY();
          }

          if (!mGestureDetector.onTouchEvent(event)) {
            if (action == MotionEvent.ACTION_UP) {
              // tup up after scrolling
              int size = (int) (Math.abs(touchX - event.getX()) + Math.abs(touchY - event.getY()));

              if (size == mContentWidth || size == mContentHeight) {
                mState = State.ABOUT_TO_ANIMATE;
                // Log.e("size", String.valueOf(size));
                // Log.e(String.valueOf(mContentWidth),String.valueOf(mContentHeight));
              }

              post(startAnimation);
            }
          }
          return false;
        }
  @Override
  public final boolean onTouchEvent(MotionEvent event) {

    gestureDetector.onTouchEvent(event);

    return super.onTouchEvent(event);
  }
示例#22
0
  @Override
  public boolean dispatchTouchEvent(MotionEvent ev) {
    mGestureDetector.onTouchEvent(ev);
    // scroll.onTouchEvent(ev);

    return super.dispatchTouchEvent(ev);
  }
  /**
   * Handles Touch event
   *
   * @param event the motion event
   * @return
   */
  public boolean onTouchEvent(MotionEvent event) {
    switch (event.getAction()) {
      case MotionEvent.ACTION_DOWN:
        lastTouchedPosition = getMotionEventPosition(event);
        scroller.forceFinished(true);
        clearMessages();
        listener.onTouch();
        break;

      case MotionEvent.ACTION_UP:
        if (scroller.isFinished()) listener.onTouchUp();
        break;

      case MotionEvent.ACTION_MOVE:
        // perform scrolling
        int distance = (int) (getMotionEventPosition(event) - lastTouchedPosition);
        if (distance != 0) {
          startScrolling();
          listener.onScroll(distance);
          lastTouchedPosition = getMotionEventPosition(event);
        }
        break;
    }

    if (!gestureDetector.onTouchEvent(event) && event.getAction() == MotionEvent.ACTION_UP) {
      justify();
    }

    return true;
  }
示例#24
0
  @Override
  public boolean onTouchEventInternal(MotionEvent e) {
    final int action = e.getActionMasked();

    // This path mimics the Android long press detection while still allowing
    // other touch events to come through the gesture detector.
    if (!mUseDefaultLongPress) {
      if (e.getPointerCount() > 1) {
        // If there's more than one pointer ignore the long press.
        if (mLongPressRunnable.isPending()) {
          cancelLongPress();
        }
      } else if (action == MotionEvent.ACTION_DOWN) {
        // If there was a pending event kill it off.
        if (mLongPressRunnable.isPending()) {
          cancelLongPress();
        }
        mLongPressRunnable.init(e);
        mLongPressHandler.postDelayed(mLongPressRunnable, mLongPressTimeoutMs);
      } else if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
        cancelLongPress();
      } else if (mLongPressRunnable.isPending()) {
        // Allow for a little bit of touch slop.
        MotionEvent initialEvent = mLongPressRunnable.getInitialEvent();
        float distanceX = initialEvent.getX() - e.getX();
        float distanceY = initialEvent.getY() - e.getY();
        float distance = distanceX * distanceX + distanceY * distanceY;

        // Save a square root here by comparing to squared touch slop
        if (distance > mScaledTouchSlop * mScaledTouchSlop) {
          cancelLongPress();
        }
      }
    }

    // Sends the pinch event if two or more fingers touch the screen. According to test
    // Android handles the fingers order pretty consistently so always requesting
    // index 0 and 1 works here.
    // This might need some rework if 3 fingers event are supported.
    if (e.getPointerCount() > 1) {
      mHandler.onPinch(
          e.getX(0) * mPxToDp,
          e.getY(0) * mPxToDp,
          e.getX(1) * mPxToDp,
          e.getY(1) * mPxToDp,
          action == MotionEvent.ACTION_POINTER_DOWN);
      mDetector.setIsLongpressEnabled(false);
      mSingleInput = false;
    } else {
      mDetector.setIsLongpressEnabled(mUseDefaultLongPress);
      mSingleInput = true;
    }
    mDetector.onTouchEvent(e);

    // Propagate the up event after any gesture events.
    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
      mHandler.onUpOrCancel();
    }
    return true;
  }
  @Override
  public boolean onInterceptTouchEvent(MotionEvent ev) {

    mGestureDetector = new GestureDetector(new YScrollDetector());

    return super.onInterceptTouchEvent(ev) && mGestureDetector.onTouchEvent(ev);
  }
 @Override
 public boolean onTouchEvent(MotionEvent ev) {
   // Intercept ListView's touch event
   if (mScroller != null && mScroller.onTouchEvent(ev)) {
     return true;
   }
   if (mGestureDetector == null) {
     // Create a new GestureDetector -- 手势探测器
     mGestureDetector =
         new GestureDetector(
             getContext(),
             new GestureDetector.SimpleOnGestureListener() {
               @Override
               public boolean onFling(
                   MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
                 if (mScroller != null) {
                   mScroller.show();
                 }
                 return super.onFling(e1, e2, velocityX, velocityY);
               }
             });
   }
   mGestureDetector.onTouchEvent(ev);
   return super.onTouchEvent(ev);
 }
  /*----------------------onTouchEvent-------------------------------------------------------------------------------*/
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    Log.d(TAG, "onTouchEvent()");

    mGestureDetector.onTouchEvent(event);
    return multiTouchController.onTouchEvent(event);
  }
 @Test
 public void canAnswerLastGestureDetector() throws Exception {
   GestureDetector newDetector = new GestureDetector(Robolectric.application, null);
   assertNotSame(newDetector, ShadowGestureDetector.getLastActiveDetector());
   newDetector.onTouchEvent(null);
   assertSame(newDetector, ShadowGestureDetector.getLastActiveDetector());
 }
示例#29
0
 @Override
 public boolean onTouchEvent(MotionEvent event) {
   if (gestureDetector.onTouchEvent(event)) {
     return true;
   }
   return super.onTouchEvent(event);
 }
示例#30
0
 @Override
 public boolean onTouch(View v, MotionEvent event) {
   boolean handled = false;
   switch (event.getAction()) {
     case MotionEvent.ACTION_DOWN:
       mLastTouchX = event.getX();
       mLastTouchY = event.getY();
       forceFinished(true);
       clearMessages();
       handled = true;
       break;
     case MotionEvent.ACTION_MOVE:
       int dX = (int) (event.getX() - mLastTouchX);
       int dY = (int) (event.getY() - mLastTouchY);
       if (dX != 0 || dY != 0) {
         startScrolling();
         mScrollListener.onScroll(dX, dY);
         mLastTouchX = event.getX();
         mLastTouchY = event.getY();
       }
       handled = true;
       break;
     default:
       break;
   }
   return mGestureDetector.onTouchEvent(event) || handled;
 }