private HitTestResult hitTest(MotionEvent event) {
    float x = event.getX();
    float y = event.getY();

    RectF area = generateRect(m_leftTop, HitRadius, HitRadius);
    if (area.contains(x, y)) {
      return HitTestResult.TopLeft;
    }
    area = generateRect(m_rightBottom, HitRadius, HitRadius);
    if (area.contains(x, y)) {
      return HitTestResult.BottomRight;
    }

    area = generateRect(m_leftBottom, HitRadius, HitRadius);
    if (area.contains(x, y)) {
      return HitTestResult.BottomLeft;
    }

    area = generateRect(m_rightTop, HitRadius, HitRadius);
    if (area.contains(x, y)) {
      return HitTestResult.TopRight;
    }

    return HitTestResult.Outside;
  }
Exemple #2
0
 @Override
 public boolean onTouchEvent(PointF point) {
   if (routeLayer != null && routeLayer.getHelper().isRouterEnabled()) {
     if (boundsForMiniRoute.contains(point.x, point.y)
         && routeLayer.getHelper().isFollowingMode()) {
       showMiniMap = !showMiniMap;
       view.refreshMap();
       return true;
     }
     if (boundsForLeftTime.contains(point.x, point.y)
         && routeLayer.getHelper().isFollowingMode()) {
       showArrivalTime = !showArrivalTime;
       view.getSettings().SHOW_ARRIVAL_TIME_OTHERWISE_EXPECTED_TIME.set(showArrivalTime);
       view.refreshMap();
       return true;
     }
   }
   if (cachedDistString != null && boundsForDist.contains(point.x, point.y)) {
     AnimateDraggingMapThread thread = view.getAnimatedDraggingThread();
     LatLon pointToNavigate = view.getSettings().getPointToNavigate();
     if (pointToNavigate != null) {
       int fZoom = view.getZoom() < 15 ? 15 : view.getZoom();
       thread.startMoving(
           pointToNavigate.getLatitude(), pointToNavigate.getLongitude(), fZoom, true);
     }
   }
   return false;
 }
  // Returns true if the line segment defined by the given two points intersects the given
  // rectangle.
  public static boolean lineSegmentIntersectsRect(PointF p1, PointF p2, RectF r2) {
    RectF line =
        new RectF(
            Math.min(p1.x, p2.x), Math.min(p1.y, p2.y), Math.max(p1.x, p2.x), Math.max(p1.y, p2.y));

    // If the bounding box of the line segment intersects the rectangle or one contains the other,
    //    the line segment intersects the rectangle.
    return RectF.intersects(line, r2) || line.contains(r2) || r2.contains(line);
  }
  public final boolean onSingleTapConfirmed(MotionEvent e) {
    ImageView imageView = getImageView();

    if (null != imageView) {
      if (null != mPhotoTapListener) {
        final RectF displayRect = getDisplayRect();

        if (null != displayRect) {
          final float x = e.getX(), y = e.getY();

          // Check to see if the user tapped on the photo
          if (displayRect.contains(x, y)) {

            float xResult = (x - displayRect.left) / displayRect.width();
            float yResult = (y - displayRect.top) / displayRect.height();

            mPhotoTapListener.onPhotoTap(imageView, xResult, yResult);
            return true;
          }
        }
      }
      if (null != mViewTapListener) {
        mViewTapListener.onViewTap(imageView, e.getX(), e.getY());
      }
    }

    return false;
  }
  @Override
  public boolean onSingleTapConfirmed(MotionEvent e) {
    if (this.photoViewAttacher == null) return false;

    ImageView imageView = photoViewAttacher.getImageView();

    if (null != photoViewAttacher.getOnPhotoTapListener()) {
      final RectF displayRect = photoViewAttacher.getDisplayRect();

      if (null != displayRect) {
        final float x = e.getX(), y = e.getY();

        // Check to see if the user tapped on the photo
        if (displayRect.contains(x, y)) {

          float xResult = (x - displayRect.left) / displayRect.width();
          float yResult = (y - displayRect.top) / displayRect.height();

          photoViewAttacher.getOnPhotoTapListener().onPhotoTap(imageView, xResult, yResult);
          return true;
        }
      }
    }
    if (null != photoViewAttacher.getOnViewTapListener()) {
      photoViewAttacher.getOnViewTapListener().onViewTap(imageView, e.getX(), e.getY());
    }

    return false;
  }
  @Override
  public boolean dispatchTouchEvent(MotionEvent ev) {

    for (int i = getChildCount() - 1; i >= 0; i--) {
      View v = getChildAt(i);
      if (v.getVisibility() != View.VISIBLE) continue;
      Matrix m = getViewMatrix(v);
      if (m != null) {
        float[] points = new float[] {ev.getX(), ev.getY()};
        RectF rect = new RectF(v.getLeft(), v.getTop(), v.getRight(), v.getBottom());

        Matrix realM = new Matrix(m);
        realM.preTranslate(-rect.left, -rect.top);
        realM.postTranslate(rect.left, rect.top);
        realM.mapRect(rect);
        if (rect.contains((int) points[0], (int) points[1])) {
          Matrix mi = new Matrix();
          realM.invert(mi);
          if (mi != null) {
            mi.mapPoints(points);
            ev.setEdgeFlags(
                ev.getEdgeFlags() | FLAG_TRANSFORMED); // a trick to mark the event as transformed
            ev.setLocation(
                points[0], points[1]); // without the transform point the view wont receive it
            return super.dispatchTouchEvent(ev);
          }
        }
      }
    }
    Matrix m = getMyViewMatrix();
    int flag = ev.getEdgeFlags();
    if (m != null && ((flag & FLAG_TRANSFORMED) != FLAG_TRANSFORMED)) {
      float[] points = new float[] {ev.getX(), ev.getY()}; // untransformed point
      RectF rect = new RectF(getLeft(), getTop(), getRight(), getBottom()); // untransformed rect
      Matrix realM = new Matrix(m);
      realM.preTranslate(-rect.left, -rect.top);
      realM.postTranslate(rect.left, rect.top);
      realM.mapRect(rect);
      points[0] += getLeft();
      points[1] += getTop();
      if (!rect.contains(points[0], points[1]) && ev.getAction() == MotionEvent.ACTION_DOWN) {
        Log.d("FreeLayout", this + "not dispatching");
        return false;
      }
    }
    return super.dispatchTouchEvent(ev);
  }
Exemple #7
0
  public int checkUnitChange(float x, float y) {
    if (!DIMENSIONS.contains(x, y)) return -1;

    if (y < UNIT_HEIGHT) {
      return 0;
    } else {
      return 1;
    }
  }
 @Override
 public boolean onTouchEvent(MotionEvent event) {
   // TODO Auto-generated method stub
   switch (event.getAction()) {
     case MotionEvent.ACTION_DOWN:
       // 獲取按下點坐標
       mDownX = event.getX();
       mDownY = event.getY();
       break;
     case MotionEvent.ACTION_MOVE:
       // 判斷是否為下游標
       if (mCursorBottomDstRect.contains(mDownX, mDownY)) {
         float offSetX = event.getX() - mDownX;
         mCursorBottomDstRect.left = mCursorBottomDstRect.left + offSetX;
         mCursorBottomDstRect.right = mCursorBottomDstRect.left + offSetX + mBitmap.getWidth();
         mDownX = event.getX();
         mDownY = event.getY();
         invalidate();
       }
       // 判斷是否為上游標
       if (mCursorTopDstRect.contains(mDownX, mDownY)) {
         float offSetX = event.getX() - mDownX;
         mCursorTopDstRect.left = mCursorTopDstRect.left + offSetX;
         mCursorTopDstRect.right = mCursorTopDstRect.left + offSetX + mBitmap.getWidth();
         mDownX = event.getX();
         mDownY = event.getY();
         invalidate();
       }
       break;
     case MotionEvent.ACTION_CANCEL:
     case MotionEvent.ACTION_UP:
       // 手指抬起,校正游標位置
       setCursorPositon(mTopCalibration, mCursorTopDstRect);
       setCursorPositon(mBottomCalibration, mCursorBottomDstRect);
       invalidate();
       break;
     default:
       break;
   }
   return true;
 }
  private boolean moveTrackersIfNeeded(MotionEvent event) {
    if (mStartTouchPoint == null) return false;

    boolean update = false;

    int startX = mStartTouchPoint.x;
    int startY = mStartTouchPoint.y;

    if (mHueRect.contains(startX, startY)) {
      mLastTouchedPanel = PANEL_HUE;
      mHue = pointToHue(event.getY());
      update = true;
    } else if (mSatValRect.contains(startX, startY)) {
      mLastTouchedPanel = PANEL_SAT_VAL;
      float[] result = pointToSatVal(event.getX(), event.getY());
      mSat = result[0];
      mVal = result[1];
      update = true;
    }

    return update;
  }
 public boolean onTouchEvent(MotionEvent paramMotionEvent) {
   if ((a.b()) || (!m)) {
     return super.onTouchEvent(paramMotionEvent);
   }
   int n = paramMotionEvent.getAction();
   float f1 = paramMotionEvent.getX();
   float f2 = paramMotionEvent.getY();
   switch (n) {
   }
   for (; ; ) {
     return super.onTouchEvent(paramMotionEvent);
     n = 0;
     for (; ; ) {
       if (n < e) {
         RectF localRectF = (RectF) b.get(n);
         if (localRectF.contains(f1, f2)) {
           a(n);
           c = localRectF;
         }
       } else {
         invalidate();
         break;
       }
       n += 1;
     }
     if ((c != null) && (!c.contains(f1, f2))) {
       c();
       continue;
       if ((d != -1) && (f != null)) {
         f.a(this, d, e);
       }
       c();
       continue;
       c();
     }
   }
 }
Exemple #11
0
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    if (mController.isIgnoringTouchEvents()) return false;

    // prevent ray cast of touch events to actions container
    getHitRect(mHitRect);
    mHitRect.offset(-getScrollX(), -getScrollY());

    // applying effects
    mEffectedHitRect.set(mHitRect);
    mController.getEffectsMatrix().mapRect(mEffectedHitRect);

    if (mEffectedHitRect.contains((int) event.getX(), (int) event.getY())) {
      return true;
    }

    return super.onTouchEvent(event);
  }
        @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
        @Override
        public int onTestSize(int suggestedSize, RectF availableSPace) {
          mPaint.setTextSize(suggestedSize);
          String text = getText().toString();
          boolean singleline = getMaxLines() == 1;
          if (singleline) {
            mTextRect.bottom = mPaint.getFontSpacing();
            mTextRect.right = mPaint.measureText(text);
          } else {
            StaticLayout layout =
                new StaticLayout(
                    text,
                    mPaint,
                    mWidthLimit,
                    Alignment.ALIGN_NORMAL,
                    mSpacingMult,
                    mSpacingAdd,
                    true);
            // return early if we have more lines
            if (getMaxLines() != NO_LINE_LIMIT && layout.getLineCount() > getMaxLines()) {
              return 1;
            }
            mTextRect.bottom = layout.getHeight();
            int maxWidth = -1;
            for (int i = 0; i < layout.getLineCount(); i++) {
              if (maxWidth < layout.getLineWidth(i)) {
                maxWidth = (int) layout.getLineWidth(i);
              }
            }
            mTextRect.right = maxWidth;
          }

          mTextRect.offsetTo(0, 0);
          if (availableSPace.contains(mTextRect)) {
            // may be too small, don't worry we will find the best match
            return -1;
          } else {
            // too big
            return 1;
          }
        }
  /** Test whether an information balloon should be displayed or a prior balloon hidden. */
  private MapLocation getHitMapLocation(MapView mapView, GeoPoint tapPoint) {

    /** Tracking the clicks on MapLocation */
    MapLocation hitMapLocation = null;

    RectF hitTestRecr = new RectF();
    Point screenCoords = new Point();
    Iterator<MapLocation> iterator = mLocationViewers.getMapLocations().iterator();
    while (iterator.hasNext()) {
      MapLocation testLocation = iterator.next();

      Bitmap bubbleIcon = testLocation.isSpecial() ? mBubbleIconSpecial : mBubbleIcon;

      /** This is used to translate the map's lat/long coordinates to screen's coordinates */
      mapView
          .getProjection()
          .toPixels(
              new GeoPoint(testLocation.getLatitude(), testLocation.getLongitude()), screenCoords);

      // Create a testing Rectangle with the size and coordinates of our icon
      // Set the testing Rectangle with the size and coordinates of our on screen icon
      hitTestRecr.set(
          -bubbleIcon.getWidth() / 2, -bubbleIcon.getHeight(), bubbleIcon.getWidth() / 2, 0);
      hitTestRecr.offset(screenCoords.x, screenCoords.y);

      //  At last test for a match between our Rectangle and the location clicked by the user
      mapView.getProjection().toPixels(tapPoint, screenCoords);
      if (hitTestRecr.contains(screenCoords.x, screenCoords.y)) {
        hitMapLocation = testLocation;
        break;
      }
    }

    //  Finally clear the new MouseSelection as its process finished
    tapPoint = null;

    return hitMapLocation;
  }
Exemple #14
0
  private GeoTrack getHitMapLocation(MapView mapView, IGeoPoint tapPoint) {
    // Track which MapLocation was hit...if any
    GeoTrack result = null;
    RectF tapPointHitTestRect = new RectF();
    Point tapPointTestScreenCoords = new Point();
    int zoonLevel = mapView.getZoomLevel();
    int selectRadius = zoonLevel + 6;
    Projection pj = mapView.getProjection();
    for (GeoTrack testLocation : geoTracks) {
      if (!seletedRangeActivated
          || (testLocation.time >= seletedRangeBeginTimeInMs
              && testLocation.time <= seletedRangeEndTimeInMs)) {
        // Translate the MapLocation's lat/long coordinates to screen
        // coordinates
        pj.toPixels(testLocation.asGeoPoint(), tapPointTestScreenCoords);

        // Create a 'hit' testing Rectangle w/size and coordinates of
        // our
        // icon
        // Set the 'hit' testing Rectangle with the size and coordinates
        // of
        // our on screen icon
        tapPointHitTestRect.set(-selectRadius, -selectRadius, selectRadius, selectRadius);
        tapPointHitTestRect.offset(tapPointTestScreenCoords.x, tapPointTestScreenCoords.y);

        // Finally test for a match between our 'hit' Rectangle and the
        // location clicked by the user
        pj.toPixels(tapPoint, tapPointTestScreenCoords);
        if (tapPointHitTestRect.contains(tapPointTestScreenCoords.x, tapPointTestScreenCoords.y)) {
          result = testLocation;
          // break;
        }
      }
    }
    return result;
  }
    @Override
    public boolean onSingleTapConfirmed(MotionEvent event) {
      if (photoTapListener != null) {
        final RectF displayRect = getDisplayRect();

        if (null != displayRect) {
          final float x = event.getX(), y = event.getY();

          // Check to see if the user tapped on the photo
          if (displayRect.contains(x, y)) {

            float xResult = (x - displayRect.left) / displayRect.width();
            float yResult = (y - displayRect.top) / displayRect.height();

            photoTapListener.onPhotoTap(ZoomImageView.this, xResult, yResult);
            return true;
          }
        }
      }
      if (viewTapListener != null) {
        viewTapListener.onViewTap(ZoomImageView.this, event.getX(), event.getY());
      }
      return false;
    }
  @Override
  public boolean onTouchEvent(MotionEvent ev) {
    if (!mDragging) {
      return false;
    }

    final int action = ev.getAction();
    final float x = ev.getX();
    final float y = ev.getY();

    switch (action) {
      case MotionEvent.ACTION_DOWN:

        // Remember where the motion event started
        mLastMotionX = x;
        mLastMotionY = y;

        if ((x < SCROLL_ZONE) || (x > getWidth() - SCROLL_ZONE)) {
          mScrollState = SCROLL_WAITING_IN_ZONE;
          postDelayed(mScrollRunnable, SCROLL_DELAY);
        } else {
          mScrollState = SCROLL_OUTSIDE_ZONE;
        }

        break;
      case MotionEvent.ACTION_MOVE:
        final int scrollX = mScrollX;
        final int scrollY = mScrollY;

        final float touchX = mTouchOffsetX;
        final float touchY = mTouchOffsetY;

        final int offsetX = mBitmapOffsetX;
        final int offsetY = mBitmapOffsetY;

        int left = (int) (scrollX + mLastMotionX - touchX - offsetX);
        int top = (int) (scrollY + mLastMotionY - touchY - offsetY);

        int width;
        int height;
        if (mDrawModeBitmap && mDragBitmap != null) {
          final Bitmap dragBitmap = mDragBitmap;
          width = dragBitmap.getWidth();
          height = dragBitmap.getHeight();
        } else {
          width = mDrawWidth;
          height = mDrawHeight;
        }
        final Rect rect = mRect;
        rect.set(left - 1, top - 1, left + width + 1, top + height + 1);

        mLastMotionX = x;
        mLastMotionY = y;

        left = (int) (scrollX + x - touchX - offsetX);
        top = (int) (scrollY + y - touchY - offsetY);

        // Invalidate current icon position
        rect.union(left - 1, top - 1, left + width + 1, top + height + 1);

        final int[] coordinates = mDropCoordinates;
        DropTarget dropTarget = findDropTarget((int) x, (int) y, coordinates);
        if (dropTarget != null) {
          if (mLastDropTarget == dropTarget) {
            dropTarget.onDragOver(
                mDragSource,
                coordinates[0],
                coordinates[1],
                (int) mTouchOffsetX,
                (int) mTouchOffsetY,
                mDragInfo);
          } else {
            if (mLastDropTarget != null) {
              mLastDropTarget.onDragExit(
                  mDragSource,
                  coordinates[0],
                  coordinates[1],
                  (int) mTouchOffsetX,
                  (int) mTouchOffsetY,
                  mDragInfo);
            }
            dropTarget.onDragEnter(
                mDragSource,
                coordinates[0],
                coordinates[1],
                (int) mTouchOffsetX,
                (int) mTouchOffsetY,
                mDragInfo);
          }
        } else {
          if (mLastDropTarget != null) {
            mLastDropTarget.onDragExit(
                mDragSource,
                coordinates[0],
                coordinates[1],
                (int) mTouchOffsetX,
                (int) mTouchOffsetY,
                mDragInfo);
          }
        }

        invalidate(rect);

        mLastDropTarget = dropTarget;
        if (mTagPopup != null) {
          if (Math.abs(mOriginalX - mLastMotionX) > SCROLL_ZONE
              || Math.abs(mOriginalY - mLastMotionY) > SCROLL_ZONE) {
            final QuickActionWindow qa = (QuickActionWindow) mTagPopup;
            qa.dismiss();
            mTagPopup = null;
          }
        }
        boolean inDragRegion = false;
        if (mDragRegion != null) {
          final RectF region = mDragRegion;
          final boolean inRegion = region.contains(ev.getRawX(), ev.getRawY());
          if (!mEnteredRegion && inRegion) {
            mDragPaint = mTrashPaint;
            mRectPaint.setColor(COLOR_TRASH);
            mEnteredRegion = true;
            inDragRegion = true;
          } else if (mEnteredRegion && !inRegion) {
            mDragPaint = null;
            mRectPaint.setColor(COLOR_NORMAL);
            mEnteredRegion = false;
          }
        }

        if (!inDragRegion && x < SCROLL_ZONE) {
          if (mScrollState == SCROLL_OUTSIDE_ZONE) {
            mScrollState = SCROLL_WAITING_IN_ZONE;
            mScrollRunnable.setDirection(SCROLL_LEFT);
            postDelayed(mScrollRunnable, SCROLL_DELAY);
          }
        } else if (!inDragRegion && x > getWidth() - SCROLL_ZONE) {
          if (mScrollState == SCROLL_OUTSIDE_ZONE) {
            mScrollState = SCROLL_WAITING_IN_ZONE;
            mScrollRunnable.setDirection(SCROLL_RIGHT);
            postDelayed(mScrollRunnable, SCROLL_DELAY);
          }
        } else {
          if (mScrollState == SCROLL_WAITING_IN_ZONE) {
            mScrollState = SCROLL_OUTSIDE_ZONE;
            mScrollRunnable.setDirection(SCROLL_RIGHT);
            removeCallbacks(mScrollRunnable);
          }
        }

        break;
      case MotionEvent.ACTION_UP:
        removeCallbacks(mScrollRunnable);
        if (mShouldDrop) {
          drop(x, y);
          mShouldDrop = false;
        }
        endDrag();

        break;
      case MotionEvent.ACTION_CANCEL:
        endDrag();
    }

    return true;
  }
  /**
   * Handles the touch event.
   *
   * @param event the touch event
   */
  public boolean handleTouch(MotionEvent event) {
    int action = event.getAction();
    if (mRenderer != null && action == MotionEvent.ACTION_MOVE) {
      if (oldX >= 0 || oldY >= 0) {
        float newX = event.getX(0);
        float newY = event.getY(0);
        if (event.getPointerCount() > 1
            && (oldX2 >= 0 || oldY2 >= 0)
            && mRenderer.isZoomEnabled()) {
          float newX2 = event.getX(1);
          float newY2 = event.getY(1);
          float newDeltaX = Math.abs(newX - newX2);
          float newDeltaY = Math.abs(newY - newY2);
          float oldDeltaX = Math.abs(oldX - oldX2);
          float oldDeltaY = Math.abs(oldY - oldY2);
          float zoomRate = 1;

          float tan1 = Math.abs(newY - oldY) / Math.abs(newX - oldX);
          float tan2 = Math.abs(newY2 - oldY2) / Math.abs(newX2 - oldX2);
          if (tan1 <= 0.25 && tan2 <= 0.25) {
            // horizontal pinch zoom, |deltaY| / |deltaX| is [0 ~ 0.25], 0.25 is
            // the approximate value of tan(PI / 12)
            zoomRate = newDeltaX / oldDeltaX;
            applyZoom(zoomRate, Zoom.ZOOM_AXIS_X);
          } else if (tan1 >= 3.73 && tan2 >= 3.73) {
            // pinch zoom vertically, |deltaY| / |deltaX| is [3.73 ~ infinity],
            // 3.732 is the approximate value of tan(PI / 2 - PI / 12)
            zoomRate = newDeltaY / oldDeltaY;
            applyZoom(zoomRate, Zoom.ZOOM_AXIS_Y);
          } else {
            // pinch zoom diagonally
            if (Math.abs(newX - oldX) >= Math.abs(newY - oldY)) {
              zoomRate = newDeltaX / oldDeltaX;
            } else {
              zoomRate = newDeltaY / oldDeltaY;
            }
            applyZoom(zoomRate, Zoom.ZOOM_AXIS_XY);
          }
          oldX2 = newX2;
          oldY2 = newY2;
        } else if (mRenderer.isPanEnabled()) {
          mPan.apply(oldX, oldY, newX, newY);
          oldX2 = 0;
          oldY2 = 0;
        }
        oldX = newX;
        oldY = newY;
        graphicalView.repaint();
        return true;
      }
    } else if (action == MotionEvent.ACTION_DOWN) {
      oldX = event.getX(0);
      oldY = event.getY(0);
      if (mRenderer != null && mRenderer.isZoomEnabled() && zoomR.contains(oldX, oldY)) {
        if (oldX < zoomR.left + zoomR.width() / 3) {
          graphicalView.zoomIn();
        } else if (oldX < zoomR.left + zoomR.width() * 2 / 3) {
          graphicalView.zoomOut();
        } else {
          graphicalView.zoomReset();
        }
        return true;
      }
    } else if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_UP) {
      oldX = 0;
      oldY = 0;
      oldX2 = 0;
      oldY2 = 0;
      if (action == MotionEvent.ACTION_POINTER_UP) {
        oldX = -1;
        oldY = -1;
      }
    }
    return !mRenderer.isClickEnabled();
  }
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    boolean handled = true;
    switch (event.getAction() & MotionEvent.ACTION_MASK) {
      case MotionEvent.ACTION_DOWN:
        {
          // 删除按钮接收事件
          if (mShowDashBorder && mDelDrawRectF.contains(event.getX(), event.getY())) {
            if (getParent() instanceof ViewGroup) {
              ((ViewGroup) getParent()).removeView(DashFrameLayout.this);
            }
            break;
          }
          // 拖放按钮接收事件
          if (mShowDashBorder && mDragDrawRectF.contains(event.getX(), event.getY())) {
            mode = SINGLE_ZOOM;
            showDashBorder(true);

            mPreDistance =
                Utils.calcDistance(mCenterPoint[0], mCenterPoint[1], event.getX(), event.getY());
            mPreRotation =
                Utils.calcRotation(mCenterPoint[0], mCenterPoint[1], event.getX(), event.getY());
            break;
          }
          /** 判断虚线框是否接收事件; 因旋转后无法直接判断事件是否在rect内, 可将坐标点反向旋转后再与未进行旋转的rect进行比较判断 */
          mDashDrawRectF.set(mDashRectF);
          mViewNoRotateMatrix.mapRect(mDashDrawRectF);
          Matrix inverseMatrix = new Matrix();
          // 获取反向旋转矩阵
          inverseMatrix.postRotate(360 - mCurRotation, mCenterPoint[0], mCenterPoint[1]);
          // 将当前坐标反向旋转,再进行判断
          float[] eventPoint = {event.getX(), event.getY()};
          inverseMatrix.mapPoints(eventPoint);
          if (mDashDrawRectF.contains(eventPoint[0], eventPoint[1])) {
            mode = DRAG;

            mInitTouchX = event.getX();
            mInitTouchY = event.getY();

            mLastTouchX = event.getX();
            mLastTouchY = event.getY();
          } else {
            handled = false;
          }

          showDashBorder(handled);
          if (handled && mListener != null) {
            mListener.onFocus();
            mAlwaysInTapRegion = true;
          }
          break;
        }
      case MotionEvent.ACTION_MOVE:
        {
          if (mAlwaysInTapRegion) {
            float deltaX = event.getX() - mInitTouchX;
            float deltaY = event.getY() - mInitTouchY;
            // 判断是否在点击区域内
            if ((deltaX * deltaX) + (deltaY * deltaY) > mTouchSlopSquare) {
              mAlwaysInTapRegion = false;
            }
          }

          if (mode == SINGLE_ZOOM || mode == DOUBLE_ZOOM) {
            float curDistance, endRotation;
            if (mode == SINGLE_ZOOM) {
              // 单指缩放、旋转
              curDistance =
                  Utils.calcDistance(mCenterPoint[0], mCenterPoint[1], event.getX(), event.getY());
              endRotation =
                  Utils.calcRotation(mCenterPoint[0], mCenterPoint[1], event.getX(), event.getY());
            } else {
              // 双指缩放、旋转
              curDistance = Utils.calcDistance(event);
              endRotation = Utils.calcRotation(event);
            }
            scale(curDistance / mPreDistance);
            mPreDistance = curDistance;

            rotate(endRotation - mPreRotation);
            mPreRotation = endRotation;
          } else if (mode == DRAG) {
            translate(event.getX() - mLastTouchX, event.getY() - mLastTouchY);
            mLastTouchX = event.getX();
            mLastTouchY = event.getY();
          }
          invalidate();
          break;
        }
      case MotionEvent.ACTION_POINTER_DOWN:
        {
          mAlwaysInTapRegion = false;
          if (mode != SINGLE_ZOOM) {
            mode = DOUBLE_ZOOM;
            mPreDistance = Utils.calcDistance(event);
            mPreRotation = Utils.calcRotation(event);
          }
          break;
        }
      case MotionEvent.ACTION_UP:
        {
          mode = NONE;
          mPreRotation = 0.f;

          if (mAlwaysInTapRegion && mPreShowDashBorder && mListener != null) {
            mListener.onClick();
          }
          mAlwaysInTapRegion = false;
          break;
        }
      case MotionEvent.ACTION_POINTER_UP:
        {
          if (mode != SINGLE_ZOOM) {
            mode = NONE;
            mPreRotation = 0.f;
          }
          break;
        }
    }
    return handled;
  }
Exemple #19
0
 final boolean hitTest(float x, float y) {
   return bounds.contains(x, y);
 }
  /** Call this from a drag source view. */
  public boolean onTouchEvent(MotionEvent ev) {
    View scrollView = mScrollView;

    if (!mDragging) {
      return false;
    }

    final int action = ev.getAction();
    final int screenX = clamp((int) ev.getRawX(), 0, mDisplayMetrics.widthPixels);
    final int screenY = clamp((int) ev.getRawY(), 0, mDisplayMetrics.heightPixels);

    switch (action) {
      case MotionEvent.ACTION_DOWN:
        // Remember where the motion event started
        mMotionDownX = screenX;
        mMotionDownY = screenY;

        mScrollState = SCROLL_OUTSIDE_ZONE;

        /*
         * if ((screenX < mScrollZone) || (screenX > scrollView.getWidth() - mScrollZone)) {
         * mScrollState = SCROLL_WAITING_IN_ZONE;
         * mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
         * } else {
         * mScrollState = SCROLL_OUTSIDE_ZONE;
         * }
         */
        break;
      case MotionEvent.ACTION_MOVE:
        // Update the drag view. Don't use the clamped pos here so the dragging looks
        // like it goes off screen a little, intead of bumping up against the edge.
        mDragView.move((int) ev.getRawX(), (int) ev.getRawY());

        // Drop on someone?
        final int[] coordinates = mCoordinatesTemp;
        DropTarget dropTarget = findDropTarget(screenX, screenY, coordinates);
        if (dropTarget != null) {
          if (mLastDropTarget == dropTarget) {
            dropTarget.onDragOver(
                mDragSource,
                coordinates[0],
                coordinates[1],
                (int) mTouchOffsetX,
                (int) mTouchOffsetY,
                mDragView,
                mDragInfo);
          } else {
            if (mLastDropTarget != null) {
              mLastDropTarget.onDragExit(
                  mDragSource,
                  coordinates[0],
                  coordinates[1],
                  (int) mTouchOffsetX,
                  (int) mTouchOffsetY,
                  mDragView,
                  mDragInfo);
            }
            dropTarget.onDragEnter(
                mDragSource,
                coordinates[0],
                coordinates[1],
                (int) mTouchOffsetX,
                (int) mTouchOffsetY,
                mDragView,
                mDragInfo);
          }
        } else {
          if (mLastDropTarget != null) {
            mLastDropTarget.onDragExit(
                mDragSource,
                coordinates[0],
                coordinates[1],
                (int) mTouchOffsetX,
                (int) mTouchOffsetY,
                mDragView,
                mDragInfo);
          }
        }
        mLastDropTarget = dropTarget;

        // Scroll, maybe, but not if we're in the delete region.
        boolean inDeleteRegion = false;
        if (mDeleteRegion != null) {
          inDeleteRegion = mDeleteRegion.contains(screenX, screenY);
        }

        /*
         * if(screenY < 100) {
         * mDragScroller.scrollUp();
         * } else if(screenY > mDisplayMetrics.heightPixels - 100) {
         * mDragScroller.scrollDown();
         * }
         */
        /*
         * //Log.d(Launcher.TAG, "inDeleteRegion=" + inDeleteRegion + " screenX=" + screenX
         * // + " mScrollZone=" + mScrollZone);
         * if (!inDeleteRegion && screenX < mScrollZone) {
         * if (mScrollState == SCROLL_OUTSIDE_ZONE) {
         * mScrollState = SCROLL_WAITING_IN_ZONE;
         * mScrollRunnable.setDirection(SCROLL_LEFT);
         * mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
         * }
         * } else if (!inDeleteRegion && screenX > scrollView.getWidth() - mScrollZone) {
         * if (mScrollState == SCROLL_OUTSIDE_ZONE) {
         * mScrollState = SCROLL_WAITING_IN_ZONE;
         * mScrollRunnable.setDirection(SCROLL_RIGHT);
         * mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
         * }
         * } else {
         * if (mScrollState == SCROLL_WAITING_IN_ZONE) {
         * mScrollState = SCROLL_OUTSIDE_ZONE;
         * mScrollRunnable.setDirection(SCROLL_RIGHT);
         * mHandler.removeCallbacks(mScrollRunnable);
         * }
         * }
         */

        break;
      case MotionEvent.ACTION_UP:
        mHandler.removeCallbacks(mScrollRunnable);
        if (mDragging) {
          drop(screenX, screenY);
        }
        endDrag();

        break;
      case MotionEvent.ACTION_CANCEL:
        cancelDrag();
    }

    return true;
  }
Exemple #21
0
 private void drawGreyFrame(Canvas canvas, RectF bBox, Transformation t) {
   paper.set(
       t.offset_x, t.offset_y, t.offset_x + aspectRatio.ratio * t.scale, t.offset_y + t.scale);
   if (!paper.contains(bBox)) canvas.drawARGB(0xff, 0xaa, 0xaa, 0xaa);
 }