Java Code Examples for android.graphics.Path#close()

private void initBottomSquarePath(RectF rect, Path path, float strokeWidth) {

        path.moveTo(rect.left + strokeWidth, rect.top + strokeWidth);
        path.lineTo(rect.right - strokeWidth, rect.top + strokeWidth);
        path.lineTo(rect.right - strokeWidth, rect.bottom - getArrowHeight() - strokeWidth);


        path.lineTo(rect.left + getArrowWidth() + getArrowPosition() - (strokeWidth / 2), rect.bottom - getArrowHeight() - strokeWidth);
        path.lineTo(rect.left + getArrowPosition() + getArrowWidth() / 2, rect.bottom - strokeWidth - strokeWidth);
        path.lineTo(rect.left + getArrowPosition() + (strokeWidth / 2), rect.bottom - getArrowHeight() - strokeWidth);
        path.lineTo(rect.left + getArrowPosition() + strokeWidth, rect.bottom - getArrowHeight() - strokeWidth);


        path.lineTo(rect.left + strokeWidth, rect.bottom - getArrowHeight() - strokeWidth);
        path.lineTo(rect.left + strokeWidth, rect.top + strokeWidth);
        path.close();
    }
 

private void drawCircleProgress(Canvas canvas) {

        int centerX = getWidth() / 2;
        int centerY = getHeight() / 2;
        canvas.drawCircle(centerX, centerY, mRadius, mBgPaint);
        if (strokeWidth > 0) {
            canvas.drawCircle(getWidth() / 2, getHeight() / 2, mRadius, mStrokePaint);
        }
        Path path = new Path();
        path.moveTo(centerX, centerY);
        path.lineTo(centerX, 0);
        RectF rectF = new RectF(0, 0, getRight(), getBottom());
        path.arcTo(rectF, 270, mProgress / mMaxProgress * 360);
        path.close();
        canvas.drawPath(path, mProgressPaint);
    }
 

@Override
public void handle(Canvas canvas) {
    Paint paint = new Paint();
    paint.setColor(Color.RED);
    paint.setStyle(Paint.Style.STROKE);
    paint.setStrokeWidth(8);

    //中间画布操作
    canvas.drawLine(startPoint.x, startPoint.y, endPoint.x, endPoint.y, paint);
    Path triangle = new Path();
    Point triangleP[] = getTrianPoint(startPoint.x, startPoint.y, endPoint.x, endPoint.y);
    triangle.moveTo(triangleP[0].x, triangleP[0].y);
    triangle.lineTo(triangleP[1].x, triangleP[1].y);
    triangle.lineTo(triangleP[2].x, triangleP[2].y);
    triangle.close();
    paint.setStyle(Paint.Style.FILL);
    canvas.drawPath(triangle, paint);
    paint.setStyle(Paint.Style.STROKE);
}
 

public RectF getPathRect() {
    List<Point> list = new ArrayList<>();
    for (int i = 0; i < count; i++) {
        int x, y;
        x = (int) (centerX + percents[i] * radius * Math.cos(angle * i + Math.PI / 2));
        y = (int) (centerY - percents[i] * radius * Math.sin(angle * i + Math.PI / 2));
        Point p = new Point();
        p.set(x, y);
        list.add(p);
    }

    Path path = new Path();
    for (int i = 0; i < list.size(); i++) {
        if (i == 0) {
            path.moveTo(list.get(i).x, list.get(i).y);
        } else {
            path.lineTo(list.get(i).x, list.get(i).y);
        }
    }
    path.close();
    RectF rect = new RectF();
    path.computeBounds(rect, true);
    return rect;
}
 

public void rightPath(RectF rect, Path path) {
    path.moveTo(mAngle, rect.top);
    path.lineTo(rect.width(), rect.top);
    path.arcTo(new RectF(rect.right - mAngle * 2 - mArrowWidth, rect.top,
            rect.right - mArrowWidth, mAngle * 2 + rect.top), 270, 90);
    path.lineTo(rect.right - mArrowWidth, mArrowTop);
    path.lineTo(rect.right, mArrowTop - mArrowOffset);
    path.lineTo(rect.right - mArrowWidth, mArrowTop + mArrowHeight);
    path.lineTo(rect.right - mArrowWidth, rect.height() - mAngle);
    path.arcTo(new RectF(rect.right - mAngle * 2 - mArrowWidth, rect.bottom
            - mAngle * 2, rect.right - mArrowWidth, rect.bottom), 0, 90);
    path.lineTo(rect.left, rect.bottom);
    path.arcTo(new RectF(rect.left, rect.bottom - mAngle * 2, mAngle * 2
            + rect.left, rect.bottom), 90, 90);
    path.lineTo(rect.left, rect.top);
    path.arcTo(new RectF(rect.left, rect.top, mAngle * 2 + rect.left,
            mAngle * 2 + rect.top), 180, 90);
    path.close();
}
 

public void rightPath(RectF rect, Path path) {
    path.moveTo(mAngle, rect.top);
    path.lineTo(rect.width(), rect.top);
    path.arcTo(
        new RectF(rect.right - mAngle * 2 - mArrowWidth, rect.top, rect.right - mArrowWidth,
            mAngle * 2 + rect.top), 270, 90);
    path.lineTo(rect.right - mArrowWidth, mArrowTop);
    path.lineTo(rect.right, mArrowTop - mArrowOffset);
    path.lineTo(rect.right - mArrowWidth, mArrowTop + mArrowHeight);
    path.lineTo(rect.right - mArrowWidth, rect.height() - mAngle);
    path.arcTo(new RectF(rect.right - mAngle * 2 - mArrowWidth, rect.bottom - mAngle * 2,
        rect.right - mArrowWidth, rect.bottom), 0, 90);
    path.lineTo(rect.left, rect.bottom);
    path.arcTo(
        new RectF(rect.left, rect.bottom - mAngle * 2, mAngle * 2 + rect.left, rect.bottom), 90,
        90);
    path.lineTo(rect.left, rect.top);
    path.arcTo(new RectF(rect.left, rect.top, mAngle * 2 + rect.left, mAngle * 2 + rect.top),
        180, 90);
    path.close();
}
 

/**
 * This requires the three points to be in a sequence that traces out a triangle in clockwise
 * fashion. This is required for the triangle to be filled correctly when drawing, otherwise
 * it will end up black.
 */
private static Path createTriangle(Point start, Point middle, Point end) {
    Path path = new Path();
    path.setFillType(Path.FillType.EVEN_ODD);
    path.moveTo(start.x, start.y);
    path.lineTo(middle.x, middle.y);
    path.lineTo(end.x, end.y);
    path.close();

    return path;
}
 

/**
 * 根据title创建tab
 */
private View generateTextView(String title, int index, int size) {
    TextView tv = new TextView(getContext());
    tv.setText(title);
    tv.setGravity(Gravity.CENTER);
    tv.setTextSize(TypedValue.COMPLEX_UNIT_SP, tabTextSize);
    LayoutParams lp;
    if (margin == 0) {
        lp = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
        lp.width = 0;
        lp.weight = 1;
    } else {
        lp = new LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.MATCH_PARENT);
        if (index != size) {
            lp.setMargins(0, 0, margin, 0);
        }
    }
    tv.setLayoutParams(lp);
    if (mLineWidth == 0) {
        Rect bound = new Rect();
        tv.getPaint().getTextBounds(tv.getText().toString(), 0, tv.getText().length(), bound);
        mLineWidth = bound.width();
        mLineWidth += 20;
        mPath = new Path();
        mPath.moveTo(0, 0);
        mPath.lineTo(mLineWidth, 0);
        mPath.lineTo(mLineWidth, lineHeight);
        mPath.lineTo(0, lineHeight);
        mPath.close();
    }
    return tv;
}
 

/**
 * 初始化三角形指示器
 */
private void initTriangle()
{
	mPath = new Path();

	mTriangleHeight = (int) (mTriangleWidth / 2 / Math.sqrt(2));
	mPath.moveTo(0, 0);
	mPath.lineTo(mTriangleWidth, 0);
	mPath.lineTo(mTriangleWidth / 2, -mTriangleHeight);
	mPath.close();
}
 

public void drawLabel(View view, Canvas canvas) {
    if (canvas == null || view == null) {
        throw new IllegalArgumentException("LabelViewHelper draw canvas or view cant't be null!");
    }

    canvas.save();
    if (mRouteDegrees == ROTATE_LEFT){
        canvas.translate(-mBgTriangleWidth / 2, 0);
        canvas.rotate(mRouteDegrees, mBgTriangleWidth / 2, 0);
    }else if (mRouteDegrees == ROTATE_RIGHT){
        int rotateViewWH= (int) (mBgTriangleHeight * Math.sqrt(2));
        canvas.translate(view.getMeasuredWidth() - rotateViewWH, -mBgTriangleHeight);
        canvas.rotate(mRouteDegrees, 0, mBgTriangleHeight);
    }

    Path path = new Path();
    path.moveTo(0, mBgTriangleHeight);
    if (mTopDistance < 0) {
        // mTopDistance > 0 represents a trapezoid, otherwise represents a triangle.
        mTopDistance = 0;
    }
    path.lineTo(mBgTriangleWidth / 2 - mTopDistance, mTopDistance);
    path.lineTo(mBgTriangleWidth / 2 + mTopDistance, mTopDistance);
    path.lineTo(mBgTriangleWidth, mBgTriangleHeight);
    path.close();
    canvas.drawPath(path, mBgTrianglePaint);

    if (!TextUtils.isEmpty(mTextTitle)) {
        canvas.drawText(mTextTitle, (mBgTriangleWidth) / 2, mTopDistance + mTopPadding + mTextTitleRect.height(), mTextTitlePaint);
    }
    if (!TextUtils.isEmpty(mTextContent)) {
        canvas.drawText(mTextContent, (mBgTriangleWidth) / 2, (mTopDistance + mTopPadding + mTextTitleRect.height() + mCenterPadding + mTextContentRect.height()), mTextContentPaint);
    }

    canvas.restore();
}
 

private Path getStarPath(float centerX, float centerY, float innerRadius, float outerRadius) {

        double angle = 2.0*Math.PI/10.0;
        float innerTopX = innerRadius*(float)Math.sin(angle);
        float innerTopY = innerRadius*(float)Math.cos(angle);
        float outerTopX = outerRadius*(float)Math.sin(2f*angle);
        float outerTopY = outerRadius*(float)Math.cos(2f*angle);
        float innerBottomX = innerRadius*(float)Math.sin(3f*angle);
        float innerBottomY = innerRadius*(float)Math.cos(3f*angle);
        float outerBottomX = outerRadius*(float)Math.sin(4f*angle);
        float outerBottomY = outerRadius*(float)Math.cos(4f*angle);

        Path result = new Path();
        result.moveTo(centerX, centerY - outerRadius);

        result.lineTo(centerX + innerTopX, centerY - innerTopY);
        result.lineTo(centerX + outerTopX, centerY - outerTopY);
        result.lineTo(centerX + innerBottomX, centerY - innerBottomY);
        result.lineTo(centerX + outerBottomX, centerY - outerBottomY);

        result.lineTo(centerX, centerY + innerRadius);

        result.lineTo(centerX - outerBottomX, centerY - outerBottomY);
        result.lineTo(centerX - innerBottomX, centerY - innerBottomY);
        result.lineTo(centerX - outerTopX, centerY - outerTopY);
        result.lineTo(centerX - innerTopX, centerY - innerTopY);

        result.close();
        return result;
    }
 

private void drawBottomLeft(Canvas canvas) {
    if ((radius[6] > 0) || (radius[7] > 0)) {
        int height = getHeight();
        Path path = new Path();
        path.moveTo(0, height - radius[7]);
        path.lineTo(0, height);
        path.lineTo(radius[6], height);
        path.arcTo(new RectF(0, height - 2 * radius[7],
                radius[6] * 2, height), 90, 90);
        path.close();
        canvas.drawPath(path, roundPaint);
    }
}
 

private void drawTriangleOnly(Canvas canvas) {
    Path p = new Path();
    p.moveTo((float) (radius - triangle_length / 2 * Math.sqrt(3) / 3), radius - triangle_length / 2);
    p.lineTo((float) (radius + triangle_length * Math.sqrt(3) / 3), radius);
    p.lineTo((float) (radius - triangle_length / 2 * Math.sqrt(3) / 3), radius + triangle_length / 2);
    p.close();
    canvas.drawPath(p, mTrianglePaint);
}
 

private void drawLiftDown(Canvas canvas) {
	Path path = new Path();
	path.moveTo(0, getHeight() - roundHeight);
	path.lineTo(0, getHeight());
	path.lineTo(roundWidth, getHeight());
	path.arcTo(new RectF(0, getHeight() - roundHeight * 2, 0 + roundWidth * 2, getHeight()), 90, 90);
	path.close();
	canvas.drawPath(path, paint);
}
 

private void init(Context context, AttributeSet attrs) {
    if (attrs != null) {
        final TypedArray attributes = context.obtainStyledAttributes(attrs, R.styleable.PolygonView);
        final int sides = attributes.getInteger(R.styleable.PolygonView_shape_polygon_noOfSides, numberOfSides);

        numberOfSides = sides > 3 ? sides : numberOfSides;
        attributes.recycle();
    }

    super.setClipPathCreator(new ClipPathManager.ClipPathCreator() {
        @Override
        public Path createClipPath(int width, int height) {

            final float section = (float) (2.0 * Math.PI / numberOfSides);
            final int polygonSize = Math.min(width, height);
            final int radius = polygonSize / 2;
            final int centerX = width / 2;
            final int centerY = height / 2;

            final Path polygonPath = new Path();
            polygonPath.moveTo((centerX + radius * (float) Math.cos(0)), (centerY + radius * (float) Math.sin(0)));

            for (int i = 1; i < numberOfSides; i++) {
                polygonPath.lineTo((centerX + radius * (float) Math.cos(section * i)),
                        (centerY + radius * (float) Math.sin(section * i)));
            }

            polygonPath.close();
            return polygonPath;
        }

        @Override
        public boolean requiresBitmap() {
            return true;
        }
    });
}
 

private Path makePathAndBoundingBox(SVG.Ellipse obj)
{
   float  cx = (obj.cx != null) ? obj.cx.floatValueX(this) : 0f;
   float  cy = (obj.cy != null) ? obj.cy.floatValueY(this) : 0f;
   float  rx = obj.rx.floatValueX(this);
   float  ry = obj.ry.floatValueY(this);

   float  left = cx - rx;
   float  top = cy - ry;
   float  right = cx + rx;
   float  bottom = cy + ry;

   if (obj.boundingBox == null) {
      obj.boundingBox = new Box(left, top, rx*2, ry*2);
   }

   float  cpx = rx * BEZIER_ARC_FACTOR;
   float  cpy = ry * BEZIER_ARC_FACTOR;

   Path  p = new Path();
   p.moveTo(cx, top);
   p.cubicTo(cx+cpx, top, right, cy-cpy, right, cy);
   p.cubicTo(right, cy+cpy, cx+cpx, bottom, cx, bottom);
   p.cubicTo(cx-cpx, bottom, left, cy+cpy, left, cy);
   p.cubicTo(left, cy-cpy, cx-cpx, top, cx, top);
   p.close();
   return p;
}
 

public void drawTextOnPath(
        String text,
        Path path,
        float hOffset,
        float vOffset,
        Paint paint)
{
    if (null == mMainCanvas) {
        return;
    }

    PathMeasure pm = new PathMeasure(path, false);
    Matrix matrix = new Matrix();
    Path charPath = new Path();
    Path textPath = new Path();

    float pathLength = pm.getLength();
    float coordinates[] = new float[2];
    float tangent[] = new float[2];

    int i = 0;
    float position = hOffset;

    while (i < text.length()) {
        String ch = text.substring(i, i + 1);
        float charWidth = paint.measureText(ch);

        float nextPosition = position + charWidth;
        if (nextPosition > pathLength) {
            break;
        }

        pm.getPosTan(position + charWidth / 2, coordinates, tangent);
        float rotateAngle = (float) Math.toDegrees(
                Math.atan2((double) tangent[1], (double) tangent[0]));

        charPath.reset();
        paint.getTextPath(ch, 0, ch.length(), -charWidth / 2, vOffset, charPath);
        charPath.close(); // workaround

        matrix.reset();
        matrix.postScale(1, -1, 0, 0);
        matrix.postRotate(rotateAngle, 0, 0);
        matrix.postTranslate(coordinates[0], coordinates[1]);

        textPath.addPath(charPath, matrix);

        ++i;
        position = nextPosition;
    }

    mMainCanvas.drawPath(textPath, paint);

    // for debug
    //mMainCanvas.drawTextOnPath(text, path, hOffset, vOffset, paint);
}
 

/**
 * Draws the RadarDataSet
 *
 * @param c
 * @param dataSet
 * @param mostEntries the entry count of the dataset with the most entries
 */
protected void drawDataSet(Canvas c, IRadarDataSet dataSet, int mostEntries) {

    float phaseX = mAnimator.getPhaseX();
    float phaseY = mAnimator.getPhaseY();

    float sliceangle = mChart.getSliceAngle();

    // calculate the factor that is needed for transforming the value to
    // pixels
    float factor = mChart.getFactor();

    MPPointF center = mChart.getCenterOffsets();
    MPPointF pOut = MPPointF.getInstance(0,0);
    Path surface = mDrawDataSetSurfacePathBuffer;
    surface.reset();

    boolean hasMovedToPoint = false;

    for (int j = 0; j < dataSet.getEntryCount(); j++) {

        mRenderPaint.setColor(dataSet.getColor(j));

        RadarEntry e = dataSet.getEntryForIndex(j);

        Utils.getPosition(
                center,
                (e.getY() - mChart.getYChartMin()) * factor * phaseY,
                sliceangle * j * phaseX + mChart.getRotationAngle(), pOut);

        if (Float.isNaN(pOut.x))
            continue;

        if (!hasMovedToPoint) {
            surface.moveTo(pOut.x, pOut.y);
            hasMovedToPoint = true;
        } else
            surface.lineTo(pOut.x, pOut.y);
    }

    if (dataSet.getEntryCount() > mostEntries) {
        // if this is not the largest set, draw a line to the center before closing
        surface.lineTo(center.x, center.y);
    }

    surface.close();

    if (dataSet.isDrawFilledEnabled()) {

        final Drawable drawable = dataSet.getFillDrawable();
        if (drawable != null) {

            drawFilledPath(c, surface, drawable);
        } else {

            drawFilledPath(c, surface, dataSet.getFillColor(), dataSet.getFillAlpha());
        }
    }

    mRenderPaint.setStrokeWidth(dataSet.getLineWidth());
    mRenderPaint.setStyle(Paint.Style.STROKE);

    // draw the line (only if filled is disabled or alpha is below 255)
    if (!dataSet.isDrawFilledEnabled() || dataSet.getFillAlpha() < 255)
        c.drawPath(surface, mRenderPaint);

    MPPointF.recycleInstance(center);
    MPPointF.recycleInstance(pOut);
}
 

private void init(Context context, AttributeSet attrs) {
    if (attrs != null) {
        final TypedArray attributes = context.obtainStyledAttributes(attrs, R.styleable.ArcView);
        arcHeightPx = attributes.getDimensionPixelSize(R.styleable.ArcView_shape_arc_height, (int) arcHeightPx);
        arcPosition = attributes.getInteger(R.styleable.ArcView_shape_arc_position, arcPosition);
        attributes.recycle();
    }
    super.setClipPathCreator(new ClipPathManager.ClipPathCreator() {
        @Override
        public Path createClipPath(int width, int height) {
            final Path path = new Path();

            final boolean isCropInside = getCropDirection() == CROP_INSIDE;

            final float arcHeightAbs = Math.abs(arcHeightPx);

            switch (arcPosition) {
                case POSITION_BOTTOM: {
                    if (isCropInside) {
                        path.moveTo(0, 0);
                        path.lineTo(0, height);
                        path.quadTo(width / 2, height - 2 * arcHeightAbs, width, height);
                        path.lineTo(width, 0);
                        path.close();
                    } else {
                        path.moveTo(0, 0);
                        path.lineTo(0, height - arcHeightAbs);
                        path.quadTo(width / 2, height + arcHeightAbs, width, height - arcHeightAbs);
                        path.lineTo(width, 0);
                        path.close();
                    }
                    break;
                }
                case POSITION_TOP:
                    if (isCropInside) {
                        path.moveTo(0, height);
                        path.lineTo(0, 0);
                        path.quadTo(width / 2, 2 * arcHeightAbs, width, 0);
                        path.lineTo(width, height);
                        path.close();
                    } else {
                        path.moveTo(0, arcHeightAbs);
                        path.quadTo(width / 2, -arcHeightAbs, width, arcHeightAbs);
                        path.lineTo(width, height);
                        path.lineTo(0, height);
                        path.close();
                    }
                    break;
                case POSITION_LEFT:
                    if (isCropInside) {
                        path.moveTo(width, 0);
                        path.lineTo(0, 0);
                        path.quadTo(arcHeightAbs * 2, height / 2, 0, height);
                        path.lineTo(width, height);
                        path.close();
                    } else {
                        path.moveTo(width, 0);
                        path.lineTo(arcHeightAbs, 0);
                        path.quadTo(-arcHeightAbs, height / 2, arcHeightAbs, height);
                        path.lineTo(width, height);
                        path.close();
                    }
                    break;
                case POSITION_RIGHT:
                    if (isCropInside) {
                        path.moveTo(0, 0);
                        path.lineTo(width, 0);
                        path.quadTo(width - arcHeightAbs * 2, height / 2, width, height);
                        path.lineTo(0, height);
                        path.close();
                    } else {
                        path.moveTo(0, 0);
                        path.lineTo(width - arcHeightAbs, 0);
                        path.quadTo(width + arcHeightAbs, height / 2, width - arcHeightAbs, height);
                        path.lineTo(0, height);
                        path.close();
                    }
                    break;

            }
            return path;
        }

        @Override
        public boolean requiresBitmap() {
            return false;
        }
    });
}
 

/**
 * Draws the limit lines if there are one.
 */
private void drawLimitLines() {

    ArrayList<LimitLine> limitLines = mOriginalData.getLimitLines();

    if (limitLines == null)
        return;

    float sliceangle = getSliceAngle();

    // calculate the factor that is needed for transforming the value to
    // pixels
    float factor = getFactor();

    PointF c = getCenterOffsets();

    for (int i = 0; i < limitLines.size(); i++) {

        LimitLine l = limitLines.get(i);

        mLimitLinePaint.setColor(l.getLineColor());
        mLimitLinePaint.setPathEffect(l.getDashPathEffect());
        mLimitLinePaint.setStrokeWidth(l.getLineWidth());

        float r = l.getLimit() * factor;

        Path limitPath = new Path();

        for (int j = 0; j < mCurrentData.getXValCount(); j++) {

            PointF p = getPosition(c, r, sliceangle * j + mRotationAngle);

            if (j == 0)
                limitPath.moveTo(p.x, p.y);
            else
                limitPath.lineTo(p.x, p.y);
        }

        limitPath.close();

        mDrawCanvas.drawPath(limitPath, mLimitLinePaint);
    }
}