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

/**
 * Draws all paths.
 */
private void drawPaths() {
  boolean[] hasMoved = new boolean[series.length];
  
  for (int i = 0; i < chartData.size(); i++) {
    double[] dataPoint = chartData.get(i);
    for (int j = 0; j < series.length; j++) {
      double value = dataPoint[j + 1];
      if (Double.isNaN(value)) {
        continue;
      }
      ChartValueSeries chartValueSeries = series[j];
      Path path = chartValueSeries.getPath();
      int x = getX(dataPoint[0]);
      int y = getY(chartValueSeries, value);
      if (!hasMoved[j]) {
        hasMoved[j] = true;
        path.moveTo(x, y);
      } else {
        path.lineTo(x, y);
      }
    }
  }
}
 

@Override
public void onDraw(Canvas canvas, Rect showRect, String tableName, TableConfig config) {
    Paint paint = config.getPaint();
    config.tableTitleStyle.fillPaint(paint);
    Rect rect = getRect();
    int startX = rect.centerX();
    Path path = new Path();
    switch (direction) {
        case TOP:
        case BOTTOM:
            DrawUtils.drawMultiText(canvas, paint, rect, tableName.split("\n"));
            break;
        case LEFT:
        case RIGHT:
            int textWidth = (int) paint.measureText(tableName);
            path.moveTo(startX, rect.top);
            path.lineTo(startX, rect.bottom);
            canvas.drawTextOnPath(tableName, path, textWidth / 2, 0, paint);
            break;
    }
}
 

protected void drawPath(Point[] points) {
    Path path = new Path();
    path.setFillType(Path.FillType.EVEN_ODD);
    int total = points.length;
    for (int i = 0; i < total; i++) {
        Point point = points[i];
        if (i == 0) {
            path.moveTo(point.x * _scale, point.y * _scale);
        } else {
            path.lineTo(point.x * _scale, point.y * _scale);
        }
    }
    path.close();

    _bitmapCanvas.drawPath(path, _bitmapPaint);
}
 

protected Path getPath(GeoLineString lineString) {
    List<GeoPoint> points = lineString.getPoints();
    Path path = new Path();
    float x0, y0;

    if (points.size() > 0) {
        x0 = (float) points.get(0).getX();
        y0 = (float) points.get(0).getY();
        path.moveTo(x0, y0);

        for (int i = 1; i < points.size(); i++) {
            x0 = (float) points.get(i).getX();
            y0 = (float) points.get(i).getY();

            path.lineTo(x0, y0);
        }
    }

    return path;
}
 

/**
 * Draws the zero line.
 */
protected void drawZeroLine(Canvas c) {

    int clipRestoreCount = c.save();
    mZeroLineClippingRect.set(mViewPortHandler.getContentRect());
    mZeroLineClippingRect.inset(0.f, -mYAxis.getZeroLineWidth());
    c.clipRect(mZeroLineClippingRect);

    // draw zero line
    MPPointD pos = mTrans.getPixelForValues(0f, 0f);

    mZeroLinePaint.setColor(mYAxis.getZeroLineColor());
    mZeroLinePaint.setStrokeWidth(mYAxis.getZeroLineWidth());

    Path zeroLinePath = mDrawZeroLinePath;
    zeroLinePath.reset();

    zeroLinePath.moveTo(mViewPortHandler.contentLeft(), (float) pos.y);
    zeroLinePath.lineTo(mViewPortHandler.contentRight(), (float) pos.y);

    // draw a path because lines don't support dashing on lower android versions
    c.drawPath(zeroLinePath, mZeroLinePaint);

    c.restoreToCount(clipRestoreCount);
}
 

@Override
protected Path createShapePath() {
    Path path = new Path();
    path.moveTo(shapeBox.left, shapeBox.bottom);
    path.lineTo(shapeBox.centerX(), shapeBox.top);
    path.lineTo(shapeBox.right, shapeBox.bottom);
    path.lineTo(shapeBox.left, shapeBox.bottom);
    return path;
}
 

/**
     * 绘制A区域右阴影
     *
     * @param canvas
     */
    private void drawPathARightShadow(Canvas canvas, Path pathA) {
        canvas.restore();
        canvas.save();

        float viewDiagonalLength = (float) Math.hypot(viewWidth, viewHeight);//view对角线长度
        int left = (int) h.x;
        int right = (int) (h.x + viewDiagonalLength * 10);//需要足够长的长度
        int top;
        int bottom;

        GradientDrawable gradientDrawable;
        if (style.equals(STYLE_TOP_RIGHT)) {
            gradientDrawable = drawableRightTopRight;
            top = (int) (h.y - rPathAShadowDis / 2);
            bottom = (int) h.y;
        } else {
            gradientDrawable = drawableRightLowerRight;
            top = (int) h.y;
            bottom = (int) (h.y + rPathAShadowDis / 2);
        }
        gradientDrawable.setBounds(left, top, right, bottom);

        Path mPath = new Path();
        mPath.moveTo(a.x - Math.max(rPathAShadowDis, lPathAShadowDis) / 2, a.y);
//        mPath.lineTo(i.x,i.y);
        mPath.lineTo(h.x, h.y);
        mPath.lineTo(a.x, a.y);
        mPath.close();
        canvas.clipPath(pathA);
        canvas.clipPath(mPath, Region.Op.INTERSECT);

        float mDegrees = (float) Math.toDegrees(Math.atan2(a.y - h.y, a.x - h.x));
        canvas.rotate(mDegrees, h.x, h.y);
        gradientDrawable.draw(canvas);
    }
 

/**
     * Draws the trapezoid background for the horizontal tabs on a canvas object using
     * the specified color.
     *
     * @param canvas the canvas to draw upon
     * @param color  the color to use to draw the tab
     */
    public static void drawTrapezoid(@NonNull Canvas canvas, int color, boolean withShader) {

        Paint paint = new Paint();
        paint.setColor(color);
        paint.setStyle(Paint.Style.FILL);
//        paint.setFilterBitmap(true);
        paint.setAntiAlias(true);
        paint.setDither(true);
        if (withShader) {
            paint.setShader(new LinearGradient(0, 0.9f * canvas.getHeight(),
                0, canvas.getHeight(),
                color, mixTwoColors(Color.BLACK, color, 0.5f),
                Shader.TileMode.CLAMP));
        } else {
            paint.setShader(null);
        }
        int width = canvas.getWidth();
        int height = canvas.getHeight();
        double radians = Math.PI / 3;
        int base = (int) (height / Math.tan(radians));

        Path wallpath = new Path();
        wallpath.reset();
        wallpath.moveTo(0, height);
        wallpath.lineTo(width, height);
        wallpath.lineTo(width - base, 0);
        wallpath.lineTo(base, 0);
        wallpath.close();

        canvas.drawPath(wallpath, paint);
    }
 

/**
 * Initializes the paths that are used by the ObjectAnimator to scale the view.
 */
private void initPaths() {
    // Path for 'in' animation: growing from 20% to 100%
    mPathIn = new Path();
    mPathIn.moveTo(0.2f, 0.2f);
    mPathIn.lineTo(1f, 1f);

    // Path for 'out' animation: shrinking from 100% to 20%
    mPathOut = new Path();
    mPathOut.moveTo(1f, 1f);
    mPathOut.lineTo(0.2f, 0.2f);
}
 

private void createShineArea() {
	int width = getWidth();
	int height = (int) (0.9 * getHeight());
	path = new Path();
	path.moveTo(0, 0);
	path.lineTo(width, 0);
	path.lineTo(width, height);
	path.close();
	paint.setShader(new LinearGradient(0, 0, 0, height, 0x55ffffff,
			0x10ffffff, Shader.TileMode.CLAMP));
}
 

private void initArrows(int w, int h) {
    mArrowBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
    mArrowBitmap.eraseColor(Color.TRANSPARENT);
    Canvas arrowCanvas = new Canvas(mArrowBitmap);
    mArrowRotator = new Matrix();

    int hw = w / 2;
    int hh = h / 2;

    int t1 = (int) (w * 0.35);
    int t2 = (int) (w * 0.05);

    Point d = new Point(hw - t2, hh);
    Point e = new Point(hw + t2, hh);
    Point f = new Point(hw, hh - t1);
    Point g = new Point(hw, hh + t1);

    Path path = new Path();
    path.setFillType(Path.FillType.EVEN_ODD);
    path.moveTo(d.x, d.y);
    path.lineTo(e.x, e.y);
    path.lineTo(f.x, f.y);
    path.close();

    Path path2 = new Path();
    path2.setFillType(Path.FillType.EVEN_ODD);
    path2.moveTo(d.x, d.y);
    path2.lineTo(e.x, e.y);
    path2.lineTo(g.x, g.y);
    path2.close();

    arrowCanvas.drawPath(path, mCirclePaint);
    arrowCanvas.drawPath(path2, mWhiteArrowPaint);
    arrowCanvas.save();
}
 

private void drawTriangle(Canvas canvas) {
    Path p = new Path();

    if (rotate_degree >= 0 && rotate_degree < 30) {
        first_pointX = radius - triangle_length * Math.abs(Math.cos(Math.PI / 3 + rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
        first_pointY = radius - triangle_length * Math.abs(Math.sin(Math.PI / 3 + rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
    } else if (rotate_degree >= 30 && rotate_degree <= 120) {
        first_pointX = radius + triangle_length * Math.abs(Math.cos(Math.PI / 3 + rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
        first_pointY = radius - triangle_length * Math.abs(Math.sin(Math.PI / 3 + rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
    }

    if (rotate_degree >= 0 && rotate_degree < 90) {
        second_pointX = radius + triangle_length * Math.abs(Math.cos(rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
        second_pointY = radius + triangle_length * Math.abs(Math.sin(rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
    } else if (rotate_degree > 90 && rotate_degree <= 120) {
        second_pointX = radius - triangle_length * Math.abs(Math.cos(rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
        second_pointY = radius + triangle_length * Math.abs(Math.sin(rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
    }

    if (rotate_degree >= 0 && rotate_degree < 60) {
        third_pointX = radius - triangle_length * Math.abs(Math.cos(Math.PI / 3 - rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
        third_pointY = radius + triangle_length * Math.abs(Math.sin(Math.PI / 3 - rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
    } else if (rotate_degree >= 60 && rotate_degree <= 120) {
        third_pointX = radius - triangle_length * Math.abs(Math.cos(Math.PI / 3 - rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
        third_pointY = radius - triangle_length * Math.abs(Math.sin(Math.PI / 3 - rotate_degree * Math.PI / 180) * Math.sqrt(3) / 3);
    }

    p.moveTo((float) first_pointX, (float) first_pointY);
    p.lineTo((float) second_pointX, (float) second_pointY);
    p.lineTo((float) third_pointX, (float) third_pointY);
    p.close();
    canvas.drawPath(p, mTrianglePaint);
    redrawTriangle();
}
 

/**
 * Generates the path that is used for filled drawing.
 *
 * @param dataSet
 * @return
 */
private Path generateFilledPath(ILineDataSet dataSet, int from, int to) {

    float fillMin = dataSet.getFillFormatter().getFillLinePosition(dataSet, mChart);
    float phaseX = mAnimator.getPhaseX();
    float phaseY = mAnimator.getPhaseY();

    Path filled = new Path();
    Entry entry = dataSet.getEntryForIndex(from);

    filled.moveTo(entry.getXIndex(), fillMin);
    filled.lineTo(entry.getXIndex(), entry.getVal() * phaseY);

    // create a new path
    for (int x = from + 1, count = (int) Math.ceil((to - from) * phaseX + from); x < count; x++) {

        Entry e = dataSet.getEntryForIndex(x);
        filled.lineTo(e.getXIndex(), e.getVal() * phaseY);
    }

    // close up
    filled.lineTo(
            dataSet.getEntryForIndex(
                    Math.max(
                            Math.min((int) Math.ceil((to - from) * phaseX + from) - 1,
                                    dataSet.getEntryCount() - 1), 0)).getXIndex(), fillMin);

    filled.close();

    return filled;
}
 

private Path getModeRightBottomTrianglePath(Path path, int w, int h) {
    path.moveTo(0,h);
    path.lineTo(w,h);
    path.lineTo(w,0);
    return path;
}
 

@Override
public Path getPath(float startX, float startY, float endX, float endY) {
    Path path = new Path();
    path.moveTo(startX, startY);

    float ex;
    float ey;
    if (startY == endY) {
        ex = (startX + endX) / 2;
        ey = startY + mMinimumHorizontalTangent * Math.abs(endX - startX) / 2;
    } else if (startX == endX) {
        ex = startX + mMinimumVerticalTangent * Math.abs(endY - startY) / 2;
        ey = (startY + endY) / 2;
    } else {
        float deltaX = endX - startX;

        float deltaY;
        if (endY < startY) {
            deltaY = startY - endY; // Y is inverted compared to diagram above.
        } else {
            deltaY = endY - startY;
        }

        // hypotenuse squared.
        float h2 = deltaX * deltaX + deltaY * deltaY;

        // Midpoint between start and end
        float dx = (startX + endX) / 2;
        float dy = (startY + endY) / 2;

        // Distance squared between end point and mid point is (1/2 hypotenuse)^2
        float midDist2 = h2 * 0.25f;

        float minimumArcDist2;

        if (Math.abs(deltaX) < Math.abs(deltaY)) {
            // Similar triangles bfa and bde mean that (ab/fb = eb/bd)
            // Therefore, eb = ab * bd / fb
            // ab = hypotenuse
            // bd = hypotenuse/2
            // fb = deltaY
            float eDistY = h2 / (2 * deltaY);
            ey = endY + eDistY;
            ex = endX;

            minimumArcDist2 = midDist2 * mMinimumVerticalTangent
                    * mMinimumVerticalTangent;
        } else {
            // Same as above, but flip X & Y
            float eDistX = h2 / (2 * deltaX);
            ex = endX + eDistX;
            ey = endY;

            minimumArcDist2 = midDist2
                    * mMinimumHorizontalTangent
                    * mMinimumHorizontalTangent;
        }
        float arcDistX = dx - ex;
        float arcDistY = dy - ey;
        float arcDist2 = arcDistX * arcDistX + arcDistY * arcDistY;

        float maximumArcDist2 = midDist2 * mMaximumTangent * mMaximumTangent;

        float newArcDistance2 = 0;
        if (arcDist2 < minimumArcDist2) {
            newArcDistance2 = minimumArcDist2;
        } else if (arcDist2 > maximumArcDist2) {
            newArcDistance2 = maximumArcDist2;
        }
        if (newArcDistance2 != 0) {
            float ratio2 = newArcDistance2 / arcDist2;
            float ratio = (float) Math.sqrt(ratio2);
            ex = dx + (ratio * (ex - dx));
            ey = dy + (ratio * (ey - dy));
        }
    }
    float controlX1 = (startX + ex) / 2;
    float controlY1 = (startY + ey) / 2;
    float controlX2 = (ex + endX) / 2;
    float controlY2 = (ey + endY) / 2;
    path.cubicTo(controlX1, controlY1, controlX2, controlY2, endX, endY);
    return path;
}
 

private static void drawClipPath(String clipPath, Canvas canvas, Paint paint, RectF bounds, float density) {
    // Sample string is polygon(20% 0%, 0% 20%, 30% 50%, 0% 80%, 20% 100%, 50% 70%, 80% 100%, 100% 80%, 70% 50%, 100% 20%, 80% 0%, 50% 30%);
    String functionName = clipPath.substring(0, clipPath.indexOf("("));
    String value = clipPath.substring(clipPath.indexOf("(") + 1, clipPath.indexOf(")"));

    String[] arr;
    float top;
    float right;
    float bottom;
    float left;
    switch (functionName) {
        case "rect":
            arr = spaceAndComma.split(value);

            top = cssValueToDevicePixels(arr[0], bounds.bottom, density);
            right = cssValueToDevicePixels(arr[1], bounds.right, density);
            bottom = cssValueToDevicePixels(arr[2], bounds.bottom, density);
            left = cssValueToDevicePixels(arr[3], bounds.right, density);

            canvas.drawRect(left, top, right, bottom, paint);
            break;
        case "inset":
            arr = spaceAndComma.split(value);
            String topString = "0";
            String rightString = "0";
            String bottomString = "0";
            String leftString = "0";
            if (arr.length == 1) {
                topString = rightString = bottomString = leftString = arr[0];
            } else if (arr.length == 2) {
                topString = bottomString = arr[0];
                rightString = leftString = arr[1];
            } else if (arr.length == 3) {
                topString = arr[0];
                rightString = leftString = arr[1];
                bottomString = arr[2];
            } else if (arr.length == 4) {
                topString = arr[0];
                rightString = arr[1];
                bottomString = arr[2];
                leftString = arr[3];
            }

            top = cssValueToDevicePixels(topString, bounds.bottom, density);
            right = cssValueToDevicePixels("100%", bounds.right, density) - cssValueToDevicePixels(rightString, bounds.right, density);
            bottom = cssValueToDevicePixels("100%", bounds.bottom, density) - cssValueToDevicePixels(bottomString, bounds.bottom, density);
            left = cssValueToDevicePixels(leftString, bounds.right, density);

            canvas.drawRect(left, top, right, bottom, paint);
            break;
        case "circle":
            arr = space.split(value);
            float radius = cssValueToDevicePixels(arr[0], (bounds.width() > bounds.height() ? bounds.height() : bounds.width()) / 2, density);
            float y = cssValueToDevicePixels(arr[2], bounds.height(), density);
            float x = cssValueToDevicePixels(arr[3], bounds.width(), density);
            canvas.drawCircle(x, y, radius, paint);
            break;
        case "ellipse":
            arr = space.split(value);
            float rX = cssValueToDevicePixels(arr[0], bounds.right, density);
            float rY = cssValueToDevicePixels(arr[1], bounds.bottom, density);
            float cX = cssValueToDevicePixels(arr[3], bounds.right, density);
            float cY = cssValueToDevicePixels(arr[4], bounds.bottom, density);
            left = cX - rX;
            top = cY - rY;
            right = (rX * 2) + left;
            bottom = (rY * 2) + top;
            canvas.drawOval(new RectF(left, top, right, bottom), paint);
            break;
        case "polygon":
            Path path = new Path();
            PointF firstPoint = null;
            arr = value.split(",");
            for (String s : arr) {
                String[] xy = space.split(s.trim());
                PointF point = new PointF(cssValueToDevicePixels(xy[0], bounds.width(), density), cssValueToDevicePixels(xy[1], bounds.height(), density));

                if (firstPoint == null) {
                    firstPoint = point;
                    path.moveTo(point.x, point.y);
                }

                path.lineTo(point.x, point.y);
            }
            if (firstPoint != null) {
                path.lineTo(firstPoint.x, firstPoint.y);
            }
            canvas.drawPath(path, paint);
            break;
    }
}
 

private Path  makePathAndBoundingBox(Rect obj)
{
   float x, y, w, h, rx, ry;

   if (obj.rx == null && obj.ry == null) {
      rx = 0;
      ry = 0;
   } else if (obj.rx == null) {
      rx = ry = obj.ry.floatValueY(this);
   } else if (obj.ry == null) {
      rx = ry = obj.rx.floatValueX(this);
   } else {
      rx = obj.rx.floatValueX(this);
      ry = obj.ry.floatValueY(this);
   }
   rx = Math.min(rx, obj.width.floatValueX(this) / 2f);
   ry = Math.min(ry, obj.height.floatValueY(this) / 2f);
   x = (obj.x != null) ? obj.x.floatValueX(this) : 0f;
   y = (obj.y != null) ? obj.y.floatValueY(this) : 0f;
   w = obj.width.floatValueX(this);
   h = obj.height.floatValueY(this);

   if (obj.boundingBox == null) {
      obj.boundingBox = new Box(x, y, w, h);
   }

   float  right = x + w;
   float  bottom = y + h;

   Path  p = new Path();
   if (rx == 0 || ry == 0)
   {
      // Simple rect
      p.moveTo(x, y);
      p.lineTo(right, y);
      p.lineTo(right, bottom);
      p.lineTo(x, bottom);
      p.lineTo(x, y);
   }
   else
   {
      // Rounded rect
      
      // Bexier control point lengths for a 90 degress arc
      float  cpx = rx * BEZIER_ARC_FACTOR;
      float  cpy = ry * BEZIER_ARC_FACTOR;

      p.moveTo(x, y+ry);
      p.cubicTo(x, y+ry-cpy, x+rx-cpx, y, x+rx, y);
      p.lineTo(right-rx, y);
      p.cubicTo(right-rx+cpx, y, right, y+ry-cpy, right, y+ry);
      p.lineTo(right, bottom-ry);
      p.cubicTo(right, bottom-ry+cpy, right-rx+cpx, bottom, right-rx, bottom);
      p.lineTo(x+rx, bottom);
      p.cubicTo(x+rx-cpx, bottom, x, bottom-ry+cpy, x, bottom-ry);
      p.lineTo(x, y+ry);
   }
   p.close();
   return p;
}
 

private Path getTickPath(Path path, float x, float y, float size, float progress, boolean in){
	if(mTickPathProgress == progress)
		return path;
	
	mTickPathProgress = progress;
	
	float x1 = x + size * TICK_DATA[0];
	float y1 = y + size * TICK_DATA[1];
	float x2 = x + size * TICK_DATA[2];
	float y2 = y + size * TICK_DATA[3];
	float x3 = x + size * TICK_DATA[4];
	float y3 = y + size * TICK_DATA[5];
	
	float d1 = (float)Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
	float d2 = (float)Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
	float midProgress = d1 / (d1 + d2);
	
	path.reset();
	
	if(in){
		path.moveTo(x1, y1);			
		
		if(progress < midProgress){
			progress = progress / midProgress;
			path.lineTo(x1 * (1 - progress) + x2 * progress, y1 * (1 - progress) + y2 * progress);
		}
		else{
			progress = (progress - midProgress) / (1f - midProgress);
			path.lineTo(x2, y2);				
			path.lineTo(x2 * (1 - progress) + x3 * progress, y2 * (1 - progress) + y3 * progress);
		}	
	}	
	else{
		path.moveTo(x3, y3);
		
		if(progress < midProgress){
			progress = progress / midProgress;
			path.lineTo(x2, y2);
			path.lineTo(x1 * (1 - progress) + x2 * progress, y1 * (1 - progress) + y2 * progress);
		}
		else{
			progress = (progress - midProgress) / (1f - midProgress);
			path.lineTo(x2 * (1 - progress) + x3 * progress, y2 * (1 - progress) + y3 * progress);
		}
	}
	
	return path;
}
 

/**
 * Draws the LimitLines associated with this axis to the screen.
 *
 * @param c
 */
@Override
public void renderLimitLines(Canvas c) {

    List<LimitLine> limitLines = mYAxis.getLimitLines();

    if (limitLines == null || limitLines.size() <= 0)
        return;

    float[] pts = mRenderLimitLinesBuffer;
    pts[0] = 0;
    pts[1] = 0;
    Path limitLinePath = mRenderLimitLines;
    limitLinePath.reset();

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

        LimitLine l = limitLines.get(i);

        if (!l.isEnabled())
            continue;

        int clipRestoreCount = c.save();
        mLimitLineClippingRect.set(mViewPortHandler.getContentRect());
        mLimitLineClippingRect.inset(0.f, -l.getLineWidth());
        c.clipRect(mLimitLineClippingRect);

        mLimitLinePaint.setStyle(Paint.Style.STROKE);
        mLimitLinePaint.setColor(l.getLineColor());
        mLimitLinePaint.setStrokeWidth(l.getLineWidth());
        mLimitLinePaint.setPathEffect(l.getDashPathEffect());

        pts[1] = l.getLimit();

        mTrans.pointValuesToPixel(pts);

        limitLinePath.moveTo(mViewPortHandler.contentLeft(), pts[1]);
        limitLinePath.lineTo(mViewPortHandler.contentRight(), pts[1]);

        c.drawPath(limitLinePath, mLimitLinePaint);
        limitLinePath.reset();
        // c.drawLines(pts, mLimitLinePaint);

        String label = l.getLabel();

        // if drawing the limit-value label is enabled
        if (label != null && !label.equals("")) {

            mLimitLinePaint.setStyle(l.getTextStyle());
            mLimitLinePaint.setPathEffect(null);
            mLimitLinePaint.setColor(l.getTextColor());
            mLimitLinePaint.setTypeface(l.getTypeface());
            mLimitLinePaint.setStrokeWidth(0.5f);
            mLimitLinePaint.setTextSize(l.getTextSize());

            final float labelLineHeight = Utils.calcTextHeight(mLimitLinePaint, label);
            float xOffset = Utils.convertDpToPixel(4f) + l.getXOffset();
            float yOffset = l.getLineWidth() + labelLineHeight + l.getYOffset();

            final LimitLine.LimitLabelPosition position = l.getLabelPosition();

            if (position == LimitLine.LimitLabelPosition.RIGHT_TOP) {

                mLimitLinePaint.setTextAlign(Paint.Align.RIGHT);
                c.drawText(label,
                        mViewPortHandler.contentRight() - xOffset,
                        pts[1] - yOffset + labelLineHeight, mLimitLinePaint);

            } else if (position == LimitLine.LimitLabelPosition.RIGHT_BOTTOM) {

                mLimitLinePaint.setTextAlign(Paint.Align.RIGHT);
                c.drawText(label,
                        mViewPortHandler.contentRight() - xOffset,
                        pts[1] + yOffset, mLimitLinePaint);

            } else if (position == LimitLine.LimitLabelPosition.LEFT_TOP) {

                mLimitLinePaint.setTextAlign(Paint.Align.LEFT);
                c.drawText(label,
                        mViewPortHandler.contentLeft() + xOffset,
                        pts[1] - yOffset + labelLineHeight, mLimitLinePaint);

            } else {

                mLimitLinePaint.setTextAlign(Paint.Align.LEFT);
                c.drawText(label,
                        mViewPortHandler.offsetLeft() + xOffset,
                        pts[1] + yOffset, mLimitLinePaint);
            }
        }

        c.restoreToCount(clipRestoreCount);
    }
}
 

protected void drawAreas(Canvas canvas) {
    if (null == bandData) {
        return;
    }
    // distance between two points
    float lineLength = getDataQuadrantPaddingWidth() / 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);
    List<DateValueEntity> line1Data = line1.getLineData();
    List<DateValueEntity> line2Data = line2.getLineData();

    if (line1.isDisplay() == false || line2.isDisplay() == false) {
        return;
    }
    if (line1Data == null || line2Data == null) {
        return;
    }

    Paint mPaint = new Paint();
    mPaint.setColor(line1.getLineColor());
    mPaint.setAlpha(70);
    mPaint.setAntiAlias(true);
    // set start point’s X
    startX = getDataQuadrantPaddingStartX() + lineLength / 2f;
    Path areaPath = new Path();
    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 - minValue)
                / (maxValue - minValue)) * getDataQuadrantPaddingHeight())
                + getDataQuadrantPaddingStartY();
        float valueY2 = (float) ((1f - (value2 - minValue)
                / (maxValue - minValue)) * getDataQuadrantPaddingHeight())
                + getDataQuadrantPaddingStartY();

        // 绘制线条路径
        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);
}