Examples with Path android.graphics.Path used on opensource projects

Example 61 with Path

use of android.graphics.Path in project platform_frameworks_base by android.

the class PathInterpolator method initCubic.

private void initCubic(float x1, float y1, float x2, float y2) {
    Path path = new Path();
    path.moveTo(0, 0);
    path.cubicTo(x1, y1, x2, y2, 1f, 1f);
    initPath(path);
}

Example 62 with Path

use of android.graphics.Path in project platform_frameworks_base by android.

the class PathInterpolator method parseInterpolatorFromTypeArray.

private void parseInterpolatorFromTypeArray(TypedArray a) {
    // will be all coming from pathData.
    if (a.hasValue(R.styleable.PathInterpolator_pathData)) {
        String pathData = a.getString(R.styleable.PathInterpolator_pathData);
        Path path = PathParser.createPathFromPathData(pathData);
        if (path == null) {
            throw new InflateException("The path is null, which is created" + " from " + pathData);
        }
        initPath(path);
    } else {
        if (!a.hasValue(R.styleable.PathInterpolator_controlX1)) {
            throw new InflateException("pathInterpolator requires the controlX1 attribute");
        } else if (!a.hasValue(R.styleable.PathInterpolator_controlY1)) {
            throw new InflateException("pathInterpolator requires the controlY1 attribute");
        }
        float x1 = a.getFloat(R.styleable.PathInterpolator_controlX1, 0);
        float y1 = a.getFloat(R.styleable.PathInterpolator_controlY1, 0);
        boolean hasX2 = a.hasValue(R.styleable.PathInterpolator_controlX2);
        boolean hasY2 = a.hasValue(R.styleable.PathInterpolator_controlY2);
        if (hasX2 != hasY2) {
            throw new InflateException("pathInterpolator requires both controlX2 and controlY2 for cubic Beziers.");
        }
        if (!hasX2) {
            initQuad(x1, y1);
        } else {
            float x2 = a.getFloat(R.styleable.PathInterpolator_controlX2, 0);
            float y2 = a.getFloat(R.styleable.PathInterpolator_controlY2, 0);
            initCubic(x1, y1, x2, y2);
        }
    }
}

Example 63 with Path

use of android.graphics.Path in project platform_frameworks_base by android.

the class TextView method onDraw.

@Override
protected void onDraw(Canvas canvas) {
    restartMarqueeIfNeeded();
    // Draw the background for this view
    super.onDraw(canvas);
    final int compoundPaddingLeft = getCompoundPaddingLeft();
    final int compoundPaddingTop = getCompoundPaddingTop();
    final int compoundPaddingRight = getCompoundPaddingRight();
    final int compoundPaddingBottom = getCompoundPaddingBottom();
    final int scrollX = mScrollX;
    final int scrollY = mScrollY;
    final int right = mRight;
    final int left = mLeft;
    final int bottom = mBottom;
    final int top = mTop;
    final boolean isLayoutRtl = isLayoutRtl();
    final int offset = getHorizontalOffsetForDrawables();
    final int leftOffset = isLayoutRtl ? 0 : offset;
    final int rightOffset = isLayoutRtl ? offset : 0;
    final Drawables dr = mDrawables;
    if (dr != null) {
        /*
             * Compound, not extended, because the icon is not clipped
             * if the text height is smaller.
             */
        int vspace = bottom - top - compoundPaddingBottom - compoundPaddingTop;
        int hspace = right - left - compoundPaddingRight - compoundPaddingLeft;
        // Make sure to update invalidateDrawable() when changing this code.
        if (dr.mShowing[Drawables.LEFT] != null) {
            canvas.save();
            canvas.translate(scrollX + mPaddingLeft + leftOffset, scrollY + compoundPaddingTop + (vspace - dr.mDrawableHeightLeft) / 2);
            dr.mShowing[Drawables.LEFT].draw(canvas);
            canvas.restore();
        }
        // Make sure to update invalidateDrawable() when changing this code.
        if (dr.mShowing[Drawables.RIGHT] != null) {
            canvas.save();
            canvas.translate(scrollX + right - left - mPaddingRight - dr.mDrawableSizeRight - rightOffset, scrollY + compoundPaddingTop + (vspace - dr.mDrawableHeightRight) / 2);
            dr.mShowing[Drawables.RIGHT].draw(canvas);
            canvas.restore();
        }
        // Make sure to update invalidateDrawable() when changing this code.
        if (dr.mShowing[Drawables.TOP] != null) {
            canvas.save();
            canvas.translate(scrollX + compoundPaddingLeft + (hspace - dr.mDrawableWidthTop) / 2, scrollY + mPaddingTop);
            dr.mShowing[Drawables.TOP].draw(canvas);
            canvas.restore();
        }
        // Make sure to update invalidateDrawable() when changing this code.
        if (dr.mShowing[Drawables.BOTTOM] != null) {
            canvas.save();
            canvas.translate(scrollX + compoundPaddingLeft + (hspace - dr.mDrawableWidthBottom) / 2, scrollY + bottom - top - mPaddingBottom - dr.mDrawableSizeBottom);
            dr.mShowing[Drawables.BOTTOM].draw(canvas);
            canvas.restore();
        }
    }
    int color = mCurTextColor;
    if (mLayout == null) {
        assumeLayout();
    }
    Layout layout = mLayout;
    if (mHint != null && mText.length() == 0) {
        if (mHintTextColor != null) {
            color = mCurHintTextColor;
        }
        layout = mHintLayout;
    }
    mTextPaint.setColor(color);
    mTextPaint.drawableState = getDrawableState();
    canvas.save();
    /*  Would be faster if we didn't have to do this. Can we chop the
            (displayable) text so that we don't need to do this ever?
        */
    int extendedPaddingTop = getExtendedPaddingTop();
    int extendedPaddingBottom = getExtendedPaddingBottom();
    final int vspace = mBottom - mTop - compoundPaddingBottom - compoundPaddingTop;
    final int maxScrollY = mLayout.getHeight() - vspace;
    float clipLeft = compoundPaddingLeft + scrollX;
    float clipTop = (scrollY == 0) ? 0 : extendedPaddingTop + scrollY;
    float clipRight = right - left - getCompoundPaddingRight() + scrollX;
    float clipBottom = bottom - top + scrollY - ((scrollY == maxScrollY) ? 0 : extendedPaddingBottom);
    if (mShadowRadius != 0) {
        clipLeft += Math.min(0, mShadowDx - mShadowRadius);
        clipRight += Math.max(0, mShadowDx + mShadowRadius);
        clipTop += Math.min(0, mShadowDy - mShadowRadius);
        clipBottom += Math.max(0, mShadowDy + mShadowRadius);
    }
    canvas.clipRect(clipLeft, clipTop, clipRight, clipBottom);
    int voffsetText = 0;
    int voffsetCursor = 0;
    /* shortcircuit calling getVerticaOffset() */
    if ((mGravity & Gravity.VERTICAL_GRAVITY_MASK) != Gravity.TOP) {
        voffsetText = getVerticalOffset(false);
        voffsetCursor = getVerticalOffset(true);
    }
    canvas.translate(compoundPaddingLeft, extendedPaddingTop + voffsetText);
    final int layoutDirection = getLayoutDirection();
    final int absoluteGravity = Gravity.getAbsoluteGravity(mGravity, layoutDirection);
    if (isMarqueeFadeEnabled()) {
        if (!mSingleLine && getLineCount() == 1 && canMarquee() && (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) != Gravity.LEFT) {
            final int width = mRight - mLeft;
            final int padding = getCompoundPaddingLeft() + getCompoundPaddingRight();
            final float dx = mLayout.getLineRight(0) - (width - padding);
            canvas.translate(layout.getParagraphDirection(0) * dx, 0.0f);
        }
        if (mMarquee != null && mMarquee.isRunning()) {
            final float dx = -mMarquee.getScroll();
            canvas.translate(layout.getParagraphDirection(0) * dx, 0.0f);
        }
    }
    final int cursorOffsetVertical = voffsetCursor - voffsetText;
    Path highlight = getUpdatedHighlightPath();
    if (mEditor != null) {
        mEditor.onDraw(canvas, layout, highlight, mHighlightPaint, cursorOffsetVertical);
    } else {
        layout.draw(canvas, highlight, mHighlightPaint, cursorOffsetVertical);
    }
    if (mMarquee != null && mMarquee.shouldDrawGhost()) {
        final float dx = mMarquee.getGhostOffset();
        canvas.translate(layout.getParagraphDirection(0) * dx, 0.0f);
        layout.draw(canvas, highlight, mHighlightPaint, cursorOffsetVertical);
    }
    canvas.restore();
}

Example 64 with Path

use of android.graphics.Path in project carat by amplab.

the class LineChart method generateFilledPath.

/**
     * Generates the path that is used for filled drawing.
     * 
     * @param entries
     * @return
     */
private Path generateFilledPath(ArrayList<Entry> entries, float fillMin) {
    Path filled = new Path();
    filled.moveTo(entries.get(0).getXIndex(), entries.get(0).getVal() * mPhaseY);
    // create a new path
    for (int x = 1; x < entries.size() * mPhaseX; x++) {
        Entry e = entries.get(x);
        filled.lineTo(e.getXIndex(), e.getVal() * mPhaseY);
    }
    // close up
    filled.lineTo(entries.get((int) ((entries.size() - 1) * mPhaseX)).getXIndex(), fillMin);
    filled.lineTo(entries.get(0).getXIndex(), fillMin);
    filled.close();
    return filled;
}

Example 65 with Path

use of android.graphics.Path in project carat by amplab.

the class LineChart method drawCubic.

protected void drawCubic(LineDataSet dataSet, ArrayList<Entry> entries) {
    // get the color that is specified for this position from the
    // DataSet
    mRenderPaint.setColor(dataSet.getColor());
    float intensity = dataSet.getCubicIntensity();
    // the path for the cubic-spline
    Path spline = new Path();
    ArrayList<CPoint> points = new ArrayList<CPoint>();
    for (Entry e : entries) {
        if (e != null)
            points.add(new CPoint(e.getXIndex(), e.getVal()));
    }
    if (points.size() > 1) {
        for (int j = 0; j < points.size() * mPhaseX; j++) {
            CPoint point = points.get(j);
            if (j == 0) {
                CPoint next = points.get(j + 1);
                point.dx = ((next.x - point.x) * intensity);
                point.dy = ((next.y - point.y) * intensity);
            } else if (j == points.size() - 1) {
                CPoint prev = points.get(j - 1);
                point.dx = ((point.x - prev.x) * intensity);
                point.dy = ((point.y - prev.y) * intensity);
            } else {
                CPoint next = points.get(j + 1);
                CPoint prev = points.get(j - 1);
                point.dx = ((next.x - prev.x) * intensity);
                point.dy = ((next.y - prev.y) * intensity);
            }
            // create the cubic-spline path
            if (j == 0) {
                spline.moveTo(point.x, point.y * mPhaseY);
            } else {
                CPoint prev = points.get(j - 1);
                spline.cubicTo(prev.x + prev.dx, (prev.y + prev.dy) * mPhaseY, point.x - point.dx, (point.y - point.dy) * mPhaseY, point.x, point.y * mPhaseY);
            }
        }
    }
    // if filled is enabled, close the path
    if (dataSet.isDrawFilledEnabled()) {
        drawCubicFill(dataSet, spline);
    } else {
        mRenderPaint.setStyle(Paint.Style.STROKE);
    }
    mTrans.pathValueToPixel(spline);
    mDrawCanvas.drawPath(spline, mRenderPaint);
}