正在查看： SpeedCash v6.5.1482 应用的 LineChartRenderer.java JAVA 源代码文件
本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。
页面标题
页面副标题
SpeedCash v6.5.1482 - LineChartRenderer.java 源代码
package com.github.mikephil.charting.renderer;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.drawable.Drawable;
import com.github.mikephil.charting.animation.ChartAnimator;
import com.github.mikephil.charting.data.BaseEntry;
import com.github.mikephil.charting.data.Entry;
import com.github.mikephil.charting.data.LineData;
import com.github.mikephil.charting.data.LineDataSet;
import com.github.mikephil.charting.formatter.ValueFormatter;
import com.github.mikephil.charting.highlight.Highlight;
import com.github.mikephil.charting.interfaces.dataprovider.LineDataProvider;
import com.github.mikephil.charting.interfaces.datasets.IDataSet;
import com.github.mikephil.charting.interfaces.datasets.ILineDataSet;
import com.github.mikephil.charting.renderer.BarLineScatterCandleBubbleRenderer;
import com.github.mikephil.charting.utils.MPPointD;
import com.github.mikephil.charting.utils.MPPointF;
import com.github.mikephil.charting.utils.Transformer;
import com.github.mikephil.charting.utils.Utils;
import com.github.mikephil.charting.utils.ViewPortHandler;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.List;
public class LineChartRenderer extends LineRadarRenderer {
public float[] b;
public HashMap<IDataSet, b> c;
protected Path cubicFillPath;
protected Path cubicPath;
public float[] d;
protected Canvas mBitmapCanvas;
protected Bitmap.Config mBitmapConfig;
protected LineDataProvider mChart;
protected Paint mCirclePaintInner;
protected WeakReference<Bitmap> mDrawBitmap;
protected Path mGenerateFilledPathBuffer;
public static class a {
public static final int[] a;
static {
int[] iArr = new int[LineDataSet.Mode.values().length];
a = iArr;
try {
iArr[LineDataSet.Mode.LINEAR.ordinal()] = 1;
} catch (NoSuchFieldError unused) {
}
try {
a[LineDataSet.Mode.STEPPED.ordinal()] = 2;
} catch (NoSuchFieldError unused2) {
}
try {
a[LineDataSet.Mode.CUBIC_BEZIER.ordinal()] = 3;
} catch (NoSuchFieldError unused3) {
}
try {
a[LineDataSet.Mode.HORIZONTAL_BEZIER.ordinal()] = 4;
} catch (NoSuchFieldError unused4) {
}
}
}
public LineChartRenderer(LineDataProvider lineDataProvider, ChartAnimator chartAnimator, ViewPortHandler viewPortHandler) {
super(chartAnimator, viewPortHandler);
this.mBitmapConfig = Bitmap.Config.ARGB_8888;
this.cubicPath = new Path();
this.cubicFillPath = new Path();
this.b = new float[4];
this.mGenerateFilledPathBuffer = new Path();
this.c = new HashMap<>();
this.d = new float[2];
this.mChart = lineDataProvider;
Paint paint = new Paint(1);
this.mCirclePaintInner = paint;
paint.setStyle(Paint.Style.FILL);
this.mCirclePaintInner.setColor(-1);
}
public final void b(ILineDataSet iLineDataSet, int i, int i2, Path path) {
float fillLinePosition = iLineDataSet.getFillFormatter().getFillLinePosition(iLineDataSet, this.mChart);
float phaseY = this.mAnimator.getPhaseY();
boolean z = iLineDataSet.getMode() == LineDataSet.Mode.STEPPED;
path.reset();
?? entryForIndex = iLineDataSet.getEntryForIndex(i);
path.moveTo(entryForIndex.getX(), fillLinePosition);
path.lineTo(entryForIndex.getX(), entryForIndex.getY() * phaseY);
int i3 = i + 1;
Entry entry = null;
BaseEntry baseEntry = entryForIndex;
while (i3 <= i2) {
?? entryForIndex2 = iLineDataSet.getEntryForIndex(i3);
if (z) {
path.lineTo(entryForIndex2.getX(), baseEntry.getY() * phaseY);
}
path.lineTo(entryForIndex2.getX(), entryForIndex2.getY() * phaseY);
i3++;
baseEntry = entryForIndex2;
entry = entryForIndex2;
}
if (entry != null) {
path.lineTo(entry.getX(), fillLinePosition);
}
path.close();
}
public void drawCircles(Canvas canvas) {
b bVar;
Bitmap b2;
this.mRenderPaint.setStyle(Paint.Style.FILL);
float phaseY = this.mAnimator.getPhaseY();
float[] fArr = this.d;
boolean z = false;
float f = 0.0f;
fArr[0] = 0.0f;
fArr[1] = 0.0f;
List dataSets = this.mChart.getLineData().getDataSets();
int i = 0;
while (i < dataSets.size()) {
ILineDataSet iLineDataSet = (ILineDataSet) dataSets.get(i);
if (iLineDataSet.isVisible() && iLineDataSet.isDrawCirclesEnabled() && iLineDataSet.getEntryCount() != 0) {
this.mCirclePaintInner.setColor(iLineDataSet.getCircleHoleColor());
Transformer transformer = this.mChart.getTransformer(iLineDataSet.getAxisDependency());
this.mXBounds.set(this.mChart, iLineDataSet);
float circleRadius = iLineDataSet.getCircleRadius();
float circleHoleRadius = iLineDataSet.getCircleHoleRadius();
boolean z2 = (!iLineDataSet.isDrawCircleHoleEnabled() || circleHoleRadius >= circleRadius || circleHoleRadius <= f) ? z ? 1 : 0 : true;
boolean z3 = (z2 && iLineDataSet.getCircleHoleColor() == 1122867) ? true : z ? 1 : 0;
a aVar = null;
if (this.c.containsKey(iLineDataSet)) {
bVar = this.c.get(iLineDataSet);
} else {
bVar = new b(this, aVar);
this.c.put(iLineDataSet, bVar);
}
if (bVar.c(iLineDataSet)) {
bVar.a(iLineDataSet, z2, z3);
}
BarLineScatterCandleBubbleRenderer.XBounds xBounds = this.mXBounds;
int i2 = xBounds.range;
int i3 = xBounds.min;
int i4 = i2 + i3;
?? r3 = z;
while (i3 <= i4) {
?? entryForIndex = iLineDataSet.getEntryForIndex(i3);
if (entryForIndex == 0) {
break;
}
this.d[r3] = entryForIndex.getX();
this.d[1] = entryForIndex.getY() * phaseY;
transformer.pointValuesToPixel(this.d);
if (!this.mViewPortHandler.isInBoundsRight(this.d[r3])) {
break;
}
if (this.mViewPortHandler.isInBoundsLeft(this.d[r3]) && this.mViewPortHandler.isInBoundsY(this.d[1]) && (b2 = bVar.b(i3)) != null) {
float[] fArr2 = this.d;
canvas.drawBitmap(b2, fArr2[r3] - circleRadius, fArr2[1] - circleRadius, (Paint) null);
}
i3++;
r3 = 0;
}
}
i++;
z = false;
f = 0.0f;
}
}
public void drawCubicBezier(ILineDataSet iLineDataSet) {
float phaseY = this.mAnimator.getPhaseY();
Transformer transformer = this.mChart.getTransformer(iLineDataSet.getAxisDependency());
this.mXBounds.set(this.mChart, iLineDataSet);
float cubicIntensity = iLineDataSet.getCubicIntensity();
this.cubicPath.reset();
BarLineScatterCandleBubbleRenderer.XBounds xBounds = this.mXBounds;
if (xBounds.range >= 1) {
int i = xBounds.min + 1;
T entryForIndex = iLineDataSet.getEntryForIndex(Math.max(i - 2, 0));
?? entryForIndex2 = iLineDataSet.getEntryForIndex(Math.max(i - 1, 0));
if (entryForIndex2 != 0) {
this.cubicPath.moveTo(entryForIndex2.getX(), entryForIndex2.getY() * phaseY);
int i2 = this.mXBounds.min + 1;
int i3 = -1;
Entry entry = entryForIndex2;
Entry entry2 = entryForIndex2;
Entry entry3 = entryForIndex;
while (true) {
BarLineScatterCandleBubbleRenderer.XBounds xBounds2 = this.mXBounds;
Entry entry4 = entry2;
if (i2 > xBounds2.range + xBounds2.min) {
break;
}
if (i3 != i2) {
entry4 = iLineDataSet.getEntryForIndex(i2);
}
int i4 = i2 + 1;
if (i4 < iLineDataSet.getEntryCount()) {
i2 = i4;
}
?? entryForIndex3 = iLineDataSet.getEntryForIndex(i2);
this.cubicPath.cubicTo(entry.getX() + ((entry4.getX() - entry3.getX()) * cubicIntensity), (entry.getY() + ((entry4.getY() - entry3.getY()) * cubicIntensity)) * phaseY, entry4.getX() - ((entryForIndex3.getX() - entry.getX()) * cubicIntensity), (entry4.getY() - ((entryForIndex3.getY() - entry.getY()) * cubicIntensity)) * phaseY, entry4.getX(), entry4.getY() * phaseY);
entry3 = entry;
entry = entry4;
entry2 = entryForIndex3;
int i5 = i2;
i2 = i4;
i3 = i5;
}
} else {
return;
}
}
if (iLineDataSet.isDrawFilledEnabled()) {
this.cubicFillPath.reset();
this.cubicFillPath.addPath(this.cubicPath);
drawCubicFill(this.mBitmapCanvas, iLineDataSet, this.cubicFillPath, transformer, this.mXBounds);
}
this.mRenderPaint.setColor(iLineDataSet.getColor());
this.mRenderPaint.setStyle(Paint.Style.STROKE);
transformer.pathValueToPixel(this.cubicPath);
this.mBitmapCanvas.drawPath(this.cubicPath, this.mRenderPaint);
this.mRenderPaint.setPathEffect(null);
}
public void drawCubicFill(Canvas canvas, ILineDataSet iLineDataSet, Path path, Transformer transformer, BarLineScatterCandleBubbleRenderer.XBounds xBounds) {
float fillLinePosition = iLineDataSet.getFillFormatter().getFillLinePosition(iLineDataSet, this.mChart);
path.lineTo(iLineDataSet.getEntryForIndex(xBounds.min + xBounds.range).getX(), fillLinePosition);
path.lineTo(iLineDataSet.getEntryForIndex(xBounds.min).getX(), fillLinePosition);
path.close();
transformer.pathValueToPixel(path);
Drawable fillDrawable = iLineDataSet.getFillDrawable();
if (fillDrawable != null) {
drawFilledPath(canvas, path, fillDrawable);
} else {
drawFilledPath(canvas, path, iLineDataSet.getFillColor(), iLineDataSet.getFillAlpha());
}
}
@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, this.mBitmapConfig);
this.mDrawBitmap = new WeakReference<>(bitmap);
this.mBitmapCanvas = new Canvas(bitmap);
}
bitmap.eraseColor(0);
for (T t : this.mChart.getLineData().getDataSets()) {
if (t.isVisible()) {
drawDataSet(canvas, t);
}
}
canvas.drawBitmap(bitmap, 0.0f, 0.0f, this.mRenderPaint);
}
public void drawDataSet(Canvas canvas, ILineDataSet iLineDataSet) {
if (iLineDataSet.getEntryCount() < 1) {
return;
}
this.mRenderPaint.setStrokeWidth(iLineDataSet.getLineWidth());
this.mRenderPaint.setPathEffect(iLineDataSet.getDashPathEffect());
int i = a.a[iLineDataSet.getMode().ordinal()];
if (i == 3) {
drawCubicBezier(iLineDataSet);
} else if (i != 4) {
drawLinear(canvas, iLineDataSet);
} else {
drawHorizontalBezier(iLineDataSet);
}
this.mRenderPaint.setPathEffect(null);
}
@Override
public void drawExtras(Canvas canvas) {
drawCircles(canvas);
}
@Override
public void drawHighlighted(Canvas canvas, Highlight[] highlightArr) {
LineData lineData = this.mChart.getLineData();
for (Highlight highlight : highlightArr) {
ILineDataSet iLineDataSet = (ILineDataSet) lineData.getDataSetByIndex(highlight.getDataSetIndex());
if (iLineDataSet != null && iLineDataSet.isHighlightEnabled()) {
?? entryForXValue = iLineDataSet.getEntryForXValue(highlight.getX(), highlight.getY());
if (isInBoundsX(entryForXValue, iLineDataSet)) {
MPPointD pixelForValues = this.mChart.getTransformer(iLineDataSet.getAxisDependency()).getPixelForValues(entryForXValue.getX(), entryForXValue.getY() * this.mAnimator.getPhaseY());
highlight.setDraw((float) pixelForValues.x, (float) pixelForValues.y);
drawHighlightLines(canvas, (float) pixelForValues.x, (float) pixelForValues.y, iLineDataSet);
}
}
}
}
public void drawHorizontalBezier(ILineDataSet iLineDataSet) {
float phaseY = this.mAnimator.getPhaseY();
Transformer transformer = this.mChart.getTransformer(iLineDataSet.getAxisDependency());
this.mXBounds.set(this.mChart, iLineDataSet);
this.cubicPath.reset();
BarLineScatterCandleBubbleRenderer.XBounds xBounds = this.mXBounds;
if (xBounds.range >= 1) {
?? entryForIndex = iLineDataSet.getEntryForIndex(xBounds.min);
this.cubicPath.moveTo(entryForIndex.getX(), entryForIndex.getY() * phaseY);
int i = this.mXBounds.min + 1;
Entry entry = entryForIndex;
while (true) {
BarLineScatterCandleBubbleRenderer.XBounds xBounds2 = this.mXBounds;
if (i > xBounds2.range + xBounds2.min) {
break;
}
?? entryForIndex2 = iLineDataSet.getEntryForIndex(i);
float x = entry.getX() + ((entryForIndex2.getX() - entry.getX()) / 2.0f);
this.cubicPath.cubicTo(x, entry.getY() * phaseY, x, entryForIndex2.getY() * phaseY, entryForIndex2.getX(), entryForIndex2.getY() * phaseY);
i++;
entry = entryForIndex2;
}
}
if (iLineDataSet.isDrawFilledEnabled()) {
this.cubicFillPath.reset();
this.cubicFillPath.addPath(this.cubicPath);
drawCubicFill(this.mBitmapCanvas, iLineDataSet, this.cubicFillPath, transformer, this.mXBounds);
}
this.mRenderPaint.setColor(iLineDataSet.getColor());
this.mRenderPaint.setStyle(Paint.Style.STROKE);
transformer.pathValueToPixel(this.cubicPath);
this.mBitmapCanvas.drawPath(this.cubicPath, this.mRenderPaint);
this.mRenderPaint.setPathEffect(null);
}
public void drawLinear(Canvas canvas, ILineDataSet iLineDataSet) {
int entryCount = iLineDataSet.getEntryCount();
boolean z = iLineDataSet.getMode() == LineDataSet.Mode.STEPPED;
int i = z ? 4 : 2;
Transformer transformer = this.mChart.getTransformer(iLineDataSet.getAxisDependency());
float phaseY = this.mAnimator.getPhaseY();
this.mRenderPaint.setStyle(Paint.Style.STROKE);
Canvas canvas2 = iLineDataSet.isDashedLineEnabled() ? this.mBitmapCanvas : canvas;
this.mXBounds.set(this.mChart, iLineDataSet);
if (iLineDataSet.isDrawFilledEnabled() && entryCount > 0) {
drawLinearFill(canvas, iLineDataSet, transformer, this.mXBounds);
}
if (iLineDataSet.getColors().size() > 1) {
int i2 = i * 2;
if (this.b.length <= i2) {
this.b = new float[i * 4];
}
int i3 = this.mXBounds.min;
while (true) {
BarLineScatterCandleBubbleRenderer.XBounds xBounds = this.mXBounds;
if (i3 > xBounds.range + xBounds.min) {
break;
}
?? entryForIndex = iLineDataSet.getEntryForIndex(i3);
if (entryForIndex != 0) {
this.b[0] = entryForIndex.getX();
this.b[1] = entryForIndex.getY() * phaseY;
if (i3 < this.mXBounds.max) {
?? entryForIndex2 = iLineDataSet.getEntryForIndex(i3 + 1);
if (entryForIndex2 == 0) {
break;
}
if (z) {
this.b[2] = entryForIndex2.getX();
float[] fArr = this.b;
float f = fArr[1];
fArr[3] = f;
fArr[4] = fArr[2];
fArr[5] = f;
fArr[6] = entryForIndex2.getX();
this.b[7] = entryForIndex2.getY() * phaseY;
} else {
this.b[2] = entryForIndex2.getX();
this.b[3] = entryForIndex2.getY() * phaseY;
}
} else {
float[] fArr2 = this.b;
fArr2[2] = fArr2[0];
fArr2[3] = fArr2[1];
}
transformer.pointValuesToPixel(this.b);
if (!this.mViewPortHandler.isInBoundsRight(this.b[0])) {
break;
}
if (this.mViewPortHandler.isInBoundsLeft(this.b[2]) && (this.mViewPortHandler.isInBoundsTop(this.b[1]) || this.mViewPortHandler.isInBoundsBottom(this.b[3]))) {
this.mRenderPaint.setColor(iLineDataSet.getColor(i3));
canvas2.drawLines(this.b, 0, i2, this.mRenderPaint);
}
}
i3++;
}
} else {
int i4 = entryCount * i;
if (this.b.length < Math.max(i4, i) * 2) {
this.b = new float[Math.max(i4, i) * 4];
}
if (iLineDataSet.getEntryForIndex(this.mXBounds.min) != 0) {
int i5 = this.mXBounds.min;
int i6 = 0;
while (true) {
BarLineScatterCandleBubbleRenderer.XBounds xBounds2 = this.mXBounds;
if (i5 > xBounds2.range + xBounds2.min) {
break;
}
?? entryForIndex3 = iLineDataSet.getEntryForIndex(i5 == 0 ? 0 : i5 - 1);
?? entryForIndex4 = iLineDataSet.getEntryForIndex(i5);
if (entryForIndex3 != 0 && entryForIndex4 != 0) {
int i7 = i6 + 1;
this.b[i6] = entryForIndex3.getX();
int i8 = i7 + 1;
this.b[i7] = entryForIndex3.getY() * phaseY;
if (z) {
int i9 = i8 + 1;
this.b[i8] = entryForIndex4.getX();
int i10 = i9 + 1;
this.b[i9] = entryForIndex3.getY() * phaseY;
int i11 = i10 + 1;
this.b[i10] = entryForIndex4.getX();
i8 = i11 + 1;
this.b[i11] = entryForIndex3.getY() * phaseY;
}
int i12 = i8 + 1;
this.b[i8] = entryForIndex4.getX();
this.b[i12] = entryForIndex4.getY() * phaseY;
i6 = i12 + 1;
}
i5++;
}
if (i6 > 0) {
transformer.pointValuesToPixel(this.b);
int max = Math.max((this.mXBounds.range + 1) * i, i) * 2;
this.mRenderPaint.setColor(iLineDataSet.getColor());
canvas2.drawLines(this.b, 0, max, this.mRenderPaint);
}
}
}
this.mRenderPaint.setPathEffect(null);
}
public void drawLinearFill(Canvas canvas, ILineDataSet iLineDataSet, Transformer transformer, BarLineScatterCandleBubbleRenderer.XBounds xBounds) {
int i;
int i2;
Path path = this.mGenerateFilledPathBuffer;
int i3 = xBounds.min;
int i4 = xBounds.range + i3;
int i5 = 0;
do {
i = (i5 * 128) + i3;
i2 = i + 128;
if (i2 > i4) {
i2 = i4;
}
if (i <= i2) {
b(iLineDataSet, i, i2, path);
transformer.pathValueToPixel(path);
Drawable fillDrawable = iLineDataSet.getFillDrawable();
if (fillDrawable != null) {
drawFilledPath(canvas, path, fillDrawable);
} else {
drawFilledPath(canvas, path, iLineDataSet.getFillColor(), iLineDataSet.getFillAlpha());
}
}
i5++;
} while (i <= i2);
}
@Override
public void drawValue(Canvas canvas, String str, float f, float f2, int i) {
this.mValuePaint.setColor(i);
canvas.drawText(str, f, f2, this.mValuePaint);
}
@Override
public void drawValues(Canvas canvas) {
int i;
ILineDataSet iLineDataSet;
Entry entry;
if (isDrawingValuesAllowed(this.mChart)) {
List<T> dataSets = this.mChart.getLineData().getDataSets();
for (int i2 = 0; i2 < dataSets.size(); i2++) {
ILineDataSet iLineDataSet2 = (ILineDataSet) dataSets.get(i2);
if (shouldDrawValues(iLineDataSet2) && iLineDataSet2.getEntryCount() >= 1) {
applyValueTextStyle(iLineDataSet2);
Transformer transformer = this.mChart.getTransformer(iLineDataSet2.getAxisDependency());
int circleRadius = (int) (iLineDataSet2.getCircleRadius() * 1.75f);
if (!iLineDataSet2.isDrawCirclesEnabled()) {
circleRadius /= 2;
}
int i3 = circleRadius;
this.mXBounds.set(this.mChart, iLineDataSet2);
float phaseX = this.mAnimator.getPhaseX();
float phaseY = this.mAnimator.getPhaseY();
BarLineScatterCandleBubbleRenderer.XBounds xBounds = this.mXBounds;
float[] generateTransformedValuesLine = transformer.generateTransformedValuesLine(iLineDataSet2, phaseX, phaseY, xBounds.min, xBounds.max);
ValueFormatter valueFormatter = iLineDataSet2.getValueFormatter();
MPPointF mPPointF = MPPointF.getInstance(iLineDataSet2.getIconsOffset());
mPPointF.x = Utils.convertDpToPixel(mPPointF.x);
mPPointF.y = Utils.convertDpToPixel(mPPointF.y);
int i4 = 0;
while (i4 < generateTransformedValuesLine.length) {
float f = generateTransformedValuesLine[i4];
float f2 = generateTransformedValuesLine[i4 + 1];
if (!this.mViewPortHandler.isInBoundsRight(f)) {
break;
}
if (this.mViewPortHandler.isInBoundsLeft(f) && this.mViewPortHandler.isInBoundsY(f2)) {
int i5 = i4 / 2;
Entry entryForIndex = iLineDataSet2.getEntryForIndex(this.mXBounds.min + i5);
if (iLineDataSet2.isDrawValuesEnabled()) {
entry = entryForIndex;
i = i3;
iLineDataSet = iLineDataSet2;
drawValue(canvas, valueFormatter.getPointLabel(entryForIndex), f, f2 - i3, iLineDataSet2.getValueTextColor(i5));
} else {
entry = entryForIndex;
i = i3;
iLineDataSet = iLineDataSet2;
}
if (entry.getIcon() != null && iLineDataSet.isDrawIconsEnabled()) {
Drawable icon = entry.getIcon();
Utils.drawImage(canvas, icon, (int) (f + mPPointF.x), (int) (f2 + mPPointF.y), icon.getIntrinsicWidth(), icon.getIntrinsicHeight());
}
} else {
i = i3;
iLineDataSet = iLineDataSet2;
}
i4 += 2;
iLineDataSet2 = iLineDataSet;
i3 = i;
}
MPPointF.recycleInstance(mPPointF);
}
}
}
}
public Bitmap.Config getBitmapConfig() {
return this.mBitmapConfig;
}
@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;
}
}
public void setBitmapConfig(Bitmap.Config config) {
this.mBitmapConfig = config;
releaseBitmap();
}
public class b {
public Path a;
public Bitmap[] b;
public b() {
this.a = new Path();
}
public void a(ILineDataSet iLineDataSet, boolean z, boolean z2) {
int circleColorCount = iLineDataSet.getCircleColorCount();
float circleRadius = iLineDataSet.getCircleRadius();
float circleHoleRadius = iLineDataSet.getCircleHoleRadius();
for (int i = 0; i < circleColorCount; i++) {
int i2 = (int) (circleRadius * 2.1d);
Bitmap createBitmap = Bitmap.createBitmap(i2, i2, Bitmap.Config.ARGB_4444);
Canvas canvas = new Canvas(createBitmap);
this.b[i] = createBitmap;
LineChartRenderer.this.mRenderPaint.setColor(iLineDataSet.getCircleColor(i));
if (z2) {
this.a.reset();
this.a.addCircle(circleRadius, circleRadius, circleRadius, Path.Direction.CW);
this.a.addCircle(circleRadius, circleRadius, circleHoleRadius, Path.Direction.CCW);
canvas.drawPath(this.a, LineChartRenderer.this.mRenderPaint);
} else {
canvas.drawCircle(circleRadius, circleRadius, circleRadius, LineChartRenderer.this.mRenderPaint);
if (z) {
canvas.drawCircle(circleRadius, circleRadius, circleHoleRadius, LineChartRenderer.this.mCirclePaintInner);
}
}
}
}
public Bitmap b(int i) {
Bitmap[] bitmapArr = this.b;
return bitmapArr[i % bitmapArr.length];
}
public boolean c(ILineDataSet iLineDataSet) {
int circleColorCount = iLineDataSet.getCircleColorCount();
Bitmap[] bitmapArr = this.b;
if (bitmapArr == null) {
this.b = new Bitmap[circleColorCount];
return true;
}
if (bitmapArr.length == circleColorCount) {
return false;
}
this.b = new Bitmap[circleColorCount];
return true;
}
public b(LineChartRenderer lineChartRenderer, a aVar) {
this();
}
}
}