正在查看： WeatherSense v1.8.9 应用的 LineChartRenderer.java JAVA 源代码文件
本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。
页面标题
页面副标题
WeatherSense v1.8.9 - 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.Entry;
import com.github.mikephil.charting.data.LineData;
import com.github.mikephil.charting.data.LineDataSet;
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.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
public class LineChartRenderer extends LineRadarRenderer {
protected Path cubicFillPath;
protected Path cubicPath;
protected Canvas mBitmapCanvas;
protected Bitmap.Config mBitmapConfig;
protected LineDataProvider mChart;
protected Paint mCirclePaintInner;
private float[] mCirclesBuffer;
protected WeakReference<Bitmap> mDrawBitmap;
protected Path mGenerateFilledPathBuffer;
private HashMap<IDataSet, DataSetImageCache> mImageCaches;
private float[] mLineBuffer;
@Override
public void initBuffers() {
}
public LineChartRenderer(LineDataProvider chart, ChartAnimator animator, ViewPortHandler viewPortHandler, Boolean drawOtherType) {
super(animator, viewPortHandler);
this.mBitmapConfig = Bitmap.Config.ARGB_8888;
this.cubicPath = new Path();
this.cubicFillPath = new Path();
this.mLineBuffer = new float[4];
this.mGenerateFilledPathBuffer = new Path();
this.mImageCaches = new HashMap<>();
this.mCirclesBuffer = new float[2];
this.mChart = chart;
Paint paint = new Paint(1);
this.mCirclePaintInner = paint;
paint.setStyle(Paint.Style.FILL);
this.mCirclePaintInner.setColor(-1);
this.drawOtherType = drawOtherType;
}
@Override
public void drawData(Canvas c) {
int chartWidth = (int) this.mViewPortHandler.getChartWidth();
int chartHeight = (int) this.mViewPortHandler.getChartHeight();
WeakReference<Bitmap> weakReference = this.mDrawBitmap;
if (weakReference == null || weakReference.get().getWidth() != chartWidth || this.mDrawBitmap.get().getHeight() != chartHeight) {
if (chartWidth <= 0 || chartHeight <= 0) {
return;
}
this.mDrawBitmap = new WeakReference<>(Bitmap.createBitmap(chartWidth, chartHeight, this.mBitmapConfig));
this.mBitmapCanvas = new Canvas(this.mDrawBitmap.get());
}
this.mDrawBitmap.get().eraseColor(0);
for (T t : this.mChart.getLineData().getDataSets()) {
if (t.isVisible()) {
drawDataSet(c, t);
}
}
c.drawBitmap(this.mDrawBitmap.get(), 0.0f, 0.0f, this.mRenderPaint);
}
protected void drawDataSet(Canvas c, ILineDataSet dataSet) {
if (dataSet.getEntryCount() < 1) {
return;
}
this.mRenderPaint.setStrokeWidth(dataSet.getLineWidth());
this.mRenderPaint.setPathEffect(dataSet.getDashPathEffect());
int i = AnonymousClass1.$SwitchMap$com$github$mikephil$charting$data$LineDataSet$Mode[dataSet.getMode().ordinal()];
if (i == 3) {
drawCubicBezier(dataSet);
} else if (i != 4) {
drawLinear(c, dataSet);
} else {
drawHorizontalBezier(dataSet);
}
this.mRenderPaint.setPathEffect(null);
}
static class AnonymousClass1 {
static final int[] $SwitchMap$com$github$mikephil$charting$data$LineDataSet$Mode;
static {
int[] iArr = new int[LineDataSet.Mode.values().length];
$SwitchMap$com$github$mikephil$charting$data$LineDataSet$Mode = iArr;
try {
iArr[LineDataSet.Mode.LINEAR.ordinal()] = 1;
} catch (NoSuchFieldError unused) {
}
try {
$SwitchMap$com$github$mikephil$charting$data$LineDataSet$Mode[LineDataSet.Mode.STEPPED.ordinal()] = 2;
} catch (NoSuchFieldError unused2) {
}
try {
$SwitchMap$com$github$mikephil$charting$data$LineDataSet$Mode[LineDataSet.Mode.CUBIC_BEZIER.ordinal()] = 3;
} catch (NoSuchFieldError unused3) {
}
try {
$SwitchMap$com$github$mikephil$charting$data$LineDataSet$Mode[LineDataSet.Mode.HORIZONTAL_BEZIER.ordinal()] = 4;
} catch (NoSuchFieldError unused4) {
}
}
}
protected 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();
if (this.mXBounds.range >= 1) {
?? entryForIndex = iLineDataSet.getEntryForIndex(this.mXBounds.min);
this.cubicPath.moveTo(entryForIndex.getX(), entryForIndex.getY() * phaseY);
int i = this.mXBounds.min + 1;
Entry entry = entryForIndex;
while (i <= this.mXBounds.range + this.mXBounds.min) {
?? 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);
}
protected void drawCubicBezier(ILineDataSet iLineDataSet) {
Math.max(0.0f, Math.min(1.0f, this.mAnimator.getPhaseX()));
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();
if (this.mXBounds.range >= 1) {
int i = this.mXBounds.min + 1;
int i2 = this.mXBounds.min;
int i3 = this.mXBounds.range;
T entryForIndex = iLineDataSet.getEntryForIndex(Math.max(i - 2, 0));
?? entryForIndex2 = iLineDataSet.getEntryForIndex(Math.max(i - 1, 0));
int i4 = -1;
if (entryForIndex2 != 0) {
this.cubicPath.moveTo(entryForIndex2.getX(), entryForIndex2.getY() * phaseY);
int i5 = this.mXBounds.min + 1;
Entry entry = entryForIndex2;
Entry entry2 = entryForIndex2;
Entry entry3 = entryForIndex;
while (true) {
Entry entry4 = entry2;
if (i5 > this.mXBounds.range + this.mXBounds.min) {
break;
}
if (i4 != i5) {
entry4 = iLineDataSet.getEntryForIndex(i5);
}
int i6 = i5 + 1;
if (i6 < iLineDataSet.getEntryCount()) {
i5 = i6;
}
?? entryForIndex3 = iLineDataSet.getEntryForIndex(i5);
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 i7 = i5;
i5 = i6;
i4 = i7;
}
} 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);
}
protected void drawCubicFill(Canvas c, ILineDataSet dataSet, Path spline, Transformer trans, BarLineScatterCandleBubbleRenderer.XBounds bounds) {
float fillLinePosition = dataSet.getFillFormatter().getFillLinePosition(dataSet, this.mChart);
spline.lineTo(dataSet.getEntryForIndex(bounds.min + bounds.range).getX(), fillLinePosition);
spline.lineTo(dataSet.getEntryForIndex(bounds.min).getX(), fillLinePosition);
spline.close();
trans.pathValueToPixel(spline);
Drawable fillDrawable = dataSet.getFillDrawable();
if (fillDrawable != null) {
drawFilledPath(c, spline, fillDrawable);
} else {
drawFilledPath(c, spline, dataSet.getFillColor(), dataSet.getFillAlpha());
}
}
protected void drawLinear(Canvas canvas, ILineDataSet iLineDataSet) {
int entryCount = iLineDataSet.getEntryCount();
boolean isDrawSteppedEnabled = iLineDataSet.isDrawSteppedEnabled();
int i = isDrawSteppedEnabled ? 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.mLineBuffer.length <= i2) {
this.mLineBuffer = new float[i * 4];
}
int i3 = this.mXBounds.min;
while (i3 <= this.mXBounds.range + this.mXBounds.min) {
?? entryForIndex = iLineDataSet.getEntryForIndex(i3);
int i4 = i3 + 1;
Entry entry = new Entry();
if (i4 <= this.mXBounds.range) {
entry = iLineDataSet.getEntryForIndex(i4);
}
if (entryForIndex != 0 && entryForIndex.getShow().booleanValue() && entry.getShow().booleanValue()) {
this.mLineBuffer[0] = entryForIndex.getX();
this.mLineBuffer[1] = entryForIndex.getY() * phaseY;
if (i3 < this.mXBounds.max) {
?? entryForIndex2 = iLineDataSet.getEntryForIndex(i4);
if (entryForIndex2 == 0) {
break;
}
if (isDrawSteppedEnabled) {
this.mLineBuffer[2] = entryForIndex2.getX();
float[] fArr = this.mLineBuffer;
fArr[3] = fArr[1];
fArr[4] = fArr[2];
fArr[5] = fArr[3];
fArr[6] = entryForIndex2.getX();
this.mLineBuffer[7] = entryForIndex2.getY() * phaseY;
} else if (!entryForIndex2.getShow().booleanValue()) {
this.mLineBuffer[2] = entryForIndex2.getX();
if (entryForIndex2.getY() * phaseY != 0.0f) {
this.mLineBuffer[3] = entryForIndex2.getY() * phaseY;
} else {
float[] fArr2 = this.mLineBuffer;
fArr2[3] = fArr2[1];
}
} else {
this.mLineBuffer[2] = entryForIndex2.getX();
this.mLineBuffer[3] = entryForIndex2.getY() * phaseY;
}
} else {
float[] fArr3 = this.mLineBuffer;
fArr3[2] = fArr3[0];
fArr3[3] = fArr3[1];
}
transformer.pointValuesToPixel(this.mLineBuffer);
if (!this.mViewPortHandler.isInBoundsRight(this.mLineBuffer[0])) {
break;
}
if (this.mViewPortHandler.isInBoundsLeft(this.mLineBuffer[2]) && (this.mViewPortHandler.isInBoundsTop(this.mLineBuffer[1]) || this.mViewPortHandler.isInBoundsBottom(this.mLineBuffer[3]))) {
this.mRenderPaint.setColor(iLineDataSet.getColor(i3));
canvas2.drawLines(this.mLineBuffer, 0, i2, this.mRenderPaint);
}
}
i3 = i4;
}
} else {
int i5 = entryCount * i;
if (this.mLineBuffer.length < Math.max(i5, i) * 2) {
this.mLineBuffer = new float[Math.max(i5, i) * 4];
}
if (iLineDataSet.getEntryForIndex(this.mXBounds.min) != 0) {
int i6 = this.mXBounds.min;
int i7 = 0;
while (i6 <= this.mXBounds.range + this.mXBounds.min) {
?? entryForIndex3 = iLineDataSet.getEntryForIndex(i6 == 0 ? 0 : i6 - 1);
?? entryForIndex4 = iLineDataSet.getEntryForIndex(i6);
if (entryForIndex3 != 0 && entryForIndex4 != 0) {
if (entryForIndex3.getY() != 0.0f && entryForIndex4.getY() != 0.0f) {
int i8 = i7 + 1;
this.mLineBuffer[i7] = entryForIndex3.getX();
int i9 = i8 + 1;
this.mLineBuffer[i8] = entryForIndex3.getY() * phaseY;
if (isDrawSteppedEnabled) {
int i10 = i9 + 1;
this.mLineBuffer[i9] = entryForIndex4.getX();
int i11 = i10 + 1;
this.mLineBuffer[i10] = entryForIndex3.getY() * phaseY;
int i12 = i11 + 1;
this.mLineBuffer[i11] = entryForIndex4.getX();
i9 = i12 + 1;
this.mLineBuffer[i12] = entryForIndex3.getY() * phaseY;
}
int i13 = i9 + 1;
this.mLineBuffer[i9] = entryForIndex4.getX();
this.mLineBuffer[i13] = entryForIndex4.getY() * phaseY;
i7 = i13 + 1;
}
}
i6++;
}
if (i7 > 0) {
transformer.pointValuesToPixel(this.mLineBuffer);
int max = Math.max((this.mXBounds.range + 1) * i, i) * 2;
this.mRenderPaint.setColor(iLineDataSet.getColor());
canvas2.drawLines(this.mLineBuffer, 0, max, this.mRenderPaint);
}
}
}
this.mRenderPaint.setPathEffect(null);
}
protected void drawLinearFill(Canvas c, ILineDataSet dataSet, Transformer trans, BarLineScatterCandleBubbleRenderer.XBounds bounds) {
int i;
int i2;
Path path = this.mGenerateFilledPathBuffer;
int i3 = bounds.min;
int i4 = bounds.range + bounds.min;
int i5 = 0;
do {
i = (i5 * 128) + i3;
i2 = i + 128;
if (i2 > i4) {
i2 = i4;
}
if (i <= i2) {
generateFilledPath(dataSet, i, i2, path);
trans.pathValueToPixel(path);
Drawable fillDrawable = dataSet.getFillDrawable();
if (fillDrawable != null) {
drawFilledPath(c, path, fillDrawable);
} else {
drawFilledPath(c, path, dataSet.getFillColor(), dataSet.getFillAlpha());
}
}
i5++;
} while (i <= i2);
}
private void generateFilledPath(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;
while (true) {
Entry entry2 = entry;
if (i3 > i2) {
break;
}
?? entryForIndex2 = iLineDataSet.getEntryForIndex(i3);
if (z && entry2 != null) {
path.lineTo(entryForIndex2.getX(), entry2.getY() * phaseY);
}
path.lineTo(entryForIndex2.getX(), entryForIndex2.getY() * phaseY);
i3++;
entry = entryForIndex2;
}
if (entry != null) {
path.lineTo(entry.getX(), fillLinePosition);
}
path.close();
}
@Override
public void drawValues(Canvas c) {
int i;
MPPointF mPPointF;
float f;
float f2;
if (isDrawingValuesAllowed(this.mChart)) {
List<T> dataSets = this.mChart.getLineData().getDataSets();
for (int i2 = 0; i2 < dataSets.size(); i2++) {
ILineDataSet iLineDataSet = (ILineDataSet) dataSets.get(i2);
if (shouldDrawValues(iLineDataSet)) {
applyValueTextStyle(iLineDataSet);
Transformer transformer = this.mChart.getTransformer(iLineDataSet.getAxisDependency());
int circleRadius = (int) (iLineDataSet.getCircleRadius() * 1.75f);
if (!iLineDataSet.isDrawCirclesEnabled()) {
circleRadius /= 2;
}
int i3 = circleRadius;
this.mXBounds.set(this.mChart, iLineDataSet);
float[] generateTransformedValuesLine = transformer.generateTransformedValuesLine(iLineDataSet, this.mAnimator.getPhaseX(), this.mAnimator.getPhaseY(), this.mXBounds.min, this.mXBounds.max);
MPPointF mPPointF2 = MPPointF.getInstance(iLineDataSet.getIconsOffset());
mPPointF2.x = Utils.convertDpToPixel(mPPointF2.x);
mPPointF2.y = Utils.convertDpToPixel(mPPointF2.y);
int i4 = 0;
while (i4 < generateTransformedValuesLine.length) {
float f3 = generateTransformedValuesLine[i4];
float f4 = generateTransformedValuesLine[i4 + 1];
if (!this.mViewPortHandler.isInBoundsRight(f3)) {
break;
}
if (this.mViewPortHandler.isInBoundsLeft(f3) && this.mViewPortHandler.isInBoundsY(f4)) {
int i5 = i4 / 2;
?? entryForIndex = iLineDataSet.getEntryForIndex(this.mXBounds.min + i5);
if (!iLineDataSet.isDrawValuesEnabled()) {
f = f4;
f2 = f3;
i = i4;
mPPointF = mPPointF2;
} else if (!this.isSetValueOffset.booleanValue()) {
f = f4;
f2 = f3;
i = i4;
mPPointF = mPPointF2;
drawValue(c, iLineDataSet.getValueFormatter(), entryForIndex.getY(), entryForIndex, i2, f3, f4 - i3, iLineDataSet.getValueTextColor(i5));
} else {
f = f4;
f2 = f3;
i = i4;
mPPointF = mPPointF2;
drawValue(c, iLineDataSet.getValueFormatter(), entryForIndex.getY(), entryForIndex, i2, f3, f + (i3 * 3), iLineDataSet.getValueTextColor(i5));
}
if (entryForIndex.getIcon() != null && iLineDataSet.isDrawIconsEnabled()) {
Drawable icon = entryForIndex.getIcon();
Utils.drawImage(c, icon, (int) (f2 + mPPointF.x), (int) (f + mPPointF.y), icon.getIntrinsicWidth(), icon.getIntrinsicHeight());
}
} else {
i = i4;
mPPointF = mPPointF2;
}
i4 = i + 2;
mPPointF2 = mPPointF;
}
MPPointF.recycleInstance(mPPointF2);
}
}
}
}
@Override
public void drawExtras(Canvas c) {
drawCircles(c);
}
protected void drawCircles(Canvas c) {
DataSetImageCache dataSetImageCache;
Bitmap bitmap;
this.mRenderPaint.setStyle(Paint.Style.FILL);
float phaseY = this.mAnimator.getPhaseY();
float[] fArr = this.mCirclesBuffer;
char c2 = 0;
float f = 0.0f;
fArr[0] = 0.0f;
fArr[1] = 0.0f;
List<T> 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 z = iLineDataSet.isDrawCircleHoleEnabled() && circleHoleRadius < circleRadius && circleHoleRadius > f;
boolean z2 = z && iLineDataSet.getCircleHoleColor() == 1122867;
AnonymousClass1 anonymousClass1 = null;
if (this.mImageCaches.containsKey(iLineDataSet)) {
dataSetImageCache = this.mImageCaches.get(iLineDataSet);
} else {
dataSetImageCache = new DataSetImageCache(this, anonymousClass1);
this.mImageCaches.put(iLineDataSet, dataSetImageCache);
}
if (dataSetImageCache.init(iLineDataSet)) {
dataSetImageCache.fill(iLineDataSet, z, z2);
}
int i2 = this.mXBounds.range + this.mXBounds.min;
int i3 = this.mXBounds.min;
while (i3 <= i2) {
?? entryForIndex = iLineDataSet.getEntryForIndex(i3);
if (entryForIndex == 0) {
break;
}
this.mCirclesBuffer[c2] = entryForIndex.getX();
this.mCirclesBuffer[1] = entryForIndex.getY() * phaseY;
transformer.pointValuesToPixel(this.mCirclesBuffer);
if (!this.mViewPortHandler.isInBoundsRight(this.mCirclesBuffer[c2])) {
break;
}
if (this.mViewPortHandler.isInBoundsLeft(this.mCirclesBuffer[c2]) && this.mViewPortHandler.isInBoundsY(this.mCirclesBuffer[1]) && (bitmap = dataSetImageCache.getBitmap(i3)) != null && entryForIndex.getShow().booleanValue()) {
float[] fArr2 = this.mCirclesBuffer;
c.drawBitmap(bitmap, fArr2[c2] - circleRadius, fArr2[1] - circleRadius, (Paint) null);
}
i3++;
c2 = 0;
}
}
i++;
c2 = 0;
f = 0.0f;
}
}
@Override
public void drawHighlighted(Canvas c, Highlight[] indices) {
LineData lineData = this.mChart.getLineData();
for (Highlight highlight : indices) {
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(c, (float) pixelForValues.x, (float) pixelForValues.y, iLineDataSet);
}
}
}
}
@Override
public void drawExtras2(Canvas c) {
drawCircles2(c);
}
public void drawCircles2(Canvas c) {
List list;
int i;
DataSetImageCache dataSetImageCache;
?? entryForIndex;
Bitmap bitmap;
?? entryForIndex2;
Bitmap bitmap2;
this.mRenderPaint.setStyle(Paint.Style.FILL);
float phaseY = this.mAnimator.getPhaseY();
float[] fArr = this.mCirclesBuffer;
float f = 0.0f;
fArr[0] = 0.0f;
fArr[1] = 0.0f;
List dataSets = this.mChart.getLineData().getDataSets();
int i2 = 0;
while (i2 < dataSets.size()) {
ILineDataSet iLineDataSet = (ILineDataSet) dataSets.get(i2);
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 z = iLineDataSet.isDrawCircleHoleEnabled() && circleHoleRadius < circleRadius && circleHoleRadius > f;
boolean z2 = z && iLineDataSet.getCircleHoleColor() == 1122867;
AnonymousClass1 anonymousClass1 = null;
if (this.mImageCaches.containsKey(iLineDataSet)) {
dataSetImageCache = this.mImageCaches.get(iLineDataSet);
} else {
dataSetImageCache = new DataSetImageCache(this, anonymousClass1);
this.mImageCaches.put(iLineDataSet, dataSetImageCache);
}
boolean init = dataSetImageCache.init(iLineDataSet);
if (init) {
dataSetImageCache.fill2(iLineDataSet, z, z2);
}
int i3 = this.mXBounds.range + this.mXBounds.min;
int i4 = this.mXBounds.min;
float y = iLineDataSet.getEntryForIndex(this.mXBounds.min).getY();
list = dataSets;
String week = getWeek((long) iLineDataSet.getEntryForIndex(this.mXBounds.min).getX());
ArrayList arrayList = new ArrayList();
int i5 = this.mXBounds.min;
float f2 = y;
String str = week;
int i6 = i4;
while (i5 <= i3) {
?? entryForIndex3 = iLineDataSet.getEntryForIndex(i5);
int i7 = i2;
boolean z3 = z;
boolean z4 = z2;
if (str.equals(getWeek((long) entryForIndex3.getX()))) {
if (entryForIndex3.getY() > f2) {
f2 = entryForIndex3.getY();
i6 = i5;
}
if (i5 == i3) {
arrayList.add(Integer.valueOf(i6));
}
} else {
arrayList.add(Integer.valueOf(i6));
str = getWeek((long) entryForIndex3.getX());
i6 = i5;
f2 = iLineDataSet.getEntryForIndex(i5).getY();
}
i5++;
i2 = i7;
z = z3;
z2 = z4;
}
i = i2;
boolean z5 = z;
boolean z6 = z2;
for (int i8 = 0; i8 < arrayList.size() && (entryForIndex2 = iLineDataSet.getEntryForIndex(((Integer) arrayList.get(i8)).intValue())) != 0; i8++) {
this.mCirclesBuffer[0] = entryForIndex2.getX();
this.mCirclesBuffer[1] = entryForIndex2.getY() * phaseY;
transformer.pointValuesToPixel(this.mCirclesBuffer);
if (!this.mViewPortHandler.isInBoundsRight(this.mCirclesBuffer[0])) {
break;
}
if (this.mViewPortHandler.isInBoundsLeft(this.mCirclesBuffer[0]) && this.mViewPortHandler.isInBoundsY(this.mCirclesBuffer[1]) && (bitmap2 = dataSetImageCache.getBitmap(0)) != null && entryForIndex2.getShow().booleanValue()) {
float[] fArr2 = this.mCirclesBuffer;
c.drawBitmap(bitmap2, fArr2[0] - circleRadius, fArr2[1] - circleRadius, (Paint) null);
}
}
if (init) {
dataSetImageCache.fill3(iLineDataSet, z5, z6);
}
int i9 = this.mXBounds.min;
float y2 = iLineDataSet.getEntryForIndex(this.mXBounds.min).getY();
String week2 = getWeek((long) iLineDataSet.getEntryForIndex(this.mXBounds.min).getX());
ArrayList arrayList2 = new ArrayList();
int i10 = this.mXBounds.min;
while (i10 <= i3) {
?? entryForIndex4 = iLineDataSet.getEntryForIndex(i10);
Transformer transformer2 = transformer;
float f3 = circleRadius;
if (week2.equals(getWeek((long) entryForIndex4.getX()))) {
if (entryForIndex4.getY() < y2) {
y2 = entryForIndex4.getY();
i9 = i10;
}
if (i10 == i3) {
arrayList.add(Integer.valueOf(i9));
}
} else {
arrayList2.add(Integer.valueOf(i9));
String week3 = getWeek((long) entryForIndex4.getX());
y2 = iLineDataSet.getEntryForIndex(i10).getY();
week2 = week3;
i9 = i10;
}
i10++;
transformer = transformer2;
circleRadius = f3;
}
Transformer transformer3 = transformer;
float f4 = circleRadius;
int i11 = 0;
while (i11 < arrayList2.size() && (entryForIndex = iLineDataSet.getEntryForIndex(((Integer) arrayList2.get(i11)).intValue())) != 0) {
this.mCirclesBuffer[0] = entryForIndex.getX();
this.mCirclesBuffer[1] = entryForIndex.getY() * phaseY;
Transformer transformer4 = transformer3;
transformer4.pointValuesToPixel(this.mCirclesBuffer);
if (!this.mViewPortHandler.isInBoundsRight(this.mCirclesBuffer[0])) {
break;
}
if (this.mViewPortHandler.isInBoundsLeft(this.mCirclesBuffer[0])) {
if (this.mViewPortHandler.isInBoundsY(this.mCirclesBuffer[1]) && (bitmap = dataSetImageCache.getBitmap(1)) != null && entryForIndex.getShow().booleanValue()) {
float[] fArr3 = this.mCirclesBuffer;
c.drawBitmap(bitmap, fArr3[0] - f4, fArr3[1] - f4, (Paint) null);
i11++;
transformer3 = transformer4;
}
}
i11++;
transformer3 = transformer4;
}
} else {
list = dataSets;
i = i2;
}
i2 = i + 1;
dataSets = list;
f = 0.0f;
}
}
public static String getWeek(long millis) {
return getWeek(new Date(millis));
}
public static String getWeek(Date date) {
return new SimpleDateFormat("EEEE", Locale.getDefault()).format(date);
}
public void setBitmapConfig(Bitmap.Config config) {
this.mBitmapConfig = config;
releaseBitmap();
}
public Bitmap.Config getBitmapConfig() {
return this.mBitmapConfig;
}
public void releaseBitmap() {
Canvas canvas = this.mBitmapCanvas;
if (canvas != null) {
canvas.setBitmap(null);
this.mBitmapCanvas = null;
}
WeakReference<Bitmap> weakReference = this.mDrawBitmap;
if (weakReference != null) {
weakReference.get().recycle();
this.mDrawBitmap.clear();
this.mDrawBitmap = null;
}
}
private class DataSetImageCache {
private Bitmap[] circleBitmaps;
private Path mCirclePathBuffer;
private DataSetImageCache() {
this.mCirclePathBuffer = new Path();
}
DataSetImageCache(LineChartRenderer lineChartRenderer, AnonymousClass1 anonymousClass1) {
this();
}
protected boolean init(ILineDataSet set) {
int circleColorCount = set.getCircleColorCount();
Bitmap[] bitmapArr = this.circleBitmaps;
if (bitmapArr == null) {
this.circleBitmaps = new Bitmap[circleColorCount];
return true;
}
if (bitmapArr.length == circleColorCount) {
return false;
}
this.circleBitmaps = new Bitmap[circleColorCount];
return true;
}
protected void fill(ILineDataSet set, boolean drawCircleHole, boolean drawTransparentCircleHole) {
int circleColorCount = set.getCircleColorCount();
float circleRadius = set.getCircleRadius();
float circleHoleRadius = set.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.circleBitmaps[i] = createBitmap;
LineChartRenderer.this.mRenderPaint.setColor(set.getCircleColor(i));
if (drawTransparentCircleHole) {
this.mCirclePathBuffer.reset();
this.mCirclePathBuffer.addCircle(circleRadius, circleRadius, circleRadius, Path.Direction.CW);
this.mCirclePathBuffer.addCircle(circleRadius, circleRadius, circleHoleRadius, Path.Direction.CCW);
canvas.drawPath(this.mCirclePathBuffer, LineChartRenderer.this.mRenderPaint);
} else {
canvas.drawCircle(circleRadius, circleRadius, circleRadius, LineChartRenderer.this.mRenderPaint);
if (drawCircleHole) {
canvas.drawCircle(circleRadius, circleRadius, circleHoleRadius, LineChartRenderer.this.mCirclePaintInner);
}
}
}
}
protected void fill2(ILineDataSet set, boolean drawCircleHole, boolean drawTransparentCircleHole) {
set.getCircleColorCount();
float circleRadius = set.getCircleRadius();
float circleHoleRadius = set.getCircleHoleRadius();
int i = (int) (circleRadius * 2.1d);
Bitmap createBitmap = Bitmap.createBitmap(i, i, Bitmap.Config.ARGB_4444);
Canvas canvas = new Canvas(createBitmap);
this.circleBitmaps[0] = createBitmap;
LineChartRenderer.this.mRenderPaint.setColor(set.getCircleColor(0));
if (drawTransparentCircleHole) {
this.mCirclePathBuffer.reset();
this.mCirclePathBuffer.addCircle(circleRadius, circleRadius, circleRadius, Path.Direction.CW);
this.mCirclePathBuffer.addCircle(circleRadius, circleRadius, circleHoleRadius, Path.Direction.CCW);
canvas.drawPath(this.mCirclePathBuffer, LineChartRenderer.this.mRenderPaint);
return;
}
canvas.drawCircle(circleRadius, circleRadius, circleRadius, LineChartRenderer.this.mRenderPaint);
if (drawCircleHole) {
canvas.drawCircle(circleRadius, circleRadius, circleHoleRadius, LineChartRenderer.this.mCirclePaintInner);
}
}
protected void fill3(ILineDataSet set, boolean drawCircleHole, boolean drawTransparentCircleHole) {
set.getCircleColorCount();
float circleRadius = set.getCircleRadius();
float circleHoleRadius = set.getCircleHoleRadius();
int i = (int) (circleRadius * 2.1d);
Bitmap createBitmap = Bitmap.createBitmap(i, i, Bitmap.Config.ARGB_4444);
Canvas canvas = new Canvas(createBitmap);
this.circleBitmaps[1] = createBitmap;
LineChartRenderer.this.mRenderPaint.setColor(set.getCircleColor(1));
if (drawTransparentCircleHole) {
this.mCirclePathBuffer.reset();
this.mCirclePathBuffer.addCircle(circleRadius, circleRadius, circleRadius, Path.Direction.CW);
this.mCirclePathBuffer.addCircle(circleRadius, circleRadius, circleHoleRadius, Path.Direction.CCW);
canvas.drawPath(this.mCirclePathBuffer, LineChartRenderer.this.mRenderPaint);
return;
}
canvas.drawCircle(circleRadius, circleRadius, circleRadius, LineChartRenderer.this.mRenderPaint);
if (drawCircleHole) {
canvas.drawCircle(circleRadius, circleRadius, circleHoleRadius, LineChartRenderer.this.mCirclePaintInner);
}
}
protected Bitmap getBitmap(int index) {
Bitmap[] bitmapArr = this.circleBitmaps;
return bitmapArr[index % bitmapArr.length];
}
}
}