@nativescript-community/ui-chart 1.2.36 → 2.0.1

package/renderer/LineChartRenderer.js

@@ -12,9 +12,13 @@ function almostEquals(x, y, epsilon) {
     return Math.abs(x - y) < epsilon;
 }
 function _isPointInArea(point, area, margin = 0.5) {
+    // margin - default is to match rounded decimals
     return point && point.x > area.left - margin && point.x < area.right + margin && point.y > area.top - margin && point.y < area.bottom + margin;
 }
 export function splineCurve(firstPoint, middlePoint, afterPoint, tension) {
+    // Props to Rob Spencer at scaled innovation for his post on splining between points
+    // http://scaledinnovation.com/analytics/splines/aboutSplines.html
+    // This function must also respect "skipped" points
     const previous = firstPoint;
     const current = middlePoint;
     const next = afterPoint;
@@ -22,9 +26,10 @@ export function splineCurve(firstPoint, middlePoint, afterPoint, tension) {
     const d12 = distanceBetweenPoints(next, current);
     let s01 = d01 / (d01 + d12);
     let s12 = d12 / (d01 + d12);
+    // If all points are the same, s01 & s02 will be inf
     s01 = isNaN(s01) ? 0 : s01;
     s12 = isNaN(s12) ? 0 : s12;
-    const fa = tension * s01;
+    const fa = tension * s01; // scaling factor for triangle Ta
     const fb = tension * s12;
     return {
         previous: {
@@ -40,16 +45,24 @@ export function splineCurve(firstPoint, middlePoint, afterPoint, tension) {
 function getXYValue(dataSet, index) {
     const yKey = dataSet.yProperty;
     const entry = dataSet.getEntryForIndex(index);
-    if (entry[yKey] === undefined || entry[yKey] === null) {
+    const yVal = entry[yKey];
+    if (yVal === undefined || yVal === null) {
         return null;
     }
     return { x: dataSet.getEntryXValue(entry, index), y: entry[yKey] };
 }
+// fix drawing "too" thin paths on iOS
 export class DataSetImageCache {
+    /**
+     * Sets up the cache, returns true if a change of cache was required.
+     *
+     * @param set
+     * @return
+     */
     init(set) {
-        const size = set.getCircleColorCount();
+        const size = set.circleColors.length || 1;
         let changeRequired = false;
-        if (this.circleBitmaps == null) {
+        if (!this.circleBitmaps) {
             this.circleBitmaps = [];
             changeRequired = true;
         }
@@ -59,22 +72,34 @@ export class DataSetImageCache {
         }
         return changeRequired;
     }
+    /**
+     * Fills the cache with bitmaps for the given dataset.
+     *
+     * @param set
+     * @param drawCircleHole
+     * @param drawTransparentCircleHole
+     */
     fill(set, renderPaint, circlePaintInner, drawCircleHole, drawTransparentCircleHole) {
-        const colorCount = set.getCircleColorCount();
-        const circleRadius = set.getCircleRadius();
-        const circleHoleRadius = set.getCircleHoleRadius();
+        const colorCount = set.circleColors.length || 1;
+        const circleRadius = set.circleRadius;
+        const circleHoleRadius = set.circleHoleRadius;
         const scale = set.circleHighRes ? Screen.mainScreen.scale : 1;
         for (let i = 0; i < colorCount; i++) {
             const canvas = new Canvas(Math.round(circleRadius * 2 * scale), Math.round(circleRadius * 2 * scale));
             canvas.scale(scale, scale);
-            renderPaint.setColor(set.getCircleColor(i));
+            renderPaint.setColor(set.circleColors[i] || set.color);
             if (drawTransparentCircleHole) {
                 const circlePathBuffer = Utils.getTempPath();
+                // Begin path for circle with hole
                 circlePathBuffer.reset();
+                // const oldType = circlePathBuffer.getFillType();
                 circlePathBuffer.setFillType(FillType.EVEN_ODD);
                 circlePathBuffer.addCircle(circleRadius, circleRadius, circleRadius, Direction.CW);
+                // Cut hole in path
                 circlePathBuffer.addCircle(circleRadius, circleRadius, circleHoleRadius, Direction.CCW);
+                // Fill in-between
                 canvas.drawPath(circlePathBuffer, renderPaint);
+                // circlePathBuffer.setFillType(oldType);
             }
             else {
                 canvas.drawCircle(circleRadius, circleRadius, circleRadius, renderPaint);
@@ -85,22 +110,34 @@ export class DataSetImageCache {
             this.circleBitmaps[i] = canvas.getImage();
         }
     }
+    /**
+     * Returns the cached Bitmap at the given index.
+     *
+     * @param index
+     * @return
+     */
     getBitmap(index) {
         return this.circleBitmaps[index % this.circleBitmaps.length];
     }
 }
 export class LineChartRenderer extends LineRadarRenderer {
-    constructor(chart, animator, viewPortHandler) {
-        super(animator, viewPortHandler);
-        this.mImageCaches = new Map();
-        this.mChart = chart;
-    }
     get fillPath() {
         if (!LineChartRenderer.mFillPath) {
             LineChartRenderer.mFillPath = new Path();
         }
         return LineChartRenderer.mFillPath;
     }
+    constructor(chart, animator, viewPortHandler) {
+        super(animator, viewPortHandler);
+        /**
+         * cache for the circle bitmaps of all datasets
+         */
+        this.mImageCaches = new Map();
+        this.mChart = chart;
+        // if (__ANDROID__) {
+        //     this.mBitmapConfig = android.graphics.Bitmap.Config.ARGB_8888;
+        // }
+    }
     get circlePaintInner() {
         if (!this.mCirclePaintInner) {
             this.mCirclePaintInner = Utils.getTemplatePaint('white-fill');
@@ -108,10 +145,10 @@ export class LineChartRenderer extends LineRadarRenderer {
         return this.mCirclePaintInner;
     }
     drawData(c) {
-        const width = this.mViewPortHandler.getChartWidth();
-        const height = this.mViewPortHandler.getChartHeight();
-        let drawBitmap = this.mDrawBitmap == null ? null : this.mDrawBitmap.get();
-        if (drawBitmap == null || drawBitmap.width !== width || drawBitmap.height !== height) {
+        const width = this.mViewPortHandler.chartWidth;
+        const height = this.mViewPortHandler.chartHeight;
+        let drawBitmap = this.mDrawBitmap?.get();
+        if (!drawBitmap || drawBitmap.width !== width || drawBitmap.height !== height) {
             if (width > 0 && height > 0) {
                 this.mBitmapCanvas = new Canvas(width, height);
                 drawBitmap = this.mBitmapCanvas.getImage();
@@ -123,9 +160,9 @@ export class LineChartRenderer extends LineRadarRenderer {
         else {
             this.mBitmapCanvas.clear();
         }
-        const lineData = this.mChart.getLineData();
+        const lineData = this.mChart.lineData;
         let needsBitmapDrawing = false;
-        for (const set of lineData.getVisibleDataSets()) {
+        for (const set of lineData.visibleDataSets) {
             needsBitmapDrawing = this.drawDataSet(c, set) || needsBitmapDrawing;
         }
         if (needsBitmapDrawing) {
@@ -134,31 +171,48 @@ export class LineChartRenderer extends LineRadarRenderer {
         }
     }
     drawDataSet(c, dataSet) {
-        if (dataSet.getEntryCount() < 1)
+        if (dataSet.entryCount < 1)
             return false;
         const renderPaint = this.renderPaint;
-        renderPaint.setStrokeWidth(dataSet.getLineWidth());
-        renderPaint.setPathEffect(dataSet.getDashPathEffect());
+        renderPaint.setStrokeWidth(dataSet.lineWidth);
+        if (dataSet.dashPathEffect) {
+            renderPaint.setPathEffect(dataSet.dashPathEffect);
+        }
+        if (dataSet.shader) {
+            renderPaint.setShader(dataSet.shader);
+        }
         renderPaint.setColor(dataSet.getColor());
         renderPaint.setStyle(Style.STROKE);
         const scaleX = this.mViewPortHandler.getScaleX();
         dataSet.applyFiltering(scaleX);
         const result = this.draw(c, dataSet);
-        renderPaint.setPathEffect(null);
+        if (dataSet.dashPathEffect) {
+            renderPaint.setPathEffect(null);
+        }
+        if (dataSet.shader) {
+            renderPaint.setShader(null);
+        }
         return result;
     }
     generateHorizontalBezierPath(dataSet, outputPath) {
         if (this.mXBounds.range >= 1) {
             const pointsPerEntryPair = 6;
-            const entryCount = dataSet.getEntryCount();
+            const entryCount = dataSet.entryCount;
             if (!this.mLineBuffer || this.mLineBuffer.length < Math.max(entryCount * pointsPerEntryPair, pointsPerEntryPair) * 2) {
                 this.mLineBuffer = Utils.createArrayBuffer(Math.max(entryCount * pointsPerEntryPair, pointsPerEntryPair) * 2);
             }
-            const phaseY = this.mAnimator.getPhaseY();
+            const phaseY = this.animator.phaseY;
             const yKey = dataSet.yProperty;
-            const firstIndex = Math.max(0, this.mXBounds.min);
+            let firstIndex = Math.max(0, this.mXBounds.min);
+            // let firstIndex = this.mXBounds.min + 1;
             const lastIndex = this.mXBounds.min + this.mXBounds.range;
             let prev = dataSet.getEntryForIndex(firstIndex);
+            let yVal = prev[yKey];
+            while (firstIndex < lastIndex && (yVal === undefined || yVal === null)) {
+                firstIndex++;
+                prev = dataSet.getEntryForIndex(firstIndex);
+                yVal = prev[yKey];
+            }
             let prevXVal = dataSet.getEntryXValue(prev, firstIndex);
             let cur = prev;
             let curXVal = prevXVal;
@@ -166,9 +220,11 @@ export class LineChartRenderer extends LineRadarRenderer {
             let index = 0;
             float32arr[index++] = prevXVal;
             float32arr[index++] = cur[yKey] * phaseY;
+            // let the spline start
             for (let j = firstIndex + 1; j <= lastIndex; j++) {
                 const newEntry = dataSet.getEntryForIndex(j);
-                if (newEntry[yKey] === undefined || newEntry[yKey] === null) {
+                const yVal = newEntry[yKey];
+                if (yVal === undefined || yVal === null) {
                     continue;
                 }
                 prev = cur;
@@ -200,15 +256,20 @@ export class LineChartRenderer extends LineRadarRenderer {
     generateCubicPath(dataSet, outputPath) {
         if (this.mXBounds.range >= 1) {
             const pointsPerEntryPair = 6;
-            const entryCount = dataSet.getEntryCount();
+            const entryCount = dataSet.entryCount;
             if (!this.mLineBuffer || this.mLineBuffer.length < Math.max(entryCount * pointsPerEntryPair, pointsPerEntryPair) * 2) {
                 this.mLineBuffer = Utils.createArrayBuffer(Math.max(entryCount * pointsPerEntryPair, pointsPerEntryPair) * 2);
             }
-            const phaseY = this.mAnimator.getPhaseY();
+            const phaseY = this.animator.phaseY;
             const xKey = dataSet.xProperty;
             const yKey = dataSet.yProperty;
-            const intensity = dataSet.getCubicIntensity();
+            const intensity = dataSet.cubicIntensity;
+            // Take an extra polet from the left, and an extra from the right.
+            // That's because we need 4 points for a cubic bezier (cubic=4), otherwise we get lines moving and doing weird stuff on the edges of the chart.
+            // So in the starting `prev` and `cur`, go -2, -1
+            // And in the `lastIndex`, add +1
             const firstIndex = Math.max(0, this.mXBounds.min);
+            // let firstIndex = this.mXBounds.min + 1;
             const lastIndex = this.mXBounds.min + this.mXBounds.range;
             const float32arr = this.mLineBuffer;
             let index = 0;
@@ -221,21 +282,21 @@ export class LineChartRenderer extends LineRadarRenderer {
             for (let j = firstIndex; j <= lastIndex; j++) {
                 point = getXYValue(dataSet, j);
                 if (!point) {
-                    if (j === 0) {
-                        return [];
-                    }
+                    // if (j === 0) {
+                    //     return [];
+                    // }
                     continue;
                 }
                 if (!prev) {
                     prev = point;
                 }
-                nextIndex = j + 1 < dataSet.getEntryCount() ? j + 1 : j;
+                nextIndex = j + 1 < dataSet.entryCount ? j + 1 : j;
                 next = getXYValue(dataSet, nextIndex);
                 if (!next) {
                     continue;
                 }
                 controlPoints = splineCurve(prev, point, next, intensity);
-                if (j === 0) {
+                if (j === firstIndex) {
                     float32arr[index++] = point.x;
                     float32arr[index++] = point.y * phaseY;
                 }
@@ -266,26 +327,38 @@ export class LineChartRenderer extends LineRadarRenderer {
     }
     generateLinearPath(dataSet, outputPath) {
         if (this.mXBounds.range >= 1) {
-            const isDrawSteppedEnabled = dataSet.getMode() === Mode.STEPPED;
-            const entryCount = dataSet.getEntryCount();
+            const isDrawSteppedEnabled = dataSet.mode === Mode.STEPPED;
+            const entryCount = dataSet.entryCount;
             const pointsPerEntryPair = isDrawSteppedEnabled ? 4 : 2;
             if (!this.mLineBuffer || this.mLineBuffer.length < Math.max(entryCount * pointsPerEntryPair, pointsPerEntryPair) * 2) {
                 this.mLineBuffer = Utils.createArrayBuffer(Math.max(entryCount * pointsPerEntryPair, pointsPerEntryPair) * 2);
             }
-            const phaseY = this.mAnimator.getPhaseY();
+            const phaseX = this.animator.phaseX;
+            const phaseY = this.animator.phaseY;
             const yKey = dataSet.yProperty;
-            const firstIndex = Math.max(0, this.mXBounds.min);
+            // const filled = outputPath;
+            // outputPath.reset();
+            let firstIndex = Math.max(0, this.mXBounds.min);
             const lastIndex = this.mXBounds.min + this.mXBounds.range;
-            const entry = dataSet.getEntryForIndex(firstIndex);
-            const entryXVal = dataSet.getEntryXValue(entry, firstIndex);
+            let firstEntry = dataSet.getEntryForIndex(firstIndex);
+            let entryXVal = dataSet.getEntryXValue(firstEntry, firstIndex);
+            let yVal = firstEntry[yKey];
+            while (firstIndex < lastIndex && (yVal === undefined || yVal === null)) {
+                firstIndex++;
+                firstEntry = dataSet.getEntryForIndex(firstIndex);
+                entryXVal = dataSet.getEntryXValue(firstEntry, firstIndex);
+                yVal = firstEntry[yKey];
+            }
             const float32arr = this.mLineBuffer;
             float32arr[0] = entryXVal;
-            float32arr[1] = entry[yKey] * phaseY;
+            float32arr[1] = firstEntry[yKey] * phaseY;
             let index = 2;
+            // create a new path
             let currentEntry = null;
             let currentEntryXVal;
             let currentEntryYVal;
             let previousEntryYVal;
+            // doing the if test outside is much much faster on big data
             if (isDrawSteppedEnabled) {
                 for (let x = firstIndex + 1; x <= lastIndex; x++) {
                     currentEntry = dataSet.getEntryForIndex(x);
@@ -338,19 +411,20 @@ export class LineChartRenderer extends LineRadarRenderer {
             const firstIndex = Math.max(0, this.mXBounds.min);
             const range = this.mXBounds.range;
             const lastIndex = firstIndex + range;
-            const width = this.mViewPortHandler.getChartWidth();
-            const chartRect = this.mViewPortHandler.getChartRect();
+            const width = this.mViewPortHandler.chartWidth;
+            const chartRect = this.mViewPortHandler.chartRect;
             let lastColor;
             const gradientDelta = 0;
             const posDelta = gradientDelta / width;
             for (let index = 0; index < nbColors; index++) {
                 const color = colors[index];
                 let colorIndex = color[xKey || 'index'];
+                // if filtered we need to get the real index
                 if (dataSet.isFiltered()) {
-                    dataSet.setIgnoreFiltered(true);
+                    dataSet.ignoreFiltered = true;
                     const entry = dataSet.getEntryForIndex(colorIndex);
-                    dataSet.setIgnoreFiltered(false);
-                    if (entry !== null) {
+                    dataSet.ignoreFiltered = false;
+                    if (entry) {
                         colorIndex = dataSet.getEntryIndexForXValue(dataSet.getEntryXValue(entry, colorIndex), NaN, Rounding.CLOSEST);
                     }
                 }
@@ -395,16 +469,16 @@ export class LineChartRenderer extends LineRadarRenderer {
     }
     draw(c, dataSet) {
         const result = false;
-        const drawFilled = dataSet.isDrawFilledEnabled();
-        const drawLine = dataSet.getLineWidth() > 0;
+        const drawFilled = dataSet.drawFilledEnabled;
+        const drawLine = dataSet.lineWidth > 0;
         if (!drawFilled && !drawLine) {
             return result;
         }
-        const trans = this.mChart.getTransformer(dataSet.getAxisDependency());
+        const trans = this.mChart.getTransformer(dataSet.axisDependency);
         const linePath = Utils.getTempPath();
-        this.mXBounds.set(this.mChart, dataSet, this.mAnimator);
+        this.mXBounds.set(this.mChart, dataSet, this.animator);
         let points;
-        switch (dataSet.getMode()) {
+        switch (dataSet.mode) {
             default:
             case Mode.LINEAR:
             case Mode.STEPPED:
@@ -420,16 +494,17 @@ export class LineChartRenderer extends LineRadarRenderer {
         if (!points) {
             return result;
         }
-        const colors = dataSet.getColors();
+        const colors = dataSet.colors;
         const nbColors = colors.length;
         const renderPaint = this.renderPaint;
         let paintColorsShader;
         if (nbColors > 0) {
+            // TODO: we transforms points in there. Could be dangerous if used after
             paintColorsShader = this.getMultiColorsShader(colors, points, trans, dataSet);
         }
         let oldShader;
         if (drawFilled) {
-            const useColorsForFill = dataSet.getUseColorsForFill();
+            const useColorsForFill = dataSet.useColorsForFill;
             if (paintColorsShader && useColorsForFill) {
                 oldShader = renderPaint.getShader();
                 renderPaint.setShader(paintColorsShader);
@@ -440,12 +515,13 @@ export class LineChartRenderer extends LineRadarRenderer {
             const minEntryValue = dataSet.getEntryXValue(dataSet.getEntryForIndex(this.mXBounds.min), this.mXBounds.min);
             const maxEntryValue = dataSet.getEntryXValue(dataSet.getEntryForIndex(this.mXBounds.min + this.mXBounds.range), this.mXBounds.min + this.mXBounds.range);
             this.drawFill(c, dataSet, fillPath, trans, minEntryValue, maxEntryValue);
+            this.lastLinePath = linePath;
             if (paintColorsShader && useColorsForFill) {
                 renderPaint.setShader(oldShader);
                 oldShader = null;
             }
         }
-        const customRender = this.mChart.getCustomRenderer();
+        const customRender = this.mChart.customRenderer;
         if (drawLine) {
             const useColorsForLine = dataSet.useColorsForLine;
             if (paintColorsShader && useColorsForLine) {
@@ -475,38 +551,45 @@ export class LineChartRenderer extends LineRadarRenderer {
         }
     }
     drawFill(c, dataSet, spline, trans, min, max, color, fillMin) {
-        if (fillMin === undefined) {
-            fillMin = dataSet.getFillFormatter().getFillLinePosition(dataSet, this.mChart);
+        const fillFormatter = dataSet.fillFormatter;
+        if (fillFormatter.getFillLinePath) {
+            fillFormatter.getFillLinePath(dataSet, this.mChart, spline, this.lastLinePath);
+        }
+        else if (fillMin === undefined) {
+            fillMin = fillFormatter.getFillLinePosition(dataSet, this.mChart);
+            spline.lineTo(max, fillMin);
+            spline.lineTo(min, fillMin);
+            spline.close();
         }
-        spline.lineTo(max, fillMin);
-        spline.lineTo(min, fillMin);
-        spline.close();
         trans && trans.pathValueToPixel(spline);
-        const drawable = dataSet.getFillDrawable();
-        if (drawable != null) {
-            this.drawFilledPathBitmap(c, spline, drawable, dataSet.getFillShader());
+        const drawable = dataSet.fillDrawable;
+        if (drawable) {
+            this.drawFilledPathBitmap(c, spline, drawable, dataSet.fillShader);
         }
         else {
-            this.drawFilledPath(c, spline, color || dataSet.getFillColor(), dataSet.getFillAlpha(), dataSet.getFillShader());
+            this.drawFilledPath(c, spline, color || dataSet.fillColor, dataSet.fillAlpha, dataSet.fillShader);
         }
     }
     drawValuesForDataset(c, dataSet, dataSetIndex) {
         const yKey = dataSet.yProperty;
+        // apply the text-styling defined by the DataSet
         this.applyValueTextStyle(dataSet);
-        const trans = this.mChart.getTransformer(dataSet.getAxisDependency());
-        let valOffset = dataSet.getCircleRadius() * 1.75;
-        if (!dataSet.isDrawCirclesEnabled())
+        const chart = this.mChart;
+        const trans = chart.getTransformer(dataSet.axisDependency);
+        // make sure the values do not interfear with the circles
+        let valOffset = dataSet.circleRadius * 1.75;
+        if (!dataSet.drawCirclesEnabled)
             valOffset = valOffset / 2;
-        this.mXBounds.set(this.mChart, dataSet, this.mAnimator);
-        const { points, count } = trans.generateTransformedValues(dataSet, this.mAnimator.getPhaseX(), this.mAnimator.getPhaseY(), this.mXBounds.min, this.mXBounds.max);
-        const formatter = dataSet.getValueFormatter();
-        const iconsOffset = dataSet.getIconsOffset();
-        const valuesOffset = dataSet.getValuesOffset();
-        const drawIcons = dataSet.isDrawIconsEnabled();
-        const drawValues = dataSet.isDrawValuesEnabled();
+        this.mXBounds.set(chart, dataSet, this.animator);
+        const { points, count } = trans.generateTransformedValues(dataSet, this.animator.phaseX, this.animator.phaseY, this.mXBounds.min, this.mXBounds.max);
+        const formatter = dataSet.valueFormatter;
+        const iconsOffset = dataSet.iconsOffset;
+        const valuesOffset = dataSet.valuesOffset;
+        const drawIcons = dataSet.drawIconsEnabled;
+        const drawValues = dataSet.drawValuesEnabled;
         const length = count;
         const paint = this.valuePaint;
-        const customRender = this.mChart.getCustomRenderer();
+        const customRender = chart.customRenderer;
         for (let j = 0; j < length; j += 2) {
             const x = points[j];
             const y = points[j + 1];
@@ -518,24 +601,27 @@ export class LineChartRenderer extends LineRadarRenderer {
             const entry = dataSet.getEntryForIndex(index);
             if (!entry)
                 continue;
+            const yVal = entry[yKey];
+            if (yVal === undefined || yVal === null) {
+                continue;
+            }
             if (drawValues) {
-                this.drawValue(c, formatter.getFormattedValue(entry[yKey], entry), valuesOffset.x + x, valuesOffset.y + y - valOffset, dataSet.getValueTextColor(j / 2), paint, customRender);
+                this.drawValue(c, chart, dataSet, dataSetIndex, entry, index, formatter.getFormattedValue(yVal, entry), valuesOffset.x + x, valuesOffset.y + y - valOffset, dataSet.getValueTextColor(j / 2), paint, customRender);
             }
-            if (drawIcons && entry.icon != null) {
-                const icon = entry.icon;
-                Utils.drawIcon(c, this.mChart, icon, x + iconsOffset.x, y + iconsOffset.y);
+            if (drawIcons) {
+                this.drawIcon(c, chart, dataSet, dataSetIndex, entry, index, dataSet.getEntryIcon(entry), x + iconsOffset.x, y + iconsOffset.y, customRender);
             }
         }
     }
     drawValues(c) {
-        const data = this.mChart.getLineData();
-        const dataSets = data.getDataSets();
-        if (!this.isDrawingValuesAllowed(this.mChart) || dataSets.some((d) => d.isDrawValuesEnabled() || d.isDrawIconsEnabled()) === false) {
+        const data = this.mChart.lineData;
+        const dataSets = data.dataSets;
+        if (!this.isDrawingValuesAllowed(this.mChart) || dataSets.some((d) => d.drawValuesEnabled || d.drawIconsEnabled) === false) {
             return;
         }
         for (let i = 0; i < dataSets.length; i++) {
             const dataSet = dataSets[i];
-            if (!this.shouldDrawValues(dataSet) || dataSet.getEntryCount() < 1)
+            if (!this.shouldDrawValues(dataSet) || dataSet.entryCount < 1)
                 continue;
             this.drawValuesForDataset(c, dataSet, i);
         }
@@ -545,15 +631,15 @@ export class LineChartRenderer extends LineRadarRenderer {
     }
     drawCirclesForDataset(c, dataSet) {
         const paint = this.circlePaintInner;
-        paint.setColor(dataSet.getCircleHoleColor());
-        const phaseY = this.mAnimator.getPhaseY();
+        paint.setColor(dataSet.circleHoleColor);
+        const phaseY = this.animator.phaseY;
         const yKey = dataSet.yProperty;
-        const trans = this.mChart.getTransformer(dataSet.getAxisDependency());
-        this.mXBounds.set(this.mChart, dataSet, this.mAnimator);
-        const circleRadius = dataSet.getCircleRadius();
-        const circleHoleRadius = dataSet.getCircleHoleRadius();
-        const drawCircleHole = dataSet.isDrawCircleHoleEnabled() && circleHoleRadius < circleRadius && circleHoleRadius > 0;
-        const drawTransparentCircleHole = drawCircleHole && dataSet.getCircleHoleColor() === ColorTemplate.COLOR_NONE;
+        const trans = this.mChart.getTransformer(dataSet.axisDependency);
+        this.mXBounds.set(this.mChart, dataSet, this.animator);
+        const circleRadius = dataSet.circleRadius;
+        const circleHoleRadius = dataSet.circleHoleRadius;
+        const drawCircleHole = dataSet.drawCircleHoleEnabled && circleHoleRadius < circleRadius && circleHoleRadius > 0;
+        const drawTransparentCircleHole = drawCircleHole && dataSet.circleHoleColor === ColorTemplate.COLOR_NONE;
         let imageCache;
         if (this.mImageCaches.get(dataSet)) {
             imageCache = this.mImageCaches.get(dataSet);
@@ -563,6 +649,7 @@ export class LineChartRenderer extends LineRadarRenderer {
             this.mImageCaches.set(dataSet, imageCache);
         }
         const changeRequired = imageCache.init(dataSet);
+        // only fill the cache with new bitmaps if a change is required
         if (changeRequired) {
             const renderPaint = this.renderPaint;
             imageCache.fill(dataSet, renderPaint, paint, drawCircleHole, drawTransparentCircleHole);
@@ -572,14 +659,15 @@ export class LineChartRenderer extends LineRadarRenderer {
         const destRect = Utils.getTempRectF();
         for (let j = this.mXBounds.min; j <= boundsRangeCount; j++) {
             const e = dataSet.getEntryForIndex(j);
-            if (e == null)
+            if (!e)
                 continue;
             const yVal = e[yKey];
-            if (yVal == null || yVal === undefined)
+            if (yVal === null || yVal === undefined)
                 continue;
             circleBuffer[0] = dataSet.getEntryXValue(e, j);
             circleBuffer[1] = yVal * phaseY;
             trans.pointValuesToPixel(circleBuffer);
+            // native buffer access is slow
             const cx = circleBuffer[0];
             const cy = circleBuffer[1];
             if (!this.mViewPortHandler.isInBoundsRight(cx))
@@ -587,15 +675,15 @@ export class LineChartRenderer extends LineRadarRenderer {
             if (!this.mViewPortHandler.isInBoundsLeft(cx) || !this.mViewPortHandler.isInBoundsY(cy))
                 continue;
             const circleBitmap = imageCache.getBitmap(j);
-            if (circleBitmap != null) {
+            if (circleBitmap) {
                 destRect.set(cx - circleRadius, cy - circleRadius, cx - circleRadius + 2 * circleRadius, cy - circleRadius + 2 * circleRadius);
                 c.drawBitmap(circleBitmap, null, destRect, null);
             }
         }
     }
     drawCircles(c) {
-        const dataSets = this.mChart.getLineData().getVisibleDataSets();
-        if (dataSets.some((d) => d.isDrawCirclesEnabled()) === false) {
+        const dataSets = this.mChart.lineData.visibleDataSets;
+        if (dataSets.some((d) => d.drawCirclesEnabled) === false) {
             return;
         }
         const renderPaint = this.renderPaint;
@@ -605,24 +693,25 @@ export class LineChartRenderer extends LineRadarRenderer {
         circleBuffer[1] = 0;
         for (let i = 0; i < dataSets.length; i++) {
             const dataSet = dataSets[i];
-            if (!dataSet.isDrawCirclesEnabled() || dataSet.getEntryCount() === 0)
+            if (!dataSet.drawCirclesEnabled || dataSet.entryCount === 0)
                 continue;
             this.drawCirclesForDataset(c, dataSet);
         }
     }
-    drawHighlighted(c, indices, actualDraw) {
-        const lineData = this.mChart.getLineData();
-        const customRender = this.mChart.getCustomRenderer();
+    drawHighlighted(c, indices, actualDraw = true) {
+        const lineData = this.mChart.lineData;
+        const customRender = this.mChart.customRenderer;
         const paint = this.highlightPaint;
         for (const high of indices) {
             const set = lineData.getDataSetByIndex(high.dataSetIndex);
-            if (set == null || !set.isHighlightEnabled())
+            if (!set || !set.highlightEnabled)
                 continue;
             const { entry, index } = lineData.getEntryAndIndexForHighlight(high);
+            // let e = set.getEntryForXValue(high.x high.y);
             if (!this.isInBoundsX(entry, set))
                 continue;
             const yKey = set.yProperty;
-            const pix = this.mChart.getTransformer(set.getAxisDependency()).getPixelForValues(set.getEntryXValue(entry, index), entry[yKey] * this.mAnimator.getPhaseY());
+            const pix = this.mChart.getTransformer(set.axisDependency).getPixelForValues(set.getEntryXValue(entry, index), entry[yKey] * this.animator.phaseY);
             high.drawX = pix.x;
             high.drawY = pix.y;
             if (!actualDraw) {
@@ -632,21 +721,23 @@ export class LineChartRenderer extends LineRadarRenderer {
                 customRender.drawHighlight(c, high, set, paint);
             }
             else {
-                this.drawHighlightLines(c, pix.x, pix.y, set);
+                this.drawHighlightLines(c, high.xPx, high.yPx, set);
             }
         }
     }
+    /**
+     * Releases the drawing bitmap. This should be called when {@link LineChart#onDetachedFromWindow()}.
+     */
     releaseBitmap() {
-        if (this.mBitmapCanvas != null) {
+        if (this.mBitmapCanvas) {
             this.mBitmapCanvas.setBitmap(null);
             this.mBitmapCanvas = null;
         }
-        if (this.mDrawBitmap != null) {
+        if (this.mDrawBitmap) {
             const drawBitmap = this.mDrawBitmap.get();
-            if (drawBitmap != null) {
+            if (drawBitmap) {
                 releaseImage(drawBitmap);
             }
-            this.mDrawBitmap.clear();
             this.mDrawBitmap = null;
         }
     }
@@ -663,12 +754,6 @@ __decorate([
 __decorate([
     profile
 ], LineChartRenderer.prototype, "generateCubicPath", null);
-__decorate([
-    profile
-], LineChartRenderer.prototype, "generateLinearPath", null);
-__decorate([
-    profile
-], LineChartRenderer.prototype, "draw", null);
 __decorate([
     profile
 ], LineChartRenderer.prototype, "drawLines", null);