Пример #1
0
  public void setWindSpeedDirection(int direction) {
    // ----Point for the triangle indicator-------
    Point a = new Point(x, y - (int) ((height / 2) - textSize));
    Point b = new Point(x - (height / 17), y);
    Point c = new Point(x + (height / 17), y);

    Path path = new Path();
    path.moveTo(a.x, a.y);
    path.lineTo(b.x, b.y);
    path.lineTo(c.x, c.y);
    path.lineTo(a.x, a.y);
    path.close();

    // Red Brush for the painting
    Paint redBrush = new Paint(Paint.ANTI_ALIAS_FLAG);
    redBrush.setColor(Color.RED);
    redBrush.setStrokeWidth(3f);

    if (currentDegrees != direction) {
      // matrix.postRotate(currentDegrees++,x,y);
      mCanvas.rotate(currentDegrees++, x, y);
    } else {
      finishAnimation = true;
      mCanvas.rotate(direction, x, y);
    }
    mCanvas.drawPath(path, redBrush);
    mCanvas.restore();
  }
  @Override
  public boolean onTouchEvent(MotionEvent me) {
    synchronized (mThread.getSurfaceHolder()) {
      if (!mIsScratchable) {
        return true;
      }

      switch (me.getAction()) {
        case MotionEvent.ACTION_DOWN:
          path = new Path();
          path.moveTo(me.getX(), me.getY());
          startX = me.getX();
          startY = me.getY();
          mPathList.add(path);
          break;
        case MotionEvent.ACTION_MOVE:
          if (mScratchStart) {
            path.lineTo(me.getX(), me.getY());
          } else {
            if (isScratch(startX, me.getX(), startY, me.getY())) {
              mScratchStart = true;
              path.lineTo(me.getX(), me.getY());
            }
          }
          break;
        case MotionEvent.ACTION_UP:
          mScratchStart = false;
          break;
      }
      return true;
    }
  }
Пример #3
0
  /**
   * 绘制图网络线
   *
   * @param canvas 画布
   * @param lineData 数据集类
   * @param arrayDataX x坐标
   * @param arrayDataY y坐标
   */
  private void drawDataPath(
      Canvas canvas, RadarData lineData, Float[] arrayDataX, Float[] arrayDataY) {
    float startX = 0.0f, startY = 0.0f;
    float initX = 0.0f, initY = 0.0f;

    Path pathArea = new Path();

    for (int p = 0; p < arrayDataX.length; p++) {
      if (0 == p) {
        initX = startX = arrayDataX[p];
        initY = startY = arrayDataY[p];

        pathArea.moveTo(initX, initY);
      } else {
        pathArea.lineTo(arrayDataX[p], arrayDataY[p]);
        startX = arrayDataX[p];
        startY = arrayDataY[p];
      }
      // 绘制点及对应的标签
      renderDotAndLabel(canvas, lineData, arrayDataX[p], arrayDataY[p], p);
    }
    // 收尾
    pathArea.lineTo(initX, initY);
    pathArea.close();

    lineData.getPlotLine().getLinePaint().setAlpha(mAreaAlpha);
    // lineData.getPlotLine().getLinePaint().setStyle(Style.STROKE);
    canvas.drawPath(pathArea, lineData.getPlotLine().getLinePaint());
  }
Пример #4
0
  /**
   * Draws a needle that is centered at the top or bottom of the compass.
   *
   * @param canvas the {@link Canvas} upon which to draw.
   * @param bottom true to draw the bottom needle, or false to draw the top needle.
   */
  private void drawNeedle(Canvas canvas, boolean bottom) {
    float centerX = getWidth() / 2.0f;

    float origin;
    float sign;

    // Flip the vertical coordinates if we're drawing the bottom needle.
    if (bottom) {
      origin = getHeight();
      sign = -1;
    } else {
      origin = 0;
      sign = 1;
    }

    float needleHalfWidth = NEEDLE_WIDTH / 2;

    mPath.reset();
    mPath.moveTo(centerX - needleHalfWidth, origin);
    mPath.lineTo(centerX - needleHalfWidth, origin + sign * (NEEDLE_HEIGHT - 4));
    mPath.lineTo(centerX, origin + sign * NEEDLE_HEIGHT);
    mPath.lineTo(centerX + needleHalfWidth, origin + sign * (NEEDLE_HEIGHT - 4));
    mPath.lineTo(centerX + needleHalfWidth, origin);
    mPath.close();

    canvas.drawPath(mPath, mPaint);
  }
Пример #5
0
  @Override
  public Path draw() {
    int squareWidth = pathHeight / 4;
    int middleSquare = squareWidth / 2;

    Point[] squarePoints = new Point[4];
    initializePoints(squarePoints);
    squarePoints[0].set(center.x - middleSquare, center.y - middleSquare);
    squarePoints[1].set(center.x + middleSquare, squarePoints[0].y);
    squarePoints[2].set(squarePoints[1].x, center.y + middleSquare);
    squarePoints[3].set(squarePoints[0].x, squarePoints[2].y);

    Point[] starPoints = new Point[4];
    initializePoints(starPoints);
    starPoints[0].set(maxBallSize, center.y);
    starPoints[1].set(center.x, maxBallSize);
    starPoints[2].set(pathWidth - maxBallSize, center.y);
    starPoints[3].set(center.x, pathHeight - maxBallSize);

    Path starPath = new Path();

    starPath.moveTo(starPoints[0].x, starPoints[0].y);
    starPath.lineTo(squarePoints[0].x, squarePoints[0].y);

    for (int i = 1; i < 4; i++) {
      starPath.lineTo(starPoints[i].x, starPoints[i].y);
      starPath.lineTo(squarePoints[i].x, squarePoints[i].y);
    }

    starPath.close();

    return starPath;
  }
  private void drawSpring(Canvas canvas, int springDelta) {
    mPath.reset();
    mPath.moveTo(0, 0);
    mPath.lineTo(0, PULL_HEIGHT);
    mPath.quadTo(mWidth / 2, PULL_HEIGHT - springDelta, mWidth, PULL_HEIGHT);
    mPath.lineTo(mWidth, 0);
    canvas.drawPath(mPath, mBackPaint);

    int curH = PULL_HEIGHT - springDelta / 2;

    if (curH > PULL_HEIGHT - PULL_DELTA / 2) {
      int leftX = (int) (mWidth / 2 - 2 * mRadius + getSprRatio() * mRadius);
      mPath.reset();
      mPath.moveTo(leftX, curH);
      mPath.quadTo(mWidth / 2, curH - mRadius * getSprRatio() * 2, mWidth - leftX, curH);
      canvas.drawPath(mPath, mBallPaint);
    } else {
      canvas.drawArc(
          new RectF(mWidth / 2 - mRadius, curH - mRadius, mWidth / 2 + mRadius, curH + mRadius),
          180,
          180,
          true,
          mBallPaint);
    }
  }
Пример #7
0
  @Override
  protected void dispatchDraw(Canvas canvas) {
    super.dispatchDraw(canvas);
    if (mTabCount == 0) {
      return;
    }

    // under line
    Paint paint = new Paint();
    paint.setColor(mUnderLineColor);

    RectF rectF = new RectF(0, getHeight() - mUnderLineHeight, getWidth(), getHeight());
    canvas.drawRect(rectF, paint);

    // indicator line
    mPath.rewind();

    float leftX = mIndicatorMarginTab + mLineMarginX;
    float rightX = leftX + mTabWidth - 2 * mIndicatorMarginTab;

    mPath.moveTo(leftX, mIndicatorTopY);
    mPath.lineTo(rightX, mIndicatorTopY);
    mPath.lineTo(rightX, mIndicatorBottomY);
    mPath.lineTo(leftX, mIndicatorBottomY);
    mPath.close();

    canvas.drawPath(mPath, mPaintLine);
  }
Пример #8
0
  /**
   * 描述:TODO.
   *
   * @param canvas the canvas
   * @param points the points
   * @param paint the paint
   * @param circular the circular
   * @see com.ab.view.chart.AbstractChart#drawPath(android.graphics.Canvas, float[],
   *     android.graphics.Paint, boolean)
   */
  @Override
  protected void drawPath(Canvas canvas, float[] points, Paint paint, boolean circular) {
    Path p = new Path();
    float x = points[0];
    float y = points[1];
    p.moveTo(x, y);

    int length = points.length;
    if (circular) {
      length -= 4;
    }

    for (int i = 0; i < length; i += 2) {
      int nextIndex = i + 2 < length ? i + 2 : i;
      int nextNextIndex = i + 4 < length ? i + 4 : nextIndex;
      calc(points, p1, i, nextIndex, secondMultiplier);
      p2.setX(points[nextIndex]);
      p2.setY(points[nextIndex + 1]);
      calc(points, p3, nextIndex, nextNextIndex, firstMultiplier);
      // From last point, approaching x1/y1 and x2/y2 and ends up at x3/y3
      p.cubicTo(p1.getX(), p1.getY(), p2.getX(), p2.getY(), p3.getX(), p3.getY());
    }
    if (circular) {
      for (int i = length; i < length + 4; i += 2) {
        p.lineTo(points[i], points[i + 1]);
      }
      p.lineTo(points[0], points[1]);
    }
    canvas.drawPath(p, paint);
  }
Пример #9
0
  @SuppressWarnings("NewApi")
  public Path computePath(int radius, int l, int t, int r, int b) {
    final Point o = computeOrigin(l, t, r, b);
    final int ol = o.x - radius;
    final int ot = o.y - radius;
    final int or = o.x + radius;
    final int ob = o.y + radius;

    Path path = new Path();
    path.moveTo(o.x, o.y);
    switch (startAngle) {
      case 0:
        path.lineTo(or, o.y);
        break;
      case 90:
        path.lineTo(o.x, ob);
        break;
      case 180:
        path.lineTo(ol, o.y);
        break;
      case 270:
        path.lineTo(o.x, ot);
        break;
      default:
        throw new UnsupportedOperationException();
    }
    if (Utils.LOLLIPOP_OR_LATER) {
      path.arcTo(ol, ot, or, ob, startAngle, sweepAngle, true);
    } else {
      path.arcTo(new RectF(ol, ot, or, ob), startAngle, sweepAngle, true);
    }
    path.lineTo(o.x, o.y);
    return path;
  }
Пример #10
0
    public void onDraw(Canvas canvas) {
      // 검정색 배경으로 지운다. 빈 화면이면 지우기만 하고 리턴
      canvas.drawColor(Color.BLACK);
      if (status == BLANK) {
        return;
      }

      // 도형 목록을 순회하면서 도형 정보대로 출력한다.
      int idx;
      for (idx = 0; idx < arShape.size(); idx++) {
        Paint Pnt = new Paint();
        Pnt.setAntiAlias(true);
        Pnt.setColor(arShape.get(idx).color);

        Rect rt = arShape.get(idx).rt;
        switch (arShape.get(idx).what) {
          case Shape.RECT:
            canvas.drawRect(rt, Pnt);
            break;
          case Shape.CIRCLE:
            canvas.drawCircle(
                rt.left + rt.width() / 2, rt.top + rt.height() / 2, rt.width() / 2, Pnt);
            break;
          case Shape.TRIANGLE:
            Path path = new Path();
            path.moveTo(rt.left + rt.width() / 2, rt.top);
            path.lineTo(rt.left, rt.bottom);
            path.lineTo(rt.right, rt.bottom);
            canvas.drawPath(path, Pnt);
            break;
        }
      }
    }
Пример #11
0
  private void updatePath() {
    float radius = getWidth() / 20;
    float arrowHeight = getHeight() / 4;

    Rect rect = new Rect(2, 2, this.getWidth() - 4, this.getHeight() - 4);

    mPath = new Path();
    mPath.moveTo(rect.left + radius, rect.top);
    mPath.lineTo(rect.right, rect.top);
    mPath.lineTo(rect.right, rect.bottom - arrowHeight);
    mPath.lineTo(rect.exactCenterX(), rect.bottom);
    mPath.lineTo(rect.left, rect.bottom - arrowHeight);
    mPath.lineTo(rect.left, rect.top);
    mPath.close();

    int color = this.getContext().getResources().getColor(R.color.tag_unselected_outline);
    if (mIsActive) color = this.getContext().getResources().getColor(R.color.tag_selected_outline);

    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setColor(color);
    mPaint.setStyle(Paint.Style.FILL);
    mPaint.setStrokeWidth(0);
    mPaint.setStrokeJoin(Paint.Join.ROUND); // set the join to round you
    // want
    mPaint.setStrokeCap(Paint.Cap.ROUND); // set the paint cap to round too
    mPaint.setPathEffect(new CornerPathEffect(radius)); // set the path
    // effect when they

    color = this.getContext().getResources().getColor(R.color.tag_unselected);
    if (mIsActive) color = this.getContext().getResources().getColor(R.color.tag_selected);
    mShader = new LinearGradient(0, 0, 0, getHeight(), color, color, Shader.TileMode.CLAMP);
  }
Пример #12
0
  /**
   * The graphical representation of a path.
   *
   * @param canvas the canvas to paint to
   * @param points the points that are contained in the path to paint
   * @param paint the paint to be used for painting
   * @param circular if the path ends with the start point
   */
  protected void drawPath(Canvas canvas, float[] points, Paint paint, boolean circular) {
    Path path = new Path();
    int height = canvas.getHeight();
    int width = canvas.getWidth();

    float[] tempDrawPoints;
    if (points.length < 4) {
      return;
    }
    tempDrawPoints = calculateDrawPoints(points[0], points[1], points[2], points[3], height, width);
    path.moveTo(tempDrawPoints[0], tempDrawPoints[1]);
    path.lineTo(tempDrawPoints[2], tempDrawPoints[3]);

    for (int i = 4; i < points.length; i += 2) {
      if ((points[i - 1] < 0 && points[i + 1] < 0)
          || (points[i - 1] > height && points[i + 1] > height)) {
        continue;
      }
      tempDrawPoints =
          calculateDrawPoints(
              points[i - 2], points[i - 1], points[i], points[i + 1], height, width);
      if (!circular) {
        path.moveTo(tempDrawPoints[0], tempDrawPoints[1]);
      }
      path.lineTo(tempDrawPoints[2], tempDrawPoints[3]);
    }
    if (circular) {
      path.lineTo(points[0], points[1]);
    }
    canvas.drawPath(path, paint);
  }
  @Override
  protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    super.onSizeChanged(w, h, oldw, oldh);

    centerX = w / 2;
    centerY = h / 2;

    // Make reference line long enough to cross the bounds diagonally after being rotated.
    referenceLine.reset();
    float radius = (float) Math.hypot(centerX, centerY);
    float delta = radius - centerX;
    referenceLine.moveTo(-delta, centerY);
    referenceLine.lineTo(getWidth() + delta, centerY);
    delta = radius - centerY;
    referenceLine.moveTo(centerX, -delta);
    referenceLine.lineTo(centerX, getHeight() + delta);

    // Set grids inside photo display bounds.
    grids.reset();
    delta = displayBounds.width() / 4.0f;
    for (float x = displayBounds.left + delta; x < displayBounds.right; x += delta) {
      grids.moveTo(x, displayBounds.top);
      grids.lineTo(x, displayBounds.bottom);
    }
    delta = displayBounds.height() / 4.0f;
    for (float y = displayBounds.top + delta; y < displayBounds.bottom; y += delta) {
      grids.moveTo(displayBounds.left, y);
      grids.lineTo(displayBounds.right, y);
    }
  }
Пример #14
0
    private void drawTriangle(Canvas c, float startAngle, float sweepAngle, Rect bounds) {
      if (mShowArrow) {
        if (mArrow == null) {
          mArrow = new Path();
          mArrow.setFillType(Path.FillType.EVEN_ODD);
        } else {
          mArrow.reset();
        }

        // Adjust the position of the triangle so that it is inset as
        // much as the arc, but also centered on the arc.
        float inset = (int) mStrokeInset / 2 * mArrowScale;
        float x = (float) (mRingCenterRadius * Math.cos(0) + bounds.exactCenterX());
        float y = (float) (mRingCenterRadius * Math.sin(0) + bounds.exactCenterY());

        // Update the path each time. This works around an issue in SKIA
        // where concatenating a rotation matrix to a scale matrix
        // ignored a starting negative rotation. This appears to have
        // been fixed as of API 21.
        mArrow.moveTo(0, 0);
        mArrow.lineTo(mArrowWidth * mArrowScale, 0);
        mArrow.lineTo((mArrowWidth * mArrowScale / 2), (mArrowHeight * mArrowScale));
        mArrow.offset(x - inset, y);
        mArrow.close();
        // draw a triangle
        mArrowPaint.setColor(mColors[mColorIndex]);
        c.rotate(
            startAngle + sweepAngle - ARROW_OFFSET_ANGLE,
            bounds.exactCenterX(),
            bounds.exactCenterY());
        c.drawPath(mArrow, mArrowPaint);
      }
    }
  @Override
  protected void drawCallout(Canvas canvas, NMapView mapView, boolean shadow, long when) {

    adjustTextBounds(mapView);

    stepAnimations(canvas, mapView, when);

    // Draw inner info window
    canvas.drawRoundRect(mTempRectF, CALLOUT_ROUND_RADIUS_X, CALLOUT_ROUND_RADIUS_Y, mInnerPaint);

    // Draw border for info window
    canvas.drawRoundRect(mTempRectF, CALLOUT_ROUND_RADIUS_X, CALLOUT_ROUND_RADIUS_Y, mBorderPaint);

    // Draw bottom tag
    if (CALLOUT_TAG_WIDTH > 0 && CALLOUT_TAG_HEIGHT > 0) {
      float x = mTempRectF.centerX();
      float y = mTempRectF.bottom;

      Path path = mPath;
      path.reset();

      path.moveTo(x - CALLOUT_TAG_WIDTH, y);
      path.lineTo(x, y + CALLOUT_TAG_HEIGHT);
      path.lineTo(x + CALLOUT_TAG_WIDTH, y);
      path.close();

      canvas.drawPath(path, mInnerPaint);
      canvas.drawPath(path, mBorderPaint);
    }

    //  Draw title
    canvas.drawText(mOverlayItem.getTitle(), mOffsetX, mOffsetY, mTextPaint);
  }
Пример #16
0
  private void drawBG(Canvas canvas) {
    Path path = new Path();
    int currentPointY = 0;
    switch (mStatus) {
      case NONE:
        currentPointY = mMaxArcHeight;
        break;
      case STATUS_SMOOTH_UP:
      case STATUS_UP:
        currentPointY =
            getHeight()
                - (int)
                    ((getHeight() - mMaxArcHeight)
                        * Math.min(
                            1, (mArcHeight - mMaxArcHeight / 4) * 2.0 / mMaxArcHeight * 1.3));
        break;
      case STATUS_DOWN:
        currentPointY = mMaxArcHeight;
        break;
    }

    path.moveTo(0, currentPointY);
    path.quadTo(getWidth() / 2, currentPointY - mArcHeight, getWidth(), currentPointY);
    path.lineTo(getWidth(), getHeight());
    path.lineTo(0, getHeight());
    path.lineTo(0, currentPointY);
    canvas.drawPath(path, mPaint);
  }
Пример #17
0
  @Override
  public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);

    int width = getMeasuredWidth();
    int height = getMeasuredHeight();
    int curve = (int) (height * 1.125f);

    mPath.reset();

    if (mSide == CurveTowards.LEFT) {
      mPath.moveTo(0, height);
      mPath.cubicTo(curve * 0.75f, height, curve * 0.25f, 0, curve, 0);
      mPath.lineTo(0, 0);
      mPath.lineTo(0, height);
    } else if (mSide == CurveTowards.RIGHT) {
      mPath.moveTo(width, height);
      mPath.cubicTo(
          (width - (curve * 0.75f)), height,
          (width - (curve * 0.25f)), 0,
          (width - curve), 0);
      mPath.lineTo(width, 0);
      mPath.lineTo(width, height);
    }
  }
Пример #18
0
  private void drawPointerArrow(Canvas canvas) {

    int centerX = getWidth() / 2;
    int centerY = getHeight() / 2;

    double tipAngle = (colorHSV[2] - 0.5f) * Math.PI;
    double leftAngle = tipAngle + Math.PI / 96;
    double rightAngle = tipAngle - Math.PI / 96;

    double tipAngleX = Math.cos(tipAngle) * outerWheelRadius;
    double tipAngleY = Math.sin(tipAngle) * outerWheelRadius;
    double leftAngleX = Math.cos(leftAngle) * (outerWheelRadius + arrowPointerSize);
    double leftAngleY = Math.sin(leftAngle) * (outerWheelRadius + arrowPointerSize);
    double rightAngleX = Math.cos(rightAngle) * (outerWheelRadius + arrowPointerSize);
    double rightAngleY = Math.sin(rightAngle) * (outerWheelRadius + arrowPointerSize);

    arrowPointerPath.reset();
    arrowPointerPath.moveTo((float) tipAngleX + centerX, (float) tipAngleY + centerY);
    arrowPointerPath.lineTo((float) leftAngleX + centerX, (float) leftAngleY + centerY);
    arrowPointerPath.lineTo((float) rightAngleX + centerX, (float) rightAngleY + centerY);
    arrowPointerPath.lineTo((float) tipAngleX + centerX, (float) tipAngleY + centerY);

    valuePointerArrowPaint.setColor(Color.HSVToColor(colorHSV));
    valuePointerArrowPaint.setStyle(Style.FILL);
    canvas.drawPath(arrowPointerPath, valuePointerArrowPaint);

    valuePointerArrowPaint.setStyle(Style.STROKE);
    valuePointerArrowPaint.setStrokeJoin(Join.ROUND);
    valuePointerArrowPaint.setColor(Color.BLACK);
    canvas.drawPath(arrowPointerPath, valuePointerArrowPaint);
  }
Пример #19
0
 private static Path createLightPath(int width, int height) {
   final Path path = new Path();
   path.moveTo(0, height);
   path.lineTo(0, 0);
   path.lineTo(width, 0);
   return path;
 }
Пример #20
0
  @Override
  public void draw(Canvas canvas) {
    canvas.drawRoundRect(mRectF, mRadius, mRadius, mBorderPaint);

    Path path = new Path();
    path.moveTo(mRectF.right - 2 * mOffsetY - mOffsetX, mRectF.bottom);
    path.lineTo(mRectF.right - (2 * mOffsetY + mRadius) / 2 - mOffsetX, mRectF.bottom + mOffsetY);
    path.lineTo(mRectF.right - mRadius - mOffsetX, mRectF.bottom);

    float x = 0;
    float y = mRectF.centerY();

    String text = "One Piece";
    float[] characterWidths = new float[text.length()];
    int characterNum = mTextPaint.getTextWidths(text, characterWidths);

    float textWidth = 0f;
    for (int i = 0; i < characterNum; i++) {
      textWidth += characterWidths[i];
    }
    canvas.save();
    canvas.translate(mRectF.width() / 2 - textWidth / 2, 0);
    canvas.drawText("one piece", x, y, mTextPaint);

    canvas.restore();
    canvas.drawPath(path, mBorderPaint);
  }
Пример #21
0
  static void drawYajirusi(Canvas c, int cc, Vec2 xxx, Vec2 vvx) {
    Paint pp = new Paint();
    pp.setColor(cc);

    Path p = new Path();

    float rr = vvx.Norm();
    float width = rr * 0.05f;

    Vec2 xx = vvx.Prod(width / rr);
    xx.Rot1();

    Vec2 soko1 = xxx.Diff(xx);
    Vec2 soko2 = xxx.Sum(xx);
    Vec2 noki3 = soko2.Sum(vvx.Prod(0.8f));
    Vec2 noki2 = soko1.Sum(vvx.Prod(0.8f));
    Vec2 noki1 = noki2.Diff(xx);
    Vec2 noki4 = noki3.Sum(xx);
    Vec2 teppen = xxx.Sum(vvx);

    p.moveTo(soko1.X(), soko1.Y());
    p.lineTo(soko2.X(), soko2.Y());
    p.lineTo(noki3.X(), noki3.Y());
    p.lineTo(noki4.X(), noki4.Y());
    p.lineTo(teppen.X(), teppen.Y());
    p.lineTo(noki1.X(), noki1.Y());
    p.lineTo(noki2.X(), noki2.Y());
    p.lineTo(soko1.X(), soko1.Y());

    c.drawPath(p, pp);
  }
Пример #22
0
  @Override
  protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    mPath.moveTo(-1 / 4F * vWidth, waveY);

    mPath.quadTo(ctrX, ctrY, vWidth + 1 / 4f, waveY);

    mPath.lineTo(vWidth + 1 / 4f, vHeight);
    mPath.lineTo(-1 / 4F * vWidth, vHeight);
    mPath.close();

    canvas.drawPath(mPath, mPaint);

    if (ctrX >= vWidth + 0.25f * vWidth) {
      isInc = false;
    } else if (ctrX <= -0.25f * vWidth) {
      isInc = true;
    }

    ctrX = isInc ? ctrX + 20 : ctrX - 20;

    if (ctrY <= vHeight) {
      ctrY += 2;
      waveY += 2;
    }

    mPath.reset();

    invalidate();
  }
Пример #23
0
  private void getTrackPath(float x, float y, float radius) {
    float halfStroke = mTrackSize / 2f;

    mTrackPath.reset();

    if (mTrackCap != Paint.Cap.ROUND) {
      mTempRect.set(x - radius + 1f, y - radius + 1f, x + radius - 1f, y + radius - 1f);
      float angle = (float) (Math.asin(halfStroke / (radius - 1f)) / Math.PI * 180);

      if (x - radius > mDrawRect.left) {
        mTrackPath.moveTo(mDrawRect.left, y - halfStroke);
        mTrackPath.arcTo(mTempRect, 180 + angle, -angle * 2);
        mTrackPath.lineTo(mDrawRect.left, y + halfStroke);
        mTrackPath.close();
      }

      if (x + radius < mDrawRect.right) {
        mTrackPath.moveTo(mDrawRect.right, y - halfStroke);
        mTrackPath.arcTo(mTempRect, -angle, angle * 2);
        mTrackPath.lineTo(mDrawRect.right, y + halfStroke);
        mTrackPath.close();
      }
    } else {
      float angle = (float) (Math.asin(halfStroke / (radius - 1f)) / Math.PI * 180);

      if (x - radius > mDrawRect.left) {
        float angle2 =
            (float)
                (Math.acos(Math.max(0f, (mDrawRect.left + halfStroke - x + radius) / halfStroke))
                    / Math.PI
                    * 180);

        mTempRect.set(mDrawRect.left, y - halfStroke, mDrawRect.left + mTrackSize, y + halfStroke);
        mTrackPath.arcTo(mTempRect, 180 - angle2, angle2 * 2);

        mTempRect.set(x - radius + 1f, y - radius + 1f, x + radius - 1f, y + radius - 1f);
        mTrackPath.arcTo(mTempRect, 180 + angle, -angle * 2);
        mTrackPath.close();
      }

      if (x + radius < mDrawRect.right) {
        float angle2 =
            (float)
                Math.acos(Math.max(0f, (x + radius - mDrawRect.right + halfStroke) / halfStroke));
        mTrackPath.moveTo(
            (float) (mDrawRect.right - halfStroke + Math.cos(angle2) * halfStroke),
            (float) (y + Math.sin(angle2) * halfStroke));

        angle2 = (float) (angle2 / Math.PI * 180);
        mTempRect.set(
            mDrawRect.right - mTrackSize, y - halfStroke, mDrawRect.right, y + halfStroke);
        mTrackPath.arcTo(mTempRect, angle2, -angle2 * 2);

        mTempRect.set(x - radius + 1f, y - radius + 1f, x + radius - 1f, y + radius - 1f);
        mTrackPath.arcTo(mTempRect, -angle, angle * 2);
        mTrackPath.close();
      }
    }
  }
  /**
   * draw lines
   *
   * <p>ラインを書く
   *
   * <p>绘制线条
   *
   * @param canvas
   */
  protected void drawAreas(Canvas canvas) {
    // distance between two points
    float lineLength = ((super.getWidth() - super.getAxisMarginLeft()) / displayNumber) - 1;
    // start point‘s X
    float startX;
    float lastY = 0;
    float lastX = 0;

    LineEntity<DateValueEntity> line1 = (LineEntity<DateValueEntity>) bandData.get(0);
    LineEntity<DateValueEntity> line2 = (LineEntity<DateValueEntity>) bandData.get(1);

    if (line1.isDisplay() && line2.isDisplay()) {
      Paint mPaint = new Paint();
      mPaint.setColor(line1.getLineColor());
      mPaint.setAlpha(70);
      mPaint.setAntiAlias(true);
      List<DateValueEntity> line1Data = line1.getLineData();
      List<DateValueEntity> line2Data = line2.getLineData();
      // set start point’s X
      startX = super.getAxisMarginLeft() + lineLength / 2f;
      Path areaPath = new Path();
      if (line1Data != null && line2Data != null) {
        for (int j = displayFrom; j < displayFrom + displayNumber; j++) {
          float value1 = line1Data.get(j).getValue();
          float value2 = line2Data.get(j).getValue();

          // calculate Y
          float valueY1 =
              (float)
                  ((1f - (value1 - this.getMinValue()) / (this.getMaxValue() - this.getMinValue()))
                      * (super.getHeight() - super.getAxisMarginBottom()));
          float valueY2 =
              (float)
                  ((1f - (value2 - this.getMinValue()) / (this.getMaxValue() - this.getMinValue()))
                      * (super.getHeight() - super.getAxisMarginBottom()));

          // 绘制线条路径
          if (j == displayFrom) {
            areaPath.moveTo(startX, valueY1);
            areaPath.lineTo(startX, valueY2);
            areaPath.moveTo(startX, valueY1);
          } else {
            areaPath.lineTo(startX, valueY1);
            areaPath.lineTo(startX, valueY2);
            areaPath.lineTo(lastX, lastY);

            areaPath.close();
            areaPath.moveTo(startX, valueY1);
          }

          lastX = startX;
          lastY = valueY2;
          startX = startX + 1 + lineLength;
        }
        areaPath.close();
        canvas.drawPath(areaPath, mPaint);
      }
    }
  }
Пример #25
0
  private void drawPolygon(
      BinaryMapDataObject obj,
      RenderingRuleSearchRequest render,
      Canvas canvas,
      RenderingContext rc,
      TagValuePair pair) {
    if (render == null || pair == null) {
      return;
    }
    float xText = 0;
    float yText = 0;
    int zoom = rc.zoom;
    Path path = null;

    // rc.main.color = Color.rgb(245, 245, 245);
    render.setInitialTagValueZoom(pair.tag, pair.value, zoom, obj);
    boolean rendered = render.search(RenderingRulesStorage.POLYGON_RULES);
    if (!rendered || !updatePaint(render, paint, 0, true, rc)) {
      return;
    }
    rc.visible++;
    int len = obj.getPointsLength();
    for (int i = 0; i < obj.getPointsLength(); i++) {

      PointF p = calcPoint(obj, i, rc);
      xText += p.x;
      yText += p.y;
      if (path == null) {
        path = new Path();
        path.moveTo(p.x, p.y);
      } else {
        path.lineTo(p.x, p.y);
      }
    }
    int[][] polygonInnerCoordinates = obj.getPolygonInnerCoordinates();
    if (polygonInnerCoordinates != null && path != null) {
      path.setFillType(FillType.EVEN_ODD);
      for (int j = 0; j < polygonInnerCoordinates.length; j++) {
        for (int i = 0; i < polygonInnerCoordinates[j].length; i += 2) {
          PointF p =
              calcPoint(polygonInnerCoordinates[j][i], polygonInnerCoordinates[j][i + 1], rc);
          if (i == 0) {
            path.moveTo(p.x, p.y);
          } else {
            path.lineTo(p.x, p.y);
          }
        }
      }
    }

    if (path != null && len > 0) {
      canvas.drawPath(path, paint);
      if (updatePaint(render, paint, 1, false, rc)) {
        canvas.drawPath(path, paint);
      }
      textRenderer.renderText(obj, render, rc, pair, xText / len, yText / len, null, null);
    }
  }
    private void drawCircle(Canvas canvas, BatteryTracker tracker, float textX, RectF drawRect) {
      boolean unknownStatus = tracker.status == BatteryManager.BATTERY_STATUS_UNKNOWN;
      int animOffset = tracker.shouldIndicateCharging() ? mAnimOffset : 0;
      int level = tracker.level;
      Paint paint;

      if (unknownStatus) {
        paint = mBackPaint;
        level = 100; // Draw all the circle;
      } else {
        paint = mFrontPaint;
        paint.setColor(getColorForLevel(level));
        if (tracker.status == BatteryManager.BATTERY_STATUS_FULL) {
          level = 100;
        }
      }

      // draw thin gray ring first
      canvas.drawArc(drawRect, 270, 360, false, mBackPaint);
      // draw colored arc representing charge level
      canvas.drawArc(drawRect, 270 + animOffset, 3.6f * level, false, paint);
      // if chosen by options, draw percentage text in the middle
      // always skip percentage when 100, so layout doesnt break
      if (unknownStatus) {
        mTextPaint.setColor(paint.getColor());
        canvas.drawText("?", textX, mTextY, mTextPaint);

      } else if (tracker.shouldIndicateCharging() && (!mShowPercent || level == 100)) {
        // draw the bolt
        final float bl = (int) (drawRect.left + drawRect.width() / 3.2f);
        final float bt = (int) (drawRect.top + drawRect.height() / 4f);
        final float br = (int) (drawRect.right - drawRect.width() / 5.2f);
        final float bb = (int) (drawRect.bottom - drawRect.height() / 8f);
        if (mBoltFrame.left != bl
            || mBoltFrame.top != bt
            || mBoltFrame.right != br
            || mBoltFrame.bottom != bb) {
          mBoltFrame.set(bl, bt, br, bb);
          mBoltPath.reset();
          mBoltPath.moveTo(
              mBoltFrame.left + mBoltPoints[0] * mBoltFrame.width(),
              mBoltFrame.top + mBoltPoints[1] * mBoltFrame.height());
          for (int i = 2; i < mBoltPoints.length; i += 2) {
            mBoltPath.lineTo(
                mBoltFrame.left + mBoltPoints[i] * mBoltFrame.width(),
                mBoltFrame.top + mBoltPoints[i + 1] * mBoltFrame.height());
          }
          mBoltPath.lineTo(
              mBoltFrame.left + mBoltPoints[0] * mBoltFrame.width(),
              mBoltFrame.top + mBoltPoints[1] * mBoltFrame.height());
        }
        canvas.drawPath(mBoltPath, mBoltPaint);

      } else if (level < 100 && mShowPercent) {
        mTextPaint.setColor(paint.getColor());
        canvas.drawText(Integer.toString(level), textX, mTextY, mTextPaint);
      }
    }
 public static void play(
     Canvas paramCanvas, Paint paramPaint, int paramInt1, int paramInt2, int paramInt3) {
   Path localPath = new Path();
   localPath.moveTo(paramInt3, paramInt3);
   localPath.lineTo(paramInt1 - paramInt3, paramInt3 + (paramInt2 - paramInt3 * 2.0F) / 2.0F);
   localPath.lineTo(paramInt3, paramInt2 - paramInt3);
   localPath.lineTo(paramInt3, paramInt3);
   paramCanvas.drawPath(localPath, paramPaint);
 }
Пример #28
0
 protected final int h(int paramInt, Object... paramVarArgs) {
   switch (paramInt) {
   }
   for (; ; ) {
     return 0;
     return 46;
     return 46;
     Canvas localCanvas = (Canvas) paramVarArgs[0];
     paramVarArgs = (Looper) paramVarArgs[1];
     c.e(paramVarArgs);
     c.d(paramVarArgs);
     Object localObject = c.h(paramVarArgs);
     ((Paint) localObject).setFlags(385);
     ((Paint) localObject).setStyle(Paint.Style.FILL);
     Paint localPaint1 = c.h(paramVarArgs);
     localPaint1.setFlags(385);
     localPaint1.setStyle(Paint.Style.STROKE);
     ((Paint) localObject).setColor(-16777216);
     localPaint1.setStrokeWidth(1.0F);
     localPaint1.setStrokeCap(Paint.Cap.BUTT);
     localPaint1.setStrokeJoin(Paint.Join.MITER);
     localPaint1.setStrokeMiter(4.0F);
     localPaint1.setPathEffect(null);
     Paint localPaint2 = c.a(localPaint1, paramVarArgs);
     localPaint2.set(localPaint1);
     localPaint2.setStrokeWidth(1.0F);
     localCanvas.save();
     localPaint1 = c.a((Paint) localObject, paramVarArgs);
     localPaint1.set((Paint) localObject);
     localPaint1.setColor(-8744017);
     localObject = c.i(paramVarArgs);
     ((Path) localObject).moveTo(30.430653F, 34.178318F);
     ((Path) localObject).cubicTo(27.249908F, 36.57749F, 23.291077F, 38.0F, 19.0F, 38.0F);
     ((Path) localObject).cubicTo(8.50659F, 38.0F, 0.0F, 29.49341F, 0.0F, 19.0F);
     ((Path) localObject).cubicTo(0.0F, 8.50659F, 8.50659F, 0.0F, 19.0F, 0.0F);
     ((Path) localObject).cubicTo(29.49341F, 0.0F, 38.0F, 8.50659F, 38.0F, 19.0F);
     ((Path) localObject)
         .cubicTo(38.0F, 23.291077F, 36.57749F, 27.249908F, 34.178318F, 30.430653F);
     ((Path) localObject).lineTo(45.619164F, 41.8715F);
     ((Path) localObject).lineTo(41.8715F, 45.619164F);
     ((Path) localObject).lineTo(30.430653F, 34.178318F);
     ((Path) localObject).close();
     ((Path) localObject).moveTo(27.062714F, 30.44662F);
     ((Path) localObject).cubicTo(24.783264F, 32.055153F, 22.001972F, 33.0F, 19.0F, 33.0F);
     ((Path) localObject).cubicTo(11.268014F, 33.0F, 5.0F, 26.731987F, 5.0F, 19.0F);
     ((Path) localObject).cubicTo(5.0F, 11.268014F, 11.268014F, 5.0F, 19.0F, 5.0F);
     ((Path) localObject).cubicTo(26.731987F, 5.0F, 33.0F, 11.268014F, 33.0F, 19.0F);
     ((Path) localObject)
         .cubicTo(33.0F, 22.001972F, 32.055153F, 24.783264F, 30.44662F, 27.062714F);
     ((Path) localObject).lineTo(27.062714F, 30.44662F);
     ((Path) localObject).close();
     WeChatSVGRenderC2Java.setFillType((Path) localObject, 2);
     localCanvas.drawPath((Path) localObject, localPaint1);
     localCanvas.restore();
     c.g(paramVarArgs);
   }
 }
Пример #29
0
    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
      super.onSizeChanged(w, h, oldw, oldh);

      sizePath.reset();
      sizePath.moveTo(borderSize, borderSize);
      sizePath.lineTo(getWidth() - borderSize, getHeight() / 2);
      sizePath.lineTo(borderSize, getHeight() - borderSize);
    }
 @Override
 public Path draw() {
   Path path = new Path();
   path.moveTo(maxBallSize, pathHeight - maxBallSize);
   path.lineTo(center.x, maxBallSize);
   path.lineTo(pathWidth - maxBallSize, pathHeight - maxBallSize);
   path.lineTo(maxBallSize, pathHeight - maxBallSize);
   return path;
 }