Mint v5.7.3 - PieChartRenderer.java 源代码

package com.github.mikephil.charting.renderer;

import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.text.Layout;
import android.text.StaticLayout;
import android.text.TextPaint;
import com.github.mikephil.charting.animation.ChartAnimator;
import com.github.mikephil.charting.charts.PieChart;
import com.github.mikephil.charting.data.PieData;
import com.github.mikephil.charting.data.PieDataSet;
import com.github.mikephil.charting.data.PieEntry;
import com.github.mikephil.charting.formatter.ValueFormatter;
import com.github.mikephil.charting.highlight.Highlight;
import com.github.mikephil.charting.interfaces.datasets.IPieDataSet;
import com.github.mikephil.charting.utils.MPPointF;
import com.github.mikephil.charting.utils.Utils;
import com.github.mikephil.charting.utils.ViewPortHandler;
import java.lang.ref.WeakReference;
import java.util.List;

public class PieChartRenderer extends DataRenderer {
    protected Canvas mBitmapCanvas;
    private final RectF mCenterTextLastBounds;
    private CharSequence mCenterTextLastValue;
    private StaticLayout mCenterTextLayout;
    private final TextPaint mCenterTextPaint;
    protected PieChart mChart;
    protected WeakReference<Bitmap> mDrawBitmap;
    protected Path mDrawCenterTextPathBuffer;
    protected RectF mDrawHighlightedRectF;
    private final Paint mEntryLabelsPaint;
    private final Path mHoleCirclePath;
    protected Paint mHolePaint;
    private final RectF mInnerRectBuffer;
    private final Path mPathBuffer;
    private final RectF[] mRectBuffer;
    protected Paint mTransparentCirclePaint;
    protected Paint mValueLinePaint;

    public PieChartRenderer(PieChart pieChart, ChartAnimator chartAnimator, ViewPortHandler viewPortHandler) {
        super(chartAnimator, viewPortHandler);
        this.mCenterTextLastBounds = new RectF();
        this.mRectBuffer = new RectF[]{new RectF(), new RectF(), new RectF()};
        this.mPathBuffer = new Path();
        this.mInnerRectBuffer = new RectF();
        this.mHoleCirclePath = new Path();
        this.mDrawCenterTextPathBuffer = new Path();
        this.mDrawHighlightedRectF = new RectF();
        this.mChart = pieChart;
        Paint paint = new Paint(1);
        this.mHolePaint = paint;
        paint.setColor(-1);
        this.mHolePaint.setStyle(Paint.Style.FILL);
        Paint paint2 = new Paint(1);
        this.mTransparentCirclePaint = paint2;
        paint2.setColor(-1);
        this.mTransparentCirclePaint.setStyle(Paint.Style.FILL);
        this.mTransparentCirclePaint.setAlpha(105);
        TextPaint textPaint = new TextPaint(1);
        this.mCenterTextPaint = textPaint;
        textPaint.setColor(-16777216);
        textPaint.setTextSize(Utils.convertDpToPixel(12.0f));
        this.mValuePaint.setTextSize(Utils.convertDpToPixel(13.0f));
        this.mValuePaint.setColor(-1);
        this.mValuePaint.setTextAlign(Paint.Align.CENTER);
        Paint paint3 = new Paint(1);
        this.mEntryLabelsPaint = paint3;
        paint3.setColor(-1);
        paint3.setTextAlign(Paint.Align.CENTER);
        paint3.setTextSize(Utils.convertDpToPixel(13.0f));
        Paint paint4 = new Paint(1);
        this.mValueLinePaint = paint4;
        paint4.setStyle(Paint.Style.STROKE);
    }

    protected float calculateMinimumRadiusForSpacedSlice(MPPointF mPPointF, float f, float f4, float f5, float f6, float f7, float f8) {
        double d = (f7 + f8) * 0.017453292f;
        float cos = mPPointF.x + (((float) Math.cos(d)) * f);
        float sin = mPPointF.y + (((float) Math.sin(d)) * f);
        double d5 = (f7 + (f8 / 2.0f)) * 0.017453292f;
        return (float) ((f - ((float) ((Math.sqrt(Math.pow(cos - f5, 2.0d) + Math.pow(sin - f6, 2.0d)) / 2.0d) * Math.tan(((180.0d - f4) / 2.0d) * 0.017453292519943295d)))) - Math.sqrt(Math.pow((mPPointF.x + (((float) Math.cos(d5)) * f)) - ((cos + f5) / 2.0f), 2.0d) + Math.pow((mPPointF.y + (((float) Math.sin(d5)) * f)) - ((sin + f6) / 2.0f), 2.0d)));
    }

    protected void drawCenterText(Canvas canvas) {
        MPPointF mPPointF;
        CharSequence centerText = this.mChart.getCenterText();
        if (!this.mChart.isDrawCenterTextEnabled() || centerText == null) {
            return;
        }
        MPPointF centerCircleBox = this.mChart.getCenterCircleBox();
        MPPointF centerTextOffset = this.mChart.getCenterTextOffset();
        float f = centerCircleBox.x + centerTextOffset.x;
        float f4 = centerCircleBox.y + centerTextOffset.y;
        float radius = (!this.mChart.isDrawHoleEnabled() || this.mChart.isDrawSlicesUnderHoleEnabled()) ? this.mChart.getRadius() : this.mChart.getRadius() * (this.mChart.getHoleRadius() / 100.0f);
        RectF[] rectFArr = this.mRectBuffer;
        RectF rectF = rectFArr[0];
        rectF.left = f - radius;
        rectF.top = f4 - radius;
        rectF.right = f + radius;
        rectF.bottom = f4 + radius;
        RectF rectF2 = rectFArr[1];
        rectF2.set(rectF);
        float centerTextRadiusPercent = this.mChart.getCenterTextRadiusPercent() / 100.0f;
        if (centerTextRadiusPercent > Utils.DOUBLE_EPSILON) {
            rectF2.inset((rectF2.width() - (rectF2.width() * centerTextRadiusPercent)) / 2.0f, (rectF2.height() - (rectF2.height() * centerTextRadiusPercent)) / 2.0f);
        }
        if (centerText.equals(this.mCenterTextLastValue) && rectF2.equals(this.mCenterTextLastBounds)) {
            mPPointF = centerTextOffset;
        } else {
            this.mCenterTextLastBounds.set(rectF2);
            this.mCenterTextLastValue = centerText;
            mPPointF = centerTextOffset;
            this.mCenterTextLayout = new StaticLayout(centerText, 0, centerText.length(), this.mCenterTextPaint, (int) Math.max(Math.ceil(this.mCenterTextLastBounds.width()), 1.0d), Layout.Alignment.ALIGN_CENTER, 1.0f, 0.0f, false);
        }
        float height = this.mCenterTextLayout.getHeight();
        canvas.save();
        Path path = this.mDrawCenterTextPathBuffer;
        path.reset();
        path.addOval(rectF, Path.Direction.CW);
        canvas.clipPath(path);
        canvas.translate(rectF2.left, rectF2.top + ((rectF2.height() - height) / 2.0f));
        this.mCenterTextLayout.draw(canvas);
        canvas.restore();
        MPPointF.recycleInstance(centerCircleBox);
        MPPointF.recycleInstance(mPPointF);
    }

    @Override
    public void drawData(Canvas canvas) {
        int chartWidth = (int) this.mViewPortHandler.getChartWidth();
        int chartHeight = (int) this.mViewPortHandler.getChartHeight();
        WeakReference<Bitmap> weakReference = this.mDrawBitmap;
        Bitmap bitmap = weakReference == null ? null : weakReference.get();
        if (bitmap == null || bitmap.getWidth() != chartWidth || bitmap.getHeight() != chartHeight) {
            if (chartWidth <= 0 || chartHeight <= 0) {
                return;
            }
            bitmap = Bitmap.createBitmap(chartWidth, chartHeight, Bitmap.Config.ARGB_4444);
            this.mDrawBitmap = new WeakReference<>(bitmap);
            this.mBitmapCanvas = new Canvas(bitmap);
        }
        bitmap.eraseColor(0);
        for (IPieDataSet iPieDataSet : ((PieData) this.mChart.getData()).getDataSets()) {
            if (iPieDataSet.isVisible() && iPieDataSet.getEntryCount() > 0) {
                drawDataSet(canvas, iPieDataSet);
            }
        }
    }

    protected void drawDataSet(Canvas canvas, IPieDataSet iPieDataSet) {
        int i;
        int i4;
        int i5;
        float f;
        float f4;
        float[] fArr;
        float f5;
        float f6;
        int i6;
        RectF rectF;
        RectF rectF2;
        MPPointF mPPointF;
        float f7;
        MPPointF mPPointF2;
        int i7;
        float f8;
        MPPointF mPPointF3;
        IPieDataSet iPieDataSet2 = iPieDataSet;
        float rotationAngle = this.mChart.getRotationAngle();
        float phaseX = this.mAnimator.getPhaseX();
        float phaseY = this.mAnimator.getPhaseY();
        RectF circleBox = this.mChart.getCircleBox();
        int entryCount = iPieDataSet.getEntryCount();
        float[] drawAngles = this.mChart.getDrawAngles();
        MPPointF centerCircleBox = this.mChart.getCenterCircleBox();
        float radius = this.mChart.getRadius();
        boolean z = this.mChart.isDrawHoleEnabled() && !this.mChart.isDrawSlicesUnderHoleEnabled();
        float holeRadius = z ? (this.mChart.getHoleRadius() / 100.0f) * radius : 0.0f;
        float holeRadius2 = (radius - ((this.mChart.getHoleRadius() * radius) / 100.0f)) / 2.0f;
        RectF rectF3 = new RectF();
        boolean z4 = z && this.mChart.isDrawRoundedSlicesEnabled();
        int i8 = 0;
        for (int i9 = 0; i9 < entryCount; i9++) {
            if (Math.abs(iPieDataSet2.getEntryForIndex(i9).getY()) > Utils.FLOAT_EPSILON) {
                i8++;
            }
        }
        float sliceSpace = i8 <= 1 ? 0.0f : getSliceSpace(iPieDataSet2);
        int i10 = 0;
        float f9 = 0.0f;
        while (i10 < entryCount) {
            float f10 = drawAngles[i10];
            float abs = Math.abs(iPieDataSet2.getEntryForIndex(i10).getY());
            float f11 = Utils.FLOAT_EPSILON;
            if (abs > f11 && !(iPieDataSet.isHighlightEnabled() && this.mChart.needsHighlight(i10) && !z4)) {
                boolean z5 = sliceSpace > 0.0f && f10 <= 180.0f;
                i = entryCount;
                this.mRenderPaint.setColor(iPieDataSet2.getColor(i10));
                float f12 = i8 == 1 ? 0.0f : sliceSpace / (radius * 0.017453292f);
                float f13 = rotationAngle + ((f9 + (f12 / 2.0f)) * phaseY);
                float f14 = (f10 - f12) * phaseY;
                float f15 = f14 < 0.0f ? 0.0f : f14;
                this.mPathBuffer.reset();
                if (z4) {
                    float f16 = radius - holeRadius2;
                    i4 = i10;
                    i5 = i8;
                    double d = f13 * 0.017453292f;
                    f = rotationAngle;
                    f4 = phaseX;
                    float cos = centerCircleBox.x + (((float) Math.cos(d)) * f16);
                    float sin = centerCircleBox.y + (f16 * ((float) Math.sin(d)));
                    rectF3.set(cos - holeRadius2, sin - holeRadius2, cos + holeRadius2, sin + holeRadius2);
                } else {
                    i4 = i10;
                    i5 = i8;
                    f = rotationAngle;
                    f4 = phaseX;
                }
                double d5 = f13 * 0.017453292f;
                float f17 = holeRadius;
                float cos2 = centerCircleBox.x + (((float) Math.cos(d5)) * radius);
                float sin2 = centerCircleBox.y + (((float) Math.sin(d5)) * radius);
                if (f15 < 360.0f || f15 % 360.0f > f11) {
                    fArr = drawAngles;
                    if (z4) {
                        this.mPathBuffer.arcTo(rectF3, f13 + 180.0f, -180.0f);
                    }
                    this.mPathBuffer.arcTo(circleBox, f13, f15);
                } else {
                    fArr = drawAngles;
                    this.mPathBuffer.addCircle(centerCircleBox.x, centerCircleBox.y, radius, Path.Direction.CW);
                }
                RectF rectF4 = this.mInnerRectBuffer;
                float f18 = centerCircleBox.x;
                float f19 = centerCircleBox.y;
                RectF rectF5 = rectF3;
                rectF4.set(f18 - f17, f19 - f17, f18 + f17, f19 + f17);
                if (!z) {
                    f5 = radius;
                    f6 = f17;
                    i6 = i5;
                    rectF = rectF5;
                    rectF2 = circleBox;
                    mPPointF = centerCircleBox;
                    f7 = 360.0f;
                } else if (f17 > 0.0f || z5) {
                    if (z5) {
                        i6 = i5;
                        rectF2 = circleBox;
                        f6 = f17;
                        i7 = 1;
                        f5 = radius;
                        mPPointF2 = centerCircleBox;
                        float calculateMinimumRadiusForSpacedSlice = calculateMinimumRadiusForSpacedSlice(centerCircleBox, radius, f10 * phaseY, cos2, sin2, f13, f15);
                        if (calculateMinimumRadiusForSpacedSlice < 0.0f) {
                            calculateMinimumRadiusForSpacedSlice = -calculateMinimumRadiusForSpacedSlice;
                        }
                        f8 = Math.max(f6, calculateMinimumRadiusForSpacedSlice);
                    } else {
                        f5 = radius;
                        mPPointF2 = centerCircleBox;
                        f6 = f17;
                        i6 = i5;
                        rectF2 = circleBox;
                        i7 = 1;
                        f8 = f6;
                    }
                    float f20 = (i6 == i7 || f8 == 0.0f) ? 0.0f : sliceSpace / (f8 * 0.017453292f);
                    float f21 = f + ((f9 + (f20 / 2.0f)) * phaseY);
                    float f22 = (f10 - f20) * phaseY;
                    if (f22 < 0.0f) {
                        f22 = 0.0f;
                    }
                    float f23 = f21 + f22;
                    if (f15 < 360.0f || f15 % 360.0f > f11) {
                        if (z4) {
                            float f24 = f5 - holeRadius2;
                            double d6 = 0.017453292f * f23;
                            mPPointF3 = mPPointF2;
                            float cos3 = mPPointF2.x + (((float) Math.cos(d6)) * f24);
                            float sin3 = mPPointF3.y + (f24 * ((float) Math.sin(d6)));
                            rectF = rectF5;
                            rectF.set(cos3 - holeRadius2, sin3 - holeRadius2, cos3 + holeRadius2, sin3 + holeRadius2);
                            this.mPathBuffer.arcTo(rectF, f23, 180.0f);
                        } else {
                            mPPointF3 = mPPointF2;
                            rectF = rectF5;
                            double d7 = f23 * 0.017453292f;
                            this.mPathBuffer.lineTo(mPPointF3.x + (((float) Math.cos(d7)) * f8), mPPointF3.y + (f8 * ((float) Math.sin(d7))));
                        }
                        this.mPathBuffer.arcTo(this.mInnerRectBuffer, f23, -f22);
                    } else {
                        this.mPathBuffer.addCircle(mPPointF2.x, mPPointF2.y, f8, Path.Direction.CCW);
                        mPPointF3 = mPPointF2;
                        rectF = rectF5;
                    }
                    mPPointF = mPPointF3;
                    this.mPathBuffer.close();
                    this.mBitmapCanvas.drawPath(this.mPathBuffer, this.mRenderPaint);
                    f9 += f10 * f4;
                } else {
                    f5 = radius;
                    f6 = f17;
                    i6 = i5;
                    rectF = rectF5;
                    f7 = 360.0f;
                    rectF2 = circleBox;
                    mPPointF = centerCircleBox;
                }
                if (f15 % f7 > f11) {
                    if (z5) {
                        float calculateMinimumRadiusForSpacedSlice2 = calculateMinimumRadiusForSpacedSlice(mPPointF, f5, f10 * phaseY, cos2, sin2, f13, f15);
                        double d8 = 0.017453292f * (f13 + (f15 / 2.0f));
                        this.mPathBuffer.lineTo(mPPointF.x + (((float) Math.cos(d8)) * calculateMinimumRadiusForSpacedSlice2), mPPointF.y + (calculateMinimumRadiusForSpacedSlice2 * ((float) Math.sin(d8))));
                    } else {
                        this.mPathBuffer.lineTo(mPPointF.x, mPPointF.y);
                    }
                }
                this.mPathBuffer.close();
                this.mBitmapCanvas.drawPath(this.mPathBuffer, this.mRenderPaint);
                f9 += f10 * f4;
            } else {
                f9 += f10 * phaseX;
                i4 = i10;
                f5 = radius;
                f = rotationAngle;
                f4 = phaseX;
                rectF2 = circleBox;
                i = entryCount;
                fArr = drawAngles;
                i6 = i8;
                rectF = rectF3;
                f6 = holeRadius;
                mPPointF = centerCircleBox;
            }
            i10 = i4 + 1;
            iPieDataSet2 = iPieDataSet;
            holeRadius = f6;
            rectF3 = rectF;
            centerCircleBox = mPPointF;
            i8 = i6;
            radius = f5;
            entryCount = i;
            circleBox = rectF2;
            rotationAngle = f;
            phaseX = f4;
            drawAngles = fArr;
        }
        MPPointF.recycleInstance(centerCircleBox);
    }

    protected void drawEntryLabel(Canvas canvas, String str, float f, float f4) {
        canvas.drawText(str, f, f4, this.mEntryLabelsPaint);
    }

    @Override
    public void drawExtras(Canvas canvas) {
        drawHole(canvas);
        canvas.drawBitmap(this.mDrawBitmap.get(), 0.0f, 0.0f, (Paint) null);
        drawCenterText(canvas);
    }

    @Override
    public void drawHighlighted(Canvas canvas, Highlight[] highlightArr) {
        int i;
        RectF rectF;
        float f;
        float[] fArr;
        boolean z;
        float f4;
        float f5;
        MPPointF mPPointF;
        IPieDataSet dataSetByIndex;
        float f6;
        int i4;
        float[] fArr2;
        float f7;
        int i5;
        float f8;
        float f9;
        Highlight[] highlightArr2 = highlightArr;
        boolean z4 = this.mChart.isDrawHoleEnabled() && !this.mChart.isDrawSlicesUnderHoleEnabled();
        if (z4 && this.mChart.isDrawRoundedSlicesEnabled()) {
            return;
        }
        float phaseX = this.mAnimator.getPhaseX();
        float phaseY = this.mAnimator.getPhaseY();
        float rotationAngle = this.mChart.getRotationAngle();
        float[] drawAngles = this.mChart.getDrawAngles();
        float[] absoluteAngles = this.mChart.getAbsoluteAngles();
        MPPointF centerCircleBox = this.mChart.getCenterCircleBox();
        float radius = this.mChart.getRadius();
        float holeRadius = z4 ? (this.mChart.getHoleRadius() / 100.0f) * radius : 0.0f;
        RectF rectF2 = this.mDrawHighlightedRectF;
        rectF2.set(0.0f, 0.0f, 0.0f, 0.0f);
        int i6 = 0;
        while (i6 < highlightArr2.length) {
            int x = (int) highlightArr2[i6].getX();
            if (x < drawAngles.length && (dataSetByIndex = ((PieData) this.mChart.getData()).getDataSetByIndex(highlightArr2[i6].getDataSetIndex())) != null && dataSetByIndex.isHighlightEnabled()) {
                int entryCount = dataSetByIndex.getEntryCount();
                int i7 = 0;
                for (int i8 = 0; i8 < entryCount; i8++) {
                    if (Math.abs(dataSetByIndex.getEntryForIndex(i8).getY()) > Utils.FLOAT_EPSILON) {
                        i7++;
                    }
                }
                if (x == 0) {
                    i4 = 1;
                    f6 = 0.0f;
                } else {
                    f6 = absoluteAngles[x - 1] * phaseX;
                    i4 = 1;
                }
                float sliceSpace = i7 <= i4 ? 0.0f : dataSetByIndex.getSliceSpace();
                float f10 = drawAngles[x];
                float selectionShift = dataSetByIndex.getSelectionShift();
                int i9 = i6;
                float f11 = radius + selectionShift;
                float f12 = holeRadius;
                rectF2.set(this.mChart.getCircleBox());
                float f13 = -selectionShift;
                rectF2.inset(f13, f13);
                boolean z5 = sliceSpace > 0.0f && f10 <= 180.0f;
                Integer highlightColor = dataSetByIndex.getHighlightColor();
                if (highlightColor == null) {
                    highlightColor = Integer.valueOf(dataSetByIndex.getColor(x));
                }
                this.mRenderPaint.setColor(highlightColor.intValue());
                float f14 = i7 == 1 ? 0.0f : sliceSpace / (radius * 0.017453292f);
                float f15 = i7 == 1 ? 0.0f : sliceSpace / (f11 * 0.017453292f);
                float f16 = rotationAngle + (((f14 / 2.0f) + f6) * phaseY);
                float f17 = (f10 - f14) * phaseY;
                float f18 = f17 < 0.0f ? 0.0f : f17;
                float f19 = (((f15 / 2.0f) + f6) * phaseY) + rotationAngle;
                float f20 = (f10 - f15) * phaseY;
                if (f20 < 0.0f) {
                    f20 = 0.0f;
                }
                this.mPathBuffer.reset();
                if (f18 < 360.0f || f18 % 360.0f > Utils.FLOAT_EPSILON) {
                    fArr2 = drawAngles;
                    f7 = f6;
                    double d = f19 * 0.017453292f;
                    i5 = i7;
                    z = z4;
                    this.mPathBuffer.moveTo(centerCircleBox.x + (((float) Math.cos(d)) * f11), centerCircleBox.y + (f11 * ((float) Math.sin(d))));
                    this.mPathBuffer.arcTo(rectF2, f19, f20);
                } else {
                    this.mPathBuffer.addCircle(centerCircleBox.x, centerCircleBox.y, f11, Path.Direction.CW);
                    fArr2 = drawAngles;
                    f7 = f6;
                    i5 = i7;
                    z = z4;
                }
                if (z5) {
                    double d5 = f16 * 0.017453292f;
                    i = i9;
                    rectF = rectF2;
                    f = f12;
                    mPPointF = centerCircleBox;
                    fArr = fArr2;
                    f8 = calculateMinimumRadiusForSpacedSlice(centerCircleBox, radius, f10 * phaseY, (((float) Math.cos(d5)) * radius) + centerCircleBox.x, centerCircleBox.y + (((float) Math.sin(d5)) * radius), f16, f18);
                } else {
                    rectF = rectF2;
                    mPPointF = centerCircleBox;
                    i = i9;
                    f = f12;
                    fArr = fArr2;
                    f8 = 0.0f;
                }
                RectF rectF3 = this.mInnerRectBuffer;
                float f21 = mPPointF.x;
                float f22 = mPPointF.y;
                rectF3.set(f21 - f, f22 - f, f21 + f, f22 + f);
                if (!z || (f <= 0.0f && !z5)) {
                    f4 = phaseX;
                    f5 = phaseY;
                    if (f18 % 360.0f > Utils.FLOAT_EPSILON) {
                        if (z5) {
                            double d6 = (f16 + (f18 / 2.0f)) * 0.017453292f;
                            this.mPathBuffer.lineTo(mPPointF.x + (((float) Math.cos(d6)) * f8), mPPointF.y + (f8 * ((float) Math.sin(d6))));
                        } else {
                            this.mPathBuffer.lineTo(mPPointF.x, mPPointF.y);
                        }
                    }
                } else {
                    if (z5) {
                        if (f8 < 0.0f) {
                            f8 = -f8;
                        }
                        f9 = Math.max(f, f8);
                    } else {
                        f9 = f;
                    }
                    float f23 = (i5 == 1 || f9 == 0.0f) ? 0.0f : sliceSpace / (f9 * 0.017453292f);
                    float f24 = ((f7 + (f23 / 2.0f)) * phaseY) + rotationAngle;
                    float f25 = (f10 - f23) * phaseY;
                    if (f25 < 0.0f) {
                        f25 = 0.0f;
                    }
                    float f26 = f24 + f25;
                    if (f18 < 360.0f || f18 % 360.0f > Utils.FLOAT_EPSILON) {
                        double d7 = f26 * 0.017453292f;
                        f4 = phaseX;
                        f5 = phaseY;
                        this.mPathBuffer.lineTo(mPPointF.x + (((float) Math.cos(d7)) * f9), mPPointF.y + (f9 * ((float) Math.sin(d7))));
                        this.mPathBuffer.arcTo(this.mInnerRectBuffer, f26, -f25);
                    } else {
                        this.mPathBuffer.addCircle(mPPointF.x, mPPointF.y, f9, Path.Direction.CCW);
                        f4 = phaseX;
                        f5 = phaseY;
                    }
                }
                this.mPathBuffer.close();
                this.mBitmapCanvas.drawPath(this.mPathBuffer, this.mRenderPaint);
            } else {
                i = i6;
                rectF = rectF2;
                f = holeRadius;
                fArr = drawAngles;
                z = z4;
                f4 = phaseX;
                f5 = phaseY;
                mPPointF = centerCircleBox;
            }
            i6 = i + 1;
            phaseX = f4;
            rectF2 = rectF;
            holeRadius = f;
            centerCircleBox = mPPointF;
            phaseY = f5;
            drawAngles = fArr;
            z4 = z;
            highlightArr2 = highlightArr;
        }
        MPPointF.recycleInstance(centerCircleBox);
    }

    protected void drawHole(Canvas canvas) {
        if (!this.mChart.isDrawHoleEnabled() || this.mBitmapCanvas == null) {
            return;
        }
        float radius = this.mChart.getRadius();
        float holeRadius = (this.mChart.getHoleRadius() / 100.0f) * radius;
        MPPointF centerCircleBox = this.mChart.getCenterCircleBox();
        if (Color.alpha(this.mHolePaint.getColor()) > 0) {
            this.mBitmapCanvas.drawCircle(centerCircleBox.x, centerCircleBox.y, holeRadius, this.mHolePaint);
        }
        if (Color.alpha(this.mTransparentCirclePaint.getColor()) > 0 && this.mChart.getTransparentCircleRadius() > this.mChart.getHoleRadius()) {
            int alpha = this.mTransparentCirclePaint.getAlpha();
            float transparentCircleRadius = radius * (this.mChart.getTransparentCircleRadius() / 100.0f);
            this.mTransparentCirclePaint.setAlpha((int) (alpha * this.mAnimator.getPhaseX() * this.mAnimator.getPhaseY()));
            this.mHoleCirclePath.reset();
            this.mHoleCirclePath.addCircle(centerCircleBox.x, centerCircleBox.y, transparentCircleRadius, Path.Direction.CW);
            this.mHoleCirclePath.addCircle(centerCircleBox.x, centerCircleBox.y, holeRadius, Path.Direction.CCW);
            this.mBitmapCanvas.drawPath(this.mHoleCirclePath, this.mTransparentCirclePaint);
            this.mTransparentCirclePaint.setAlpha(alpha);
        }
        MPPointF.recycleInstance(centerCircleBox);
    }

    protected void drawRoundedSlices(Canvas canvas) {
        float f;
        float[] fArr;
        float f4;
        if (this.mChart.isDrawRoundedSlicesEnabled()) {
            IPieDataSet dataSet = ((PieData) this.mChart.getData()).getDataSet();
            if (dataSet.isVisible()) {
                float phaseX = this.mAnimator.getPhaseX();
                float phaseY = this.mAnimator.getPhaseY();
                MPPointF centerCircleBox = this.mChart.getCenterCircleBox();
                float radius = this.mChart.getRadius();
                float holeRadius = (radius - ((this.mChart.getHoleRadius() * radius) / 100.0f)) / 2.0f;
                float[] drawAngles = this.mChart.getDrawAngles();
                float rotationAngle = this.mChart.getRotationAngle();
                int i = 0;
                while (i < dataSet.getEntryCount()) {
                    float f5 = drawAngles[i];
                    if (Math.abs(dataSet.getEntryForIndex(i).getY()) > Utils.FLOAT_EPSILON) {
                        double d = radius - holeRadius;
                        double d5 = (rotationAngle + f5) * phaseY;
                        f = phaseY;
                        fArr = drawAngles;
                        f4 = rotationAngle;
                        float cos = (float) (centerCircleBox.x + (Math.cos(Math.toRadians(d5)) * d));
                        float sin = (float) ((d * Math.sin(Math.toRadians(d5))) + centerCircleBox.y);
                        this.mRenderPaint.setColor(dataSet.getColor(i));
                        this.mBitmapCanvas.drawCircle(cos, sin, holeRadius, this.mRenderPaint);
                    } else {
                        f = phaseY;
                        fArr = drawAngles;
                        f4 = rotationAngle;
                    }
                    rotationAngle = f4 + (f5 * phaseX);
                    i++;
                    phaseY = f;
                    drawAngles = fArr;
                }
                MPPointF.recycleInstance(centerCircleBox);
            }
        }
    }

    @Override
    public void drawValue(Canvas canvas, String str, float f, float f4, int i) {
        this.mValuePaint.setColor(i);
        canvas.drawText(str, f, f4, this.mValuePaint);
    }

    @Override
    public void drawValues(Canvas canvas) {
        int i;
        List<IPieDataSet> list;
        float[] fArr;
        float[] fArr2;
        float f;
        float f4;
        float f5;
        MPPointF mPPointF;
        float f6;
        Canvas canvas2;
        float f7;
        float f8;
        float f9;
        float f10;
        int i4;
        int i5;
        float f11;
        MPPointF mPPointF2;
        int i6;
        PieEntry pieEntry;
        ValueFormatter valueFormatter;
        PieDataSet.ValuePosition valuePosition;
        MPPointF mPPointF3;
        IPieDataSet iPieDataSet;
        int i7;
        float f12;
        Canvas canvas3;
        int i8;
        String str;
        String str2;
        Canvas canvas4;
        MPPointF mPPointF4;
        MPPointF mPPointF5;
        Canvas canvas5 = canvas;
        MPPointF centerCircleBox = this.mChart.getCenterCircleBox();
        float radius = this.mChart.getRadius();
        float rotationAngle = this.mChart.getRotationAngle();
        float[] drawAngles = this.mChart.getDrawAngles();
        float[] absoluteAngles = this.mChart.getAbsoluteAngles();
        float phaseX = this.mAnimator.getPhaseX();
        float phaseY = this.mAnimator.getPhaseY();
        float holeRadius = (radius - ((this.mChart.getHoleRadius() * radius) / 100.0f)) / 2.0f;
        float holeRadius2 = this.mChart.getHoleRadius() / 100.0f;
        float f13 = (radius / 10.0f) * 3.6f;
        if (this.mChart.isDrawHoleEnabled()) {
            f13 = (radius - (radius * holeRadius2)) / 2.0f;
            if (!this.mChart.isDrawSlicesUnderHoleEnabled() && this.mChart.isDrawRoundedSlicesEnabled()) {
                rotationAngle = (float) (rotationAngle + ((holeRadius * 360.0f) / (radius * 6.283185307179586d)));
            }
        }
        float f14 = rotationAngle;
        float f15 = radius - f13;
        PieData pieData = (PieData) this.mChart.getData();
        List<IPieDataSet> dataSets = pieData.getDataSets();
        float yValueSum = pieData.getYValueSum();
        boolean isDrawEntryLabelsEnabled = this.mChart.isDrawEntryLabelsEnabled();
        canvas.save();
        float convertDpToPixel = Utils.convertDpToPixel(5.0f);
        int i9 = 0;
        int i10 = 0;
        while (i10 < dataSets.size()) {
            IPieDataSet iPieDataSet2 = dataSets.get(i10);
            boolean isDrawValuesEnabled = iPieDataSet2.isDrawValuesEnabled();
            if (isDrawValuesEnabled || isDrawEntryLabelsEnabled) {
                PieDataSet.ValuePosition xValuePosition = iPieDataSet2.getXValuePosition();
                PieDataSet.ValuePosition yValuePosition = iPieDataSet2.getYValuePosition();
                applyValueTextStyle(iPieDataSet2);
                int i11 = i9;
                i = i10;
                float calcTextHeight = Utils.calcTextHeight(this.mValuePaint, "Q") + Utils.convertDpToPixel(4.0f);
                ValueFormatter valueFormatter2 = iPieDataSet2.getValueFormatter();
                int entryCount = iPieDataSet2.getEntryCount();
                boolean isUseValueColorForLineEnabled = iPieDataSet2.isUseValueColorForLineEnabled();
                list = dataSets;
                int valueLineColor = iPieDataSet2.getValueLineColor();
                this.mValueLinePaint.setStrokeWidth(Utils.convertDpToPixel(iPieDataSet2.getValueLineWidth()));
                float sliceSpace = getSliceSpace(iPieDataSet2);
                MPPointF mPPointF6 = MPPointF.getInstance(iPieDataSet2.getIconsOffset());
                MPPointF mPPointF7 = centerCircleBox;
                mPPointF6.x = Utils.convertDpToPixel(mPPointF6.x);
                mPPointF6.y = Utils.convertDpToPixel(mPPointF6.y);
                int i12 = 0;
                while (i12 < entryCount) {
                    MPPointF mPPointF8 = mPPointF6;
                    PieEntry entryForIndex = iPieDataSet2.getEntryForIndex(i12);
                    int i13 = entryCount;
                    float f16 = f14 + (((i11 == 0 ? 0.0f : absoluteAngles[i11 - 1] * phaseX) + ((drawAngles[i11] - ((sliceSpace / (f15 * 0.017453292f)) / 2.0f)) / 2.0f)) * phaseY);
                    float f17 = sliceSpace;
                    String pieLabel = valueFormatter2.getPieLabel(this.mChart.isUsePercentValuesEnabled() ? (entryForIndex.getY() / yValueSum) * 100.0f : entryForIndex.getY(), entryForIndex);
                    float[] fArr3 = drawAngles;
                    String label = entryForIndex.getLabel();
                    ValueFormatter valueFormatter3 = valueFormatter2;
                    double d = f16 * 0.017453292f;
                    float[] fArr4 = absoluteAngles;
                    float f18 = phaseX;
                    float cos = (float) Math.cos(d);
                    float f19 = phaseY;
                    float sin = (float) Math.sin(d);
                    boolean z = isDrawEntryLabelsEnabled && xValuePosition == PieDataSet.ValuePosition.OUTSIDE_SLICE;
                    float f20 = f14;
                    boolean z4 = isDrawValuesEnabled && yValuePosition == PieDataSet.ValuePosition.OUTSIDE_SLICE;
                    boolean z5 = isDrawEntryLabelsEnabled && xValuePosition == PieDataSet.ValuePosition.INSIDE_SLICE;
                    PieDataSet.ValuePosition valuePosition2 = xValuePosition;
                    boolean z6 = isDrawValuesEnabled && yValuePosition == PieDataSet.ValuePosition.INSIDE_SLICE;
                    if (z || z4) {
                        float valueLinePart1Length = iPieDataSet2.getValueLinePart1Length();
                        float valueLinePart2Length = iPieDataSet2.getValueLinePart2Length();
                        float valueLinePart1OffsetPercentage = iPieDataSet2.getValueLinePart1OffsetPercentage() / 100.0f;
                        PieDataSet.ValuePosition valuePosition3 = yValuePosition;
                        if (this.mChart.isDrawHoleEnabled()) {
                            float f21 = radius * holeRadius2;
                            f7 = ((radius - f21) * valueLinePart1OffsetPercentage) + f21;
                        } else {
                            f7 = radius * valueLinePart1OffsetPercentage;
                        }
                        float abs = iPieDataSet2.isValueLineVariableLength() ? valueLinePart2Length * f15 * ((float) Math.abs(Math.sin(d))) : valueLinePart2Length * f15;
                        MPPointF mPPointF9 = mPPointF7;
                        float f22 = mPPointF9.x;
                        float f23 = (f7 * cos) + f22;
                        f8 = radius;
                        float f24 = mPPointF9.y;
                        float f25 = (f7 * sin) + f24;
                        float f26 = (valueLinePart1Length + 1.0f) * f15;
                        float f27 = (f26 * cos) + f22;
                        float f28 = f24 + (f26 * sin);
                        double d5 = f16 % 360.0d;
                        if (d5 < 90.0d || d5 > 270.0d) {
                            f9 = f27 + abs;
                            this.mValuePaint.setTextAlign(Paint.Align.LEFT);
                            if (z) {
                                this.mEntryLabelsPaint.setTextAlign(Paint.Align.LEFT);
                            }
                            f10 = f9 + convertDpToPixel;
                        } else {
                            float f29 = f27 - abs;
                            this.mValuePaint.setTextAlign(Paint.Align.RIGHT);
                            if (z) {
                                this.mEntryLabelsPaint.setTextAlign(Paint.Align.RIGHT);
                            }
                            f9 = f29;
                            f10 = f29 - convertDpToPixel;
                        }
                        if (isUseValueColorForLineEnabled) {
                            i5 = iPieDataSet2.getColor(i12);
                            i4 = valueLineColor;
                        } else {
                            i4 = valueLineColor;
                            i5 = i4 != 1122867 ? i4 : 1122867;
                        }
                        if (i5 != 1122867) {
                            this.mValueLinePaint.setColor(i5);
                            i6 = i13;
                            valuePosition = valuePosition3;
                            f11 = sin;
                            iPieDataSet = iPieDataSet2;
                            valueFormatter = valueFormatter3;
                            i7 = i4;
                            mPPointF2 = mPPointF8;
                            pieEntry = entryForIndex;
                            mPPointF3 = mPPointF9;
                            f12 = f10;
                            canvas.drawLine(f23, f25, f27, f28, this.mValueLinePaint);
                            canvas.drawLine(f27, f28, f9, f28, this.mValueLinePaint);
                        } else {
                            f11 = sin;
                            mPPointF2 = mPPointF8;
                            i6 = i13;
                            pieEntry = entryForIndex;
                            valueFormatter = valueFormatter3;
                            valuePosition = valuePosition3;
                            mPPointF3 = mPPointF9;
                            iPieDataSet = iPieDataSet2;
                            i7 = i4;
                            f12 = f10;
                        }
                        if (z && z4) {
                            drawValue(canvas, pieLabel, f12, f28, iPieDataSet.getValueTextColor(i12));
                            if (i12 >= pieData.getEntryCount() || label == null) {
                                i8 = i7;
                                canvas4 = canvas;
                                str2 = label;
                            } else {
                                canvas3 = canvas;
                                float f30 = f12;
                                i8 = i7;
                                str = label;
                                drawEntryLabel(canvas3, str, f30, f28 + calcTextHeight);
                                str2 = str;
                                canvas4 = canvas3;
                            }
                        } else {
                            canvas3 = canvas;
                            float f31 = f12;
                            i8 = i7;
                            str = label;
                            if (z) {
                                if (i12 < pieData.getEntryCount() && str != null) {
                                    drawEntryLabel(canvas3, str, f31, f28 + (calcTextHeight / 2.0f));
                                }
                            } else if (z4) {
                                str2 = str;
                                canvas4 = canvas3;
                                drawValue(canvas, pieLabel, f31, f28 + (calcTextHeight / 2.0f), iPieDataSet.getValueTextColor(i12));
                            }
                            str2 = str;
                            canvas4 = canvas3;
                        }
                    } else {
                        f11 = sin;
                        mPPointF3 = mPPointF7;
                        mPPointF2 = mPPointF8;
                        pieEntry = entryForIndex;
                        valueFormatter = valueFormatter3;
                        str2 = label;
                        iPieDataSet = iPieDataSet2;
                        f8 = radius;
                        i8 = valueLineColor;
                        i6 = i13;
                        canvas4 = canvas;
                        valuePosition = yValuePosition;
                    }
                    if (z5 || z6) {
                        mPPointF4 = mPPointF3;
                        float f32 = (f15 * cos) + mPPointF4.x;
                        float f33 = (f15 * f11) + mPPointF4.y;
                        this.mValuePaint.setTextAlign(Paint.Align.CENTER);
                        if (z5 && z6) {
                            drawValue(canvas, pieLabel, f32, f33, iPieDataSet.getValueTextColor(i12));
                            if (i12 < pieData.getEntryCount() && str2 != null) {
                                drawEntryLabel(canvas4, str2, f32, f33 + calcTextHeight);
                            }
                        } else {
                            if (z5) {
                                if (i12 < pieData.getEntryCount() && str2 != null) {
                                    drawEntryLabel(canvas4, str2, f32, f33 + (calcTextHeight / 2.0f));
                                }
                            } else if (z6) {
                                drawValue(canvas, pieLabel, f32, f33 + (calcTextHeight / 2.0f), iPieDataSet.getValueTextColor(i12));
                            }
                            if (pieEntry.getIcon() == null && iPieDataSet.isDrawIconsEnabled()) {
                                Drawable icon = pieEntry.getIcon();
                                mPPointF5 = mPPointF2;
                                float f34 = mPPointF5.y;
                                Utils.drawImage(canvas, icon, (int) (((f15 + f34) * cos) + mPPointF4.x), (int) (((f34 + f15) * f11) + mPPointF4.y + mPPointF5.x), icon.getIntrinsicWidth(), icon.getIntrinsicHeight());
                            } else {
                                mPPointF5 = mPPointF2;
                            }
                            i11++;
                            i12++;
                            mPPointF6 = mPPointF5;
                            iPieDataSet2 = iPieDataSet;
                            radius = f8;
                            entryCount = i6;
                            sliceSpace = f17;
                            yValuePosition = valuePosition;
                            valueLineColor = i8;
                            drawAngles = fArr3;
                            absoluteAngles = fArr4;
                            phaseX = f18;
                            f14 = f20;
                            xValuePosition = valuePosition2;
                            valueFormatter2 = valueFormatter;
                            mPPointF7 = mPPointF4;
                            phaseY = f19;
                        }
                    } else {
                        mPPointF4 = mPPointF3;
                    }
                    if (pieEntry.getIcon() == null) {
                    }
                    mPPointF5 = mPPointF2;
                    i11++;
                    i12++;
                    mPPointF6 = mPPointF5;
                    iPieDataSet2 = iPieDataSet;
                    radius = f8;
                    entryCount = i6;
                    sliceSpace = f17;
                    yValuePosition = valuePosition;
                    valueLineColor = i8;
                    drawAngles = fArr3;
                    absoluteAngles = fArr4;
                    phaseX = f18;
                    f14 = f20;
                    xValuePosition = valuePosition2;
                    valueFormatter2 = valueFormatter;
                    mPPointF7 = mPPointF4;
                    phaseY = f19;
                }
                fArr = drawAngles;
                fArr2 = absoluteAngles;
                f = phaseX;
                f4 = phaseY;
                f5 = f14;
                mPPointF = mPPointF7;
                f6 = radius;
                canvas2 = canvas;
                MPPointF.recycleInstance(mPPointF6);
                i9 = i11;
            } else {
                i = i10;
                list = dataSets;
                f6 = radius;
                fArr = drawAngles;
                fArr2 = absoluteAngles;
                f = phaseX;
                f4 = phaseY;
                f5 = f14;
                canvas2 = canvas5;
                mPPointF = centerCircleBox;
            }
            i10 = i + 1;
            canvas5 = canvas2;
            centerCircleBox = mPPointF;
            dataSets = list;
            radius = f6;
            drawAngles = fArr;
            absoluteAngles = fArr2;
            phaseX = f;
            phaseY = f4;
            f14 = f5;
        }
        MPPointF.recycleInstance(centerCircleBox);
        canvas.restore();
    }

    public TextPaint getPaintCenterText() {
        return this.mCenterTextPaint;
    }

    public Paint getPaintEntryLabels() {
        return this.mEntryLabelsPaint;
    }

    public Paint getPaintHole() {
        return this.mHolePaint;
    }

    public Paint getPaintTransparentCircle() {
        return this.mTransparentCirclePaint;
    }

    protected float getSliceSpace(IPieDataSet iPieDataSet) {
        if (iPieDataSet.isAutomaticallyDisableSliceSpacingEnabled() && iPieDataSet.getSliceSpace() / this.mViewPortHandler.getSmallestContentExtension() > (iPieDataSet.getYMin() / ((PieData) this.mChart.getData()).getYValueSum()) * 2.0f) {
            return 0.0f;
        }
        return iPieDataSet.getSliceSpace();
    }

    @Override
    public void initBuffers() {
    }

    public void releaseBitmap() {
        Canvas canvas = this.mBitmapCanvas;
        if (canvas != null) {
            canvas.setBitmap(null);
            this.mBitmapCanvas = null;
        }
        WeakReference<Bitmap> weakReference = this.mDrawBitmap;
        if (weakReference != null) {
            Bitmap bitmap = weakReference.get();
            if (bitmap != null) {
                bitmap.recycle();
            }
            this.mDrawBitmap.clear();
            this.mDrawBitmap = null;
        }
    }
}