Mantra Counter v25.01 - PieChartRenderer.java 源代码

package lecho.lib.hellocharts.renderer;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PointF;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.text.TextUtils;
import java.util.Iterator;
import lecho.lib.hellocharts.formatter.PieChartValueFormatter;
import lecho.lib.hellocharts.model.ColumnChartData;
import lecho.lib.hellocharts.model.PieChartData;
import lecho.lib.hellocharts.model.SelectedValue;
import lecho.lib.hellocharts.model.SliceValue;
import lecho.lib.hellocharts.model.Viewport;
import lecho.lib.hellocharts.provider.PieChartDataProvider;
import lecho.lib.hellocharts.util.ChartUtils;
import lecho.lib.hellocharts.view.Chart;

public class PieChartRenderer extends AbstractChartRenderer {
    private static final float DEFAULT_LABEL_INSIDE_RADIUS_FACTOR = 0.7f;
    private static final float DEFAULT_LABEL_OUTSIDE_RADIUS_FACTOR = 1.0f;
    private static final int DEFAULT_START_ROTATION = 45;
    private static final int DEFAULT_TOUCH_ADDITIONAL_DP = 8;
    private static final float MAX_WIDTH_HEIGHT = 100.0f;
    private static final int MODE_DRAW = 0;
    private static final int MODE_HIGHLIGHT = 1;
    private Paint centerCirclePaint;
    private float centerCircleScale;
    private Paint.FontMetricsInt centerCircleText1FontMetrics;
    private Paint centerCircleText1Paint;
    private Paint.FontMetricsInt centerCircleText2FontMetrics;
    private Paint centerCircleText2Paint;
    private float circleFillRatio;
    private PieChartDataProvider dataProvider;
    private RectF drawCircleOval;
    private boolean hasCenterCircle;
    private boolean hasLabels;
    private boolean hasLabelsOnlyForSelected;
    private boolean hasLabelsOutside;
    private float maxSum;
    private RectF originCircleOval;
    private int rotation;
    private Paint separationLinesPaint;
    private Paint slicePaint;
    private PointF sliceVector;
    private Bitmap softwareBitmap;
    private Canvas softwareCanvas;
    private Viewport tempMaximumViewport;
    private int touchAdditional;
    private PieChartValueFormatter valueFormatter;

    @Override
    public void drawUnclipped(Canvas canvas) {
    }

    public PieChartRenderer(Context context, Chart chart, PieChartDataProvider pieChartDataProvider) {
        super(context, chart);
        this.rotation = DEFAULT_START_ROTATION;
        this.slicePaint = new Paint();
        this.originCircleOval = new RectF();
        this.drawCircleOval = new RectF();
        this.sliceVector = new PointF();
        this.circleFillRatio = 1.0f;
        this.centerCirclePaint = new Paint();
        this.centerCircleText1Paint = new Paint();
        this.centerCircleText1FontMetrics = new Paint.FontMetricsInt();
        this.centerCircleText2Paint = new Paint();
        this.centerCircleText2FontMetrics = new Paint.FontMetricsInt();
        this.separationLinesPaint = new Paint();
        this.tempMaximumViewport = new Viewport();
        this.softwareCanvas = new Canvas();
        this.dataProvider = pieChartDataProvider;
        this.touchAdditional = ChartUtils.dp2px(this.density, 8);
        this.slicePaint.setAntiAlias(true);
        this.slicePaint.setStyle(Paint.Style.FILL);
        this.centerCirclePaint.setAntiAlias(true);
        this.centerCirclePaint.setStyle(Paint.Style.FILL);
        this.centerCirclePaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));
        this.centerCircleText1Paint.setAntiAlias(true);
        this.centerCircleText1Paint.setTextAlign(Paint.Align.CENTER);
        this.centerCircleText2Paint.setAntiAlias(true);
        this.centerCircleText2Paint.setTextAlign(Paint.Align.CENTER);
        this.separationLinesPaint.setAntiAlias(true);
        this.separationLinesPaint.setStyle(Paint.Style.STROKE);
        this.separationLinesPaint.setStrokeCap(Paint.Cap.ROUND);
        this.separationLinesPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
        this.separationLinesPaint.setColor(0);
    }

    @Override
    public void onChartSizeChanged() {
        calculateCircleOval();
        if (this.computator.getChartWidth() <= 0 || this.computator.getChartHeight() <= 0) {
            return;
        }
        Bitmap createBitmap = Bitmap.createBitmap(this.computator.getChartWidth(), this.computator.getChartHeight(), Bitmap.Config.ARGB_8888);
        this.softwareBitmap = createBitmap;
        this.softwareCanvas.setBitmap(createBitmap);
    }

    @Override
    public void onChartDataChanged() {
        super.onChartDataChanged();
        PieChartData pieChartData = this.dataProvider.getPieChartData();
        this.hasLabelsOutside = pieChartData.hasLabelsOutside();
        this.hasLabels = pieChartData.hasLabels();
        this.hasLabelsOnlyForSelected = pieChartData.hasLabelsOnlyForSelected();
        this.valueFormatter = pieChartData.getFormatter();
        this.hasCenterCircle = pieChartData.hasCenterCircle();
        this.centerCircleScale = pieChartData.getCenterCircleScale();
        this.centerCirclePaint.setColor(pieChartData.getCenterCircleColor());
        if (pieChartData.getCenterText1Typeface() != null) {
            this.centerCircleText1Paint.setTypeface(pieChartData.getCenterText1Typeface());
        }
        this.centerCircleText1Paint.setTextSize(ChartUtils.sp2px(this.scaledDensity, pieChartData.getCenterText1FontSize()));
        this.centerCircleText1Paint.setColor(pieChartData.getCenterText1Color());
        this.centerCircleText1Paint.getFontMetricsInt(this.centerCircleText1FontMetrics);
        if (pieChartData.getCenterText2Typeface() != null) {
            this.centerCircleText2Paint.setTypeface(pieChartData.getCenterText2Typeface());
        }
        this.centerCircleText2Paint.setTextSize(ChartUtils.sp2px(this.scaledDensity, pieChartData.getCenterText2FontSize()));
        this.centerCircleText2Paint.setColor(pieChartData.getCenterText2Color());
        this.centerCircleText2Paint.getFontMetricsInt(this.centerCircleText2FontMetrics);
        onChartViewportChanged();
    }

    @Override
    public void onChartViewportChanged() {
        if (this.isViewportCalculationEnabled) {
            calculateMaxViewport();
            this.computator.setMaxViewport(this.tempMaximumViewport);
            this.computator.setCurrentViewport(this.computator.getMaximumViewport());
        }
    }

    @Override
    public void draw(Canvas canvas) {
        Canvas canvas2;
        if (this.softwareBitmap != null) {
            canvas2 = this.softwareCanvas;
            canvas2.drawColor(0, PorterDuff.Mode.CLEAR);
        } else {
            canvas2 = canvas;
        }
        drawSlices(canvas2);
        drawSeparationLines(canvas2);
        if (this.hasCenterCircle) {
            drawCenterCircle(canvas2);
        }
        drawLabels(canvas2);
        Bitmap bitmap = this.softwareBitmap;
        if (bitmap != null) {
            canvas.drawBitmap(bitmap, ColumnChartData.DEFAULT_BASE_VALUE, ColumnChartData.DEFAULT_BASE_VALUE, (Paint) null);
        }
    }

    @Override
    public boolean checkTouch(float f, float f2) {
        this.selectedValue.clear();
        PieChartData pieChartData = this.dataProvider.getPieChartData();
        float centerX = this.originCircleOval.centerX();
        float centerY = this.originCircleOval.centerY();
        float width = this.originCircleOval.width() / 2.0f;
        this.sliceVector.set(f - centerX, f2 - centerY);
        int i = 0;
        if (this.sliceVector.length() > this.touchAdditional + width) {
            return false;
        }
        if (pieChartData.hasCenterCircle() && this.sliceVector.length() < width * pieChartData.getCenterCircleScale()) {
            return false;
        }
        float pointToAngle = ((pointToAngle(f, f2, centerX, centerY) - this.rotation) + 360.0f) % 360.0f;
        float f3 = 360.0f / this.maxSum;
        Iterator<SliceValue> it = pieChartData.getValues().iterator();
        float f4 = ColumnChartData.DEFAULT_BASE_VALUE;
        while (it.hasNext()) {
            float abs = Math.abs(it.next().getValue()) * f3;
            if (pointToAngle >= f4) {
                this.selectedValue.set(i, i, SelectedValue.SelectedValueType.NONE);
            }
            f4 += abs;
            i++;
        }
        return isTouched();
    }

    private void drawCenterCircle(Canvas canvas) {
        PieChartData pieChartData = this.dataProvider.getPieChartData();
        float width = (this.originCircleOval.width() / 2.0f) * pieChartData.getCenterCircleScale();
        float centerX = this.originCircleOval.centerX();
        float centerY = this.originCircleOval.centerY();
        canvas.drawCircle(centerX, centerY, width, this.centerCirclePaint);
        if (TextUtils.isEmpty(pieChartData.getCenterText1())) {
            return;
        }
        int abs = Math.abs(this.centerCircleText1FontMetrics.ascent);
        if (!TextUtils.isEmpty(pieChartData.getCenterText2())) {
            int abs2 = Math.abs(this.centerCircleText2FontMetrics.ascent);
            canvas.drawText(pieChartData.getCenterText1(), centerX, centerY - (abs * 0.2f), this.centerCircleText1Paint);
            canvas.drawText(pieChartData.getCenterText2(), centerX, centerY + abs2, this.centerCircleText2Paint);
            return;
        }
        canvas.drawText(pieChartData.getCenterText1(), centerX, centerY + (abs / 4), this.centerCircleText1Paint);
    }

    private void drawSlices(Canvas canvas) {
        PieChartData pieChartData = this.dataProvider.getPieChartData();
        float f = 360.0f / this.maxSum;
        float f2 = this.rotation;
        int i = 0;
        for (SliceValue sliceValue : pieChartData.getValues()) {
            float abs = Math.abs(sliceValue.getValue()) * f;
            if (isTouched() && this.selectedValue.getFirstIndex() == i) {
                drawSlice(canvas, sliceValue, f2, abs, 1);
            } else {
                drawSlice(canvas, sliceValue, f2, abs, 0);
            }
            f2 += abs;
            i++;
        }
    }

    private void drawSeparationLines(Canvas canvas) {
        int dp2px;
        PieChartData pieChartData = this.dataProvider.getPieChartData();
        if (pieChartData.getValues().size() >= 2 && (dp2px = ChartUtils.dp2px(this.density, pieChartData.getSlicesSpacing())) >= 1) {
            float f = 360.0f / this.maxSum;
            float f2 = this.rotation;
            float width = this.originCircleOval.width() / 2.0f;
            this.separationLinesPaint.setStrokeWidth(dp2px);
            Iterator<SliceValue> it = pieChartData.getValues().iterator();
            while (it.hasNext()) {
                float abs = Math.abs(it.next().getValue()) * f;
                double d = f2;
                this.sliceVector.set((float) Math.cos(Math.toRadians(d)), (float) Math.sin(Math.toRadians(d)));
                normalizeVector(this.sliceVector);
                canvas.drawLine(this.originCircleOval.centerX(), this.originCircleOval.centerY(), (this.sliceVector.x * (this.touchAdditional + width)) + this.originCircleOval.centerX(), (this.sliceVector.y * (this.touchAdditional + width)) + this.originCircleOval.centerY(), this.separationLinesPaint);
                f2 += abs;
            }
        }
    }

    public void drawLabels(Canvas canvas) {
        PieChartData pieChartData = this.dataProvider.getPieChartData();
        float f = 360.0f / this.maxSum;
        float f2 = this.rotation;
        int i = 0;
        for (SliceValue sliceValue : pieChartData.getValues()) {
            float abs = Math.abs(sliceValue.getValue()) * f;
            if (isTouched()) {
                if (this.hasLabels) {
                    drawLabel(canvas, sliceValue, f2, abs);
                } else if (this.hasLabelsOnlyForSelected && this.selectedValue.getFirstIndex() == i) {
                    drawLabel(canvas, sliceValue, f2, abs);
                }
            } else if (this.hasLabels) {
                drawLabel(canvas, sliceValue, f2, abs);
            }
            f2 += abs;
            i++;
        }
    }

    private void drawSlice(Canvas canvas, SliceValue sliceValue, float f, float f2, int i) {
        double d = (f2 / 2.0f) + f;
        this.sliceVector.set((float) Math.cos(Math.toRadians(d)), (float) Math.sin(Math.toRadians(d)));
        normalizeVector(this.sliceVector);
        this.drawCircleOval.set(this.originCircleOval);
        if (1 == i) {
            RectF rectF = this.drawCircleOval;
            int i2 = this.touchAdditional;
            rectF.inset(-i2, -i2);
            this.slicePaint.setColor(sliceValue.getDarkenColor());
            canvas.drawArc(this.drawCircleOval, f, f2, true, this.slicePaint);
            return;
        }
        this.slicePaint.setColor(sliceValue.getColor());
        canvas.drawArc(this.drawCircleOval, f, f2, true, this.slicePaint);
    }

    private void drawLabel(android.graphics.Canvas r9, lecho.lib.hellocharts.model.SliceValue r10, float r11, float r12) {
        throw new UnsupportedOperationException("Method not decompiled: lecho.lib.hellocharts.renderer.PieChartRenderer.drawLabel(android.graphics.Canvas, lecho.lib.hellocharts.model.SliceValue, float, float):void");
    }

    private void normalizeVector(PointF pointF) {
        float length = pointF.length();
        pointF.set(pointF.x / length, pointF.y / length);
    }

    private float pointToAngle(float f, float f2, float f3, float f4) {
        return ((((float) Math.toDegrees(Math.atan2(-(f - f3), f2 - f4))) + 360.0f) % 360.0f) + 90.0f;
    }

    private void calculateCircleOval() {
        Rect contentRectMinusAllMargins = this.computator.getContentRectMinusAllMargins();
        float min = Math.min(contentRectMinusAllMargins.width() / 2.0f, contentRectMinusAllMargins.height() / 2.0f);
        float centerX = contentRectMinusAllMargins.centerX();
        float centerY = contentRectMinusAllMargins.centerY();
        int i = this.touchAdditional;
        this.originCircleOval.set((centerX - min) + i, (centerY - min) + i, (centerX + min) - i, (centerY + min) - i);
        float width = this.originCircleOval.width() * 0.5f * (1.0f - this.circleFillRatio);
        this.originCircleOval.inset(width, width);
    }

    private void calculateMaxViewport() {
        this.tempMaximumViewport.set(ColumnChartData.DEFAULT_BASE_VALUE, MAX_WIDTH_HEIGHT, MAX_WIDTH_HEIGHT, ColumnChartData.DEFAULT_BASE_VALUE);
        this.maxSum = ColumnChartData.DEFAULT_BASE_VALUE;
        Iterator<SliceValue> it = this.dataProvider.getPieChartData().getValues().iterator();
        while (it.hasNext()) {
            this.maxSum += Math.abs(it.next().getValue());
        }
    }

    public RectF getCircleOval() {
        return this.originCircleOval;
    }

    public void setCircleOval(RectF rectF) {
        this.originCircleOval = rectF;
    }

    public int getChartRotation() {
        return this.rotation;
    }

    public void setChartRotation(int i) {
        this.rotation = ((i % 360) + 360) % 360;
    }

    public SliceValue getValueForAngle(int i, SelectedValue selectedValue) {
        PieChartData pieChartData = this.dataProvider.getPieChartData();
        float f = ((i - this.rotation) + 360.0f) % 360.0f;
        float f2 = 360.0f / this.maxSum;
        float f3 = ColumnChartData.DEFAULT_BASE_VALUE;
        int i2 = 0;
        for (SliceValue sliceValue : pieChartData.getValues()) {
            float abs = Math.abs(sliceValue.getValue()) * f2;
            if (f >= f3) {
                if (selectedValue != null) {
                    selectedValue.set(i2, i2, SelectedValue.SelectedValueType.NONE);
                }
                return sliceValue;
            }
            f3 += abs;
            i2++;
        }
        return null;
    }

    public float getCircleFillRatio() {
        return this.circleFillRatio;
    }

    public void setCircleFillRatio(float r3) {
        throw new UnsupportedOperationException("Method not decompiled: lecho.lib.hellocharts.renderer.PieChartRenderer.setCircleFillRatio(float):void");
    }
}