Example #1
1
  /**
   * Handle a touch event from the view.
   *
   * @param view The view that is the source of the touch
   * @param event The motion event describing the touch
   * @return true if the touch is handled.
   */
  public boolean onTouchEvent(View view, MotionEvent event) {
    float relX = event.getX() / width;
    float relY = event.getY() / height;

    switch (event.getActionMasked()) {
      case MotionEvent.ACTION_DOWN:
        return onTouched(relX, relY);

      case MotionEvent.ACTION_UP:
      case MotionEvent.ACTION_CANCEL:
        if (dragging) {
          dragging = false;
          return true;
        }
        break;

      case MotionEvent.ACTION_MOVE:
        // If we are dragging, move the piece and force a redraw
        if (dragging) {
          tempBlock.move(relX - lastRelX);
          lastRelX = relX;
          view.invalidate();
          return true;
        } else {
          scrollOffset += (relY - lastRelY);
          if (scrollOffset < 0) scrollOffset = 0;
          lastRelY = relY;
          view.invalidate();
          return true;
        }
    }

    return false;
  }
    /**
     * Update the prevent touch stream.
     *
     * @param event The event that webkit had handled, or null to drop it.
     * @param preventDefault Prevent Ui to handle this event or not.
     * @return true If last event if prevented or false if not..
     */
    public boolean update(MotionEvent event, boolean preventDefault) {
      // Don't prevent null event.
      if (event == null) {
        Log.e(TAG, "PreventTouchStream has null event.");
        return false;
      }

      if (DEBUG) {
        Log.d(TAG, "event action=" + event.getActionMasked() + " preventDefault=" + preventDefault);
      }

      boolean prevent = mLastPreventDefault;
      mLastPreventDefault = preventDefault;
      switch (event.getActionMasked()) {
        case MotionEvent.ACTION_DOWN:
        case MotionEvent.ACTION_MOVE:
        case MotionEvent.ACTION_POINTER_DOWN:
        case MotionEvent.ACTION_POINTER_UP:
          return prevent;
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL:
          mLastPreventDefault = false;
          return prevent;
        default:
          return preventDefault;
      }
    }
  @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;
  }
Example #4
0
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    if (controlling) {
      velocityTracker.addMovement(event);
      velocityTracker.computeCurrentVelocity(1);

      boolean down =
          event.getActionMasked() == MotionEvent.ACTION_DOWN
              || event.getActionMasked() == MotionEvent.ACTION_POINTER_DOWN;
      boolean up =
          event.getActionMasked() == MotionEvent.ACTION_UP
              || event.getActionMasked() == MotionEvent.ACTION_POINTER_UP;
      Finger[] fingers = new Finger[event.getPointerCount()];
      for (int i = 0; i < event.getPointerCount(); i++) {
        fingers[i] =
            new Finger(
                event.getPointerId(i),
                event.getX(i),
                event.getY(i),
                velocityTracker.getXVelocity(i),
                velocityTracker.getYVelocity(i),
                !(event.getActionIndex() == i && up));
      }

      FingerMessage<?> message =
          up ? new UpMessage(fingers) : down ? new DownMessage(fingers) : new MoveMessage(fingers);
      communicator.sendMessage(message);
    }
    return super.onTouchEvent(event);
  }
Example #5
0
  public boolean onTouchEvent2(MotionEvent event) {
    // Cancel current circle on two-fingers touch (or more.)
    if (event.getPointerCount() > 1) {
      cancelCircle(false);
      return false;
    }

    // If current circle is canceled then
    // ignore all actions except of touch down (to reset state.)
    if (mCanceled && event.getActionMasked() != MotionEvent.ACTION_DOWN) return false;

    final float x = event.getX();
    final float y = event.getY();
    switch (event.getActionMasked()) {
      case MotionEvent.ACTION_DOWN:
        clearAnimation();

        // Initialize circle
        mRadiusMax = 0;
        mPoint[0] = x;
        mPoint[1] = y;
        mCanceled = false;

        mHandler.removeCallbacks(mDelayedCancel);
        mHandler.postDelayed(mDelayedCancel, 1000);
        mCallback.onCircleEvent(mRadius, calculateRatio(), ACTION_START);
      case MotionEvent.ACTION_MOVE:
        setRadius((float) Math.hypot(x - mPoint[0], y - mPoint[1]));

        // Cancel the circle if it's decreasing.
        if (mRadiusMax - mRadius > mRadiusDecreaseThreshold) {
          mRadiusAimed = false;
          cancelCircle(false);
          break;
        }

        if (calculateRatio() == 1) {
          if (!mRadiusAimed) {
            mRadiusAimed = true;
            performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
          }
        } else if (mRadiusAimed) {
          mRadiusAimed = false;
          performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
        }
        break;
      case MotionEvent.ACTION_UP:
        if (mRadiusAimed) {
          mCallback.onCircleEvent(mRadius, calculateRatio(), ACTION_UNLOCK);
        }
      case MotionEvent.ACTION_CANCEL:
        mHandler.removeCallbacks(mDelayedCancel);
        cancelCircle(mRadiusAimed);
        break;
      default:
        return super.onTouchEvent(event);
    }
    return false;
  }
Example #6
0
  // returns the WebTouchEvent::Type for the MotionEvent and -1 for failure
  public static int createTouchPoints(MotionEvent event, TouchPoint[] pts) {

    int type;
    int defaultState;

    switch (event.getActionMasked()) {
      case MotionEvent.ACTION_DOWN:
        type = TOUCH_EVENT_TYPE_START;
        defaultState = TOUCH_POINT_STATE_PRESSED;
        break;
      case MotionEvent.ACTION_MOVE:
        type = TOUCH_EVENT_TYPE_MOVE;
        defaultState = TOUCH_POINT_STATE_MOVED;
        break;
      case MotionEvent.ACTION_UP:
        type = TOUCH_EVENT_TYPE_END;
        defaultState = TOUCH_POINT_STATE_RELEASED;
        break;
      case MotionEvent.ACTION_CANCEL:
        type = TOUCH_EVENT_TYPE_CANCEL;
        defaultState = TOUCH_POINT_STATE_CANCELLED;
        break;
      case MotionEvent.ACTION_POINTER_DOWN: // fall through.
      case MotionEvent.ACTION_POINTER_UP:
        type = TOUCH_EVENT_TYPE_MOVE;
        defaultState = TOUCH_POINT_STATE_STATIONARY;
        break;
      default:
        Log.e("Chromium", "Unknown motion event action: " + event.getActionMasked());
        return CONVERSION_ERROR;
    }

    for (int i = 0; i < pts.length; ++i) {
      int state = defaultState;
      if (defaultState == TOUCH_POINT_STATE_STATIONARY && event.getActionIndex() == i) {
        // An additional pointer has started or ended. Map this pointer state as
        // required, and all other pointers as "stationary".
        state =
            event.getActionMasked() == MotionEvent.ACTION_POINTER_DOWN
                ? TOUCH_POINT_STATE_PRESSED
                : TOUCH_POINT_STATE_RELEASED;
      }
      pts[i] =
          new TouchPoint(
              state,
              event.getPointerId(i),
              event.getX(i),
              event.getY(i),
              event.getSize(i),
              event.getPressure(i));
    }

    return type;
  }
 @Override
 public boolean onTouchEvent(MotionEvent event) {
   if (event.getActionMasked() == MotionEvent.ACTION_UP) {
     // Hack to prevent keyboard and insertion handle from showing.
     cancelLongPress();
   }
   if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
     Selection.setSelection(getText(), getOffsetForPosition(event.getX(), event.getY()));
   }
   return super.onTouchEvent(event);
 }
Example #8
0
 public void c(MotionEvent paramMotionEvent) {
   int j = paramMotionEvent.getHistorySize();
   int i = 0;
   while (i < j) {
     a(
         paramMotionEvent.getActionMasked(),
         paramMotionEvent.getHistoricalX(0, i),
         paramMotionEvent.getHistoricalY(0, i));
     i += 1;
   }
   a(paramMotionEvent.getActionMasked(), paramMotionEvent.getX(), paramMotionEvent.getY());
 }
Example #9
0
  @Override
  public boolean dispatchTouchEvent(MotionEvent ev) {
    if (ev.getActionMasked() == MotionEvent.ACTION_DOWN) {
      eventDownY = ev.getY();
      moveLength = curItem == 1 ? 0 : -firstViewHeight;
      handleEvent = checkHandleEvent(); // 按下之后,是否要处理move 和 up 事件
    }

    // 处理move 和 up 事件
    if (handleEvent) {
      if (ev.getActionMasked() == MotionEvent.ACTION_MOVE) {
        eventMoveY = ev.getY();
        interceptEvent = checkInterceptEvent(eventDownY, eventMoveY);

        // 拦截之后的move 和 up 事件
        if (interceptEvent) {
          moveLength += eventMoveY - eventDownY;
          eventDownY = eventMoveY;
          offsetTop = moveLength;

          checkBorder();
          requestLayout();

          return true;
        }
      }

      // 处理up事件,自动滑动
      if (interceptEvent) {
        if (ev.getActionMasked() == MotionEvent.ACTION_UP) {
          if (curItem == 1) {
            if (Math.abs(moveLength) > viewHeight / 3) { // 移动超过了一半
              smoothTo(2);
            } else {
              smoothTo(1);
            }
          } else {
            if (Math.abs(moveLength + firstViewHeight) > viewHeight / 3) { // 移动超过了一半
              smoothTo(1);
            } else {
              smoothTo(2);
            }
          }
          interceptEvent = false;
        }
      }
    }

    return super.dispatchTouchEvent(ev);
  }
Example #10
0
    @Override
    public boolean onInterceptTouchEvent(View view, MotionEvent event) {
      // We need to account for scroll state for the touched view otherwise
      // tapping on an "empty" part of the view will still be considered a
      // valid touch event.
      if (view.getScrollX() != 0 || view.getScrollY() != 0) {
        Rect rect = new Rect();
        view.getHitRect(rect);
        rect.offset(-view.getScrollX(), -view.getScrollY());

        int[] viewCoords = new int[2];
        view.getLocationOnScreen(viewCoords);

        int x = (int) event.getRawX() - viewCoords[0];
        int y = (int) event.getRawY() - viewCoords[1];

        if (!rect.contains(x, y)) return false;
      }

      // If the tab tray is showing, hide the tab tray and don't send the event to content.
      if (event.getActionMasked() == MotionEvent.ACTION_DOWN && autoHideTabs()) {
        mIsHidingTabs = true;
        return true;
      }
      return false;
    }
  public boolean onTouch(View v, MotionEvent event) {
    GiderosApplication app = GiderosApplication.getInstance();
    if (app == null) return false;

    int size = event.getPointerCount();
    for (int i = 0; i < size; i++) {
      id[i] = event.getPointerId(i);
      x[i] = (int) event.getX(i);
      y[i] = (int) event.getY(i);
    }

    int actionMasked = event.getActionMasked();
    boolean isPointer =
        (actionMasked == MotionEvent.ACTION_POINTER_DOWN
            || actionMasked == MotionEvent.ACTION_POINTER_UP);
    int actionIndex = isPointer ? event.getActionIndex() : 0;

    if (actionMasked == MotionEvent.ACTION_DOWN
        || actionMasked == MotionEvent.ACTION_POINTER_DOWN) {
      app.onTouchesBegin(size, id, x, y, actionIndex);
    } else if (actionMasked == MotionEvent.ACTION_MOVE) {
      app.onTouchesMove(size, id, x, y);
    } else if (actionMasked == MotionEvent.ACTION_UP
        || actionMasked == MotionEvent.ACTION_POINTER_UP) {
      app.onTouchesEnd(size, id, x, y, actionIndex);
    } else if (actionMasked == MotionEvent.ACTION_CANCEL) {
      app.onTouchesCancel(size, id, x, y);
    }

    return true;
  }
 private boolean isClickCandidateLocked(MotionEvent event) {
   if (event == null || event.getActionMasked() != MotionEvent.ACTION_UP || !mIsTapCandidate) {
     return false;
   }
   long downDuration = event.getEventTime() - event.getDownTime();
   return downDuration < LONG_PRESS_TIMEOUT;
 }
 public boolean onTouchEvent(MotionEvent ev) {
   int action = ev.getActionMasked();
   ViewParent parent = getParent(); // LinearLayout
   gestureDetector.onTouchEvent(ev);
   switch (action) {
     case MotionEvent.ACTION_DOWN:
       this.mDragHelper.processTouchEvent(ev);
       parent.requestDisallowInterceptTouchEvent(true);
       sX = ev.getRawX();
       sY = ev.getRawY();
       return true;
     case MotionEvent.ACTION_MOVE:
       float distanceX = ev.getRawX() - sX;
       float distanceY = ev.getRawY() - sY;
       sX = ev.getRawX();
       sY = ev.getRawY();
       float angle = Math.abs(distanceY / distanceX);
       angle = (float) Math.toDegrees(Math.atan(angle));
       if (angle > 30) {
         parent.requestDisallowInterceptTouchEvent(false);
         return false;
       }
       parent.requestDisallowInterceptTouchEvent(true);
       mDragHelper.processTouchEvent(ev);
       break;
     case MotionEvent.ACTION_UP:
     case MotionEvent.ACTION_CANCEL:
     default:
       parent.requestDisallowInterceptTouchEvent(true);
       mDragHelper.processTouchEvent(ev);
   }
   return true; // 必须返回true,表示已经正确处理touch事件,才能继续后续的拖动*/
 }
Example #14
0
  private boolean processTouch(MotionEvent event) {
    // Checking if that event was already processed
    // (by onInterceptTouchEvent prior to onTouchEvent)
    long eventTime = event.getEventTime();
    int action = event.getActionMasked();

    if (lastTouchEventTime == eventTime && lastTouchEventAction == action) {
      return lastTouchEventResult;
    }

    lastTouchEventTime = eventTime;
    lastTouchEventAction = action;

    if (getCount() > 0) {
      // Fixing event's Y position due to performed translation
      MotionEvent eventCopy = MotionEvent.obtain(event);
      eventCopy.offsetLocation(0, getTranslationY());
      lastTouchEventResult = gestureDetector.onTouchEvent(eventCopy);
      eventCopy.recycle();
    } else {
      lastTouchEventResult = false;
    }

    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
      onUpOrCancel();
    }

    return lastTouchEventResult;
  }
Example #15
0
  private boolean PopupTouchEvent(final MotionEvent event) {
    switch (event.getActionMasked()) {
      case MotionEvent.ACTION_DOWN:
        if (android.os.Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB)
          // mScrollIndicatorText.setVisibility(View.VISIBLE);
          toggleVisibilityCompat(false);
        else mScrollIndicatorText.startAnimation(mFadeIn);
        mScrolling = true;
        scroll(event.getY());
        return true;
      case MotionEvent.ACTION_MOVE:
        scroll(event.getY());
        return true;
      case MotionEvent.ACTION_UP:
        if (mType == TYPE_INDICATOR_WITH_HANDLE || mType == TYPE_POPUP_WITH_HANDLE)
          mHandlebar.setSelected(false);

        if (android.os.Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
          mScrolling = false;
          toggleVisibilityCompat(true);
        } else mScrollIndicatorText.startAnimation(mFadeOut);
        return true;
      default:
        break;
    }
    return false;
  }
Example #16
0
 @Override
 public boolean handleMotionEvent(MotionEvent event) {
   if ((event.getSource() & InputDevice.SOURCE_JOYSTICK) != 0) {
     int actionPointerIndex = event.getActionIndex();
     int action = event.getActionMasked();
     switch (action) {
       case MotionEvent.ACTION_MOVE:
         SDLJoystick joystick = getJoystick(event.getDeviceId());
         if (joystick != null) {
           for (int i = 0; i < joystick.axes.size(); i++) {
             InputDevice.MotionRange range = joystick.axes.get(i);
             /* Normalize the value to -1...1 */
             float value =
                 (event.getAxisValue(range.getAxis(), actionPointerIndex) - range.getMin())
                         / range.getRange()
                         * 2.0f
                     - 1.0f;
             SDLActivity.onNativeJoy(joystick.device_id, i, value);
           }
         }
         break;
       default:
         break;
     }
   }
   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(MotionEvent ev) {
    if (mTouchInterceptionListener == null) {
      return false;
    }

    // In here, we must initialize touch state variables
    // and ask if we should intercept this event.
    // Whether we should intercept or not is kept for the later event handling.
    switch (ev.getActionMasked()) {
      case MotionEvent.ACTION_DOWN:
        mInitialPoint = new PointF(ev.getX(), ev.getY());
        mPendingDownMotionEvent = MotionEvent.obtainNoHistory(ev);
        mDownMotionEventPended = true;
        mIntercepting = mTouchInterceptionListener.shouldInterceptTouchEvent(ev, false, 0, 0);
        mBeganFromDownMotionEvent = mIntercepting;
        mChildrenEventsCanceled = false;
        return mIntercepting;
      case MotionEvent.ACTION_MOVE:
        // ACTION_MOVE will be passed suddenly, so initialize to avoid exception.
        if (mInitialPoint == null) {
          mInitialPoint = new PointF(ev.getX(), ev.getY());
        }

        // diffX and diffY are the origin of the motion, and should be difference
        // from the position of the ACTION_DOWN event occurred.
        float diffX = ev.getX() - mInitialPoint.x;
        float diffY = ev.getY() - mInitialPoint.y;
        mIntercepting =
            mTouchInterceptionListener.shouldInterceptTouchEvent(ev, true, diffX, diffY);
        return mIntercepting;
    }
    return false;
  }
  private void postLongPress() {
    synchronized (mLock) {
      if (!mPostLongPressScheduled) {
        return;
      }
      mPostLongPressScheduled = false;

      MotionEvent event = mPostTouchStream.getLastEvent();
      if (event == null) {
        return;
      }

      switch (event.getActionMasked()) {
        case MotionEvent.ACTION_DOWN:
        case MotionEvent.ACTION_MOVE:
        case MotionEvent.ACTION_POINTER_DOWN:
        case MotionEvent.ACTION_POINTER_UP:
          break;
        default:
          return;
      }

      MotionEvent eventToEnqueue = MotionEvent.obtainNoHistory(event);
      eventToEnqueue.setAction(MotionEvent.ACTION_MOVE);
      DispatchEvent d =
          obtainDispatchEventLocked(
              eventToEnqueue,
              EVENT_TYPE_LONG_PRESS,
              0,
              mPostLastWebKitXOffset,
              mPostLastWebKitYOffset,
              mPostLastWebKitScale);
      enqueueEventLocked(d);
    }
  }
Example #20
0
 /** 处理触摸事件 */
 private boolean handleTouchEvent(MotionEvent motionEvent) {
   if (mViewWidth < 2) {
     mViewWidth = mRecyclerView.getWidth();
   }
   switch (motionEvent.getActionMasked()) {
     case MotionEvent.ACTION_DOWN:
       {
         actionDown(motionEvent);
         break;
       }
     case MotionEvent.ACTION_CANCEL:
       {
         actionCancel();
         break;
       }
     case MotionEvent.ACTION_UP:
       {
         actionUp(motionEvent);
         break;
       }
     case MotionEvent.ACTION_MOVE:
       {
         return actionMove(motionEvent);
       }
   }
   return false;
 }
Example #21
0
 @Override
 public boolean onTouchEvent(MotionEvent event) {
   if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
     thread.screenTouched();
   }
   return true;
 }
Example #22
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;
  }
Example #23
0
    @Override
    public boolean onTouch(View v, MotionEvent event) {

      //            opened_position     =   mListView.getPositionForView((View) v.getParent());
      switch (event.getActionMasked()) {
        case MotionEvent.ACTION_DOWN:
          {
            if (moptionsDisplay) {
              switch (v.getId()) {
                case 111111:
                  if (SwipeType == Dismiss) {
                    moptionsDisplay = false;
                    performDismiss(mDownView_parent, temp_position);
                  } else
                    //                                      if(old_mDownView!=null &&
                    // mDownView!=old_mDownView){
                    //                                          ResetListItem(old_mDownView);
                    //                                          old_mDownView=null;
                    //                                          mDownView=null;
                    //                                      }
                    tcallbacks.HalfSwipeListView(temp_position);
                  return true;
                case 222222:
                  tcallbacks.FullSwipeListView(temp_position);
                  return true;
              }
            }
          }
          return false;
      }

      return false;
    }
Example #24
0
  public static void dragVirtualButton(VirtualButton v, MotionEvent event) {
    float x, y;

    int action = event.getActionMasked();

    switch (action) {
      case (MotionEvent.ACTION_DOWN):
      case (MotionEvent.ACTION_MOVE):
        // Calculation of the new view position
        x =
            (v.getLeft() + event.getX() - v.getWidth() / 2)
                / v.getResources().getDisplayMetrics().widthPixels;
        y =
            (v.getTop() + event.getY() - v.getHeight() / 2)
                / v.getResources().getDisplayMetrics().heightPixels;

        Helper.setLayoutPosition((Activity) v.getContext(), v, x, y);

        v.setPosX(x);
        v.setPosY(y);

        return;
      default:
        return;
    }
  }
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
      switch (ev.getActionMasked()) {
        case MotionEvent.ACTION_DOWN:
          if (DEBUG_EDGE_SWIPE) Log.d(TAG, "action down " + ev.getY());
          mFirstX = ev.getX();
          mFirstY = ev.getY();
          mConsuming = false;
          break;

        case MotionEvent.ACTION_MOVE:
          if (DEBUG_EDGE_SWIPE) Log.d(TAG, "action move " + ev.getY());
          final float dY = ev.getY() - mFirstY;
          final float daX = Math.abs(ev.getX() - mFirstX);
          final float daY = Math.abs(dY);
          if (!mConsuming && daX < daY && daY > mTouchSlop) {
            snooze();
            if (dY > 0) {
              if (DEBUG_EDGE_SWIPE) Log.d(TAG, "found an open");
              mBar.animateExpandNotificationsPanel();
            }
            mConsuming = true;
          }
          break;

        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL:
          if (DEBUG_EDGE_SWIPE) Log.d(TAG, "action done");
          mConsuming = false;
          break;
      }
      return mConsuming;
    }
Example #26
0
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    int action = event.getActionMasked();
    int P = event.getPointerCount();
    // int N = event.getHistorySize();
    if (action != MotionEvent.ACTION_MOVE) {
      if (action == MotionEvent.ACTION_DOWN) {
        // startX = mCurX * mScale; // event.getX();
        // startY = mCurY * mScale; // event.getY();
        sX1 = mCurX * mScale - event.getX(0);
        sY1 = mCurY * mScale - event.getY(0);
        return true;
      }
      if (action == MotionEvent.ACTION_POINTER_DOWN) {
        // Toast.makeText(mContext,
        // Float.toString(sX1)+"apd",
        // Toast.LENGTH_SHORT).show();

        if (P == 2) {
          float sX2 = event.getX(0) - event.getX(1);
          float sY2 = event.getY(0) - event.getY(1);
          sD = (float) Math.sqrt(sX2 * sX2 + sY2 * sY2);
          mBitmapViewWidthInitial = mBitmapViewWidth;
          return true;
        } else if (P == 3) {
          sMx = (float) mCenterX - event.getX(2);
          sMy = (float) mCenterY - event.getY(2);
          return true;
        }
        return false;
      }
    } else {
      if (P == 1) {
        float a = Math.abs(sX1 + event.getX()) % mX;
        float b = Math.abs(sY1 + event.getY()) % mY;
        mCurX = (int) (a / mScale); // *(int)(event.getHistoricalX(0)-event.getHistoricalX(1));
        mCurY = (int) (b / mScale); // *(int)(event.getHistoricalY(0)-event.getHistoricalY(1));
      } else if (P == 2) {
        float sX2 = event.getX(0) - event.getX(1);
        float sY2 = event.getY(0) - event.getY(1);
        float sD2 = (float) Math.sqrt(sX2 * sX2 + sY2 * sY2);

        int r = mBitmapViewWidthInitial + Math.round(sD2 - sD);
        if (r < mScreenRadius) r = mScreenRadius;
        setViewBitmapSizes(r);
      } else if (P == 3) {
        mCenterX = (int) (sMx + event.getX(2));
        mCenterY = (int) (sMy + event.getY(2));
      } else {
        return false;
      }

      drawIntoBitmap();
      invalidate();
      if (use3D) {
        updateTexture();
      }
    }
    return true;
  }
Example #27
0
  @Override
  protected boolean onTouchImpl(View view, MotionEvent event) {
    boolean result = false;

    if (mJoystickLeft != null && mJoystickLeft.processTouch(view, event)) result = true;

    if (mJoystickRight != null && mJoystickRight.processTouch(view, event)) result = true;

    // check for double tap
    if (mSettings.isFlipEnabled() && event.getActionMasked() == MotionEvent.ACTION_POINTER_UP) {
      long currTimestamp = event.getEventTime();

      if (event.getPointerCount() > 1) {
        if (currTimestamp - timestampLast < DOUBLE_TAP_TIMESTAMP_DELTA
            && Math.abs(event.getX(1) - xLast) < COORDINATE_DELTA
            && Math.abs(event.getY(1) - yLast) < COORDINATE_DELTA) {
          // Double tap detected.
          mDroneControl.doLeftFlip();
          result = true;
        }
      }
    }

    return result;
  }
 @Override
 public boolean onTouchEvent(MotionEvent event) {
   final int action = event.getActionMasked();
   switch (action) {
     case MotionEvent.ACTION_DOWN:
       downX = event.getX();
       downY = event.getY();
       break;
     case MotionEvent.ACTION_UP:
       // 先判断是否是点击事件
       if ((isClickable() || isLongClickable())
           && ((event.getX() - downX) < mTouchSlop || (event.getY() - downY) < mTouchSlop)) {
         // 这里我们得到了一个点击事件
         if (isFocusable() && isFocusableInTouchMode() && !isFocused()) requestFocus();
         if (event.getEventTime() - event.getDownTime() >= ViewConfiguration.getLongPressTimeout()
             && isLongClickable()) {
           // 是一个长按事件
           //                        performLongClick();
           Log.i("actiontype", "longClick");
         } else {
           // 点击事件
           performClick(event.getX());
         }
       }
       break;
   }
   return true;
 }
 public boolean onTouchEvent(MotionEvent event) {
   if (event.getActionMasked() == MotionEvent.ACTION_UP) {
     if (mOnTouchUpListener != null) {
       return mOnTouchUpListener.onTouchUp(event);
     }
   }
   return true;
 }
Example #30
0
  /**
   * Handles forwarded events.
   *
   * @param activePointerId id of the pointer that activated forwarding
   * @return whether the event was handled
   */
  public boolean onForwardedEvent(MotionEvent event, int activePointerId) {
    boolean handledEvent = true;
    View vibrateView = null;

    final int actionMasked = event.getActionMasked();
    switch (actionMasked) {
      case MotionEvent.ACTION_CANCEL:
        handledEvent = false;
        break;
      case MotionEvent.ACTION_UP:
        handledEvent = false;
        // $FALL-THROUGH$
      case MotionEvent.ACTION_DOWN:
      case MotionEvent.ACTION_MOVE:
        final int activeIndex = event.findPointerIndex(activePointerId);
        if (activeIndex < 0) {
          handledEvent = false;
          break;
        }

        final int x = (int) event.getX(activeIndex);
        final int y = (int) event.getY(activeIndex);

        View pressedView = findViewByCoordinate(this, x, y, 0);
        if (mPressedChild != pressedView) {
          vibrateView = pressedView != null ? pressedView : mPressedChild;
          if (pressedView != null) pressedView.setPressed(true);
          if (mPressedChild != null) mPressedChild.setPressed(false);
          mPressedChild = pressedView;

          if (mOnForwardedEventListener != null) {
            mOnForwardedEventListener.onPressedView(event, activePointerId, mPressedChild);
          }
        }

        if (actionMasked == MotionEvent.ACTION_UP) {
          vibrateView = mPressedChild;
          clickPressedItem();
        }
        break;
    }

    // Failure to handle the event cancels forwarding.
    if (!handledEvent) {
      clearPressedItem();
    }

    if (vibrateView != null && mVibrateOnForwarded) {
      vibrateView.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
    }

    if (mOnForwardedEventListener != null) {
      mOnForwardedEventListener.onForwardedEvent(event, activePointerId);
    }

    return handledEvent;
  }