@nativescript-community/ui-chart 1.2.35 → 2.0.0

package/renderer/PieChartRenderer.js

@@ -5,10 +5,6 @@ import { ValuePosition } from '../data/PieDataSet';
 import { ColorTemplate } from '../utils/ColorTemplate';
 import { Utils } from '../utils/Utils';
 export class PieChartRenderer extends DataRenderer {
-    constructor(chart, animator, viewPortHandler) {
-        super(animator, viewPortHandler);
-        this.mChart = chart;
-    }
     get centerTextLastBounds() {
         if (!this.mCenterTextLastBounds) {
             this.mCenterTextLastBounds = new RectF(0, 0, 0, 0);
@@ -21,6 +17,10 @@ export class PieChartRenderer extends DataRenderer {
         }
         return this.mRectBuffer;
     }
+    constructor(chart, animator, viewPortHandler) {
+        super(animator, viewPortHandler);
+        this.mChart = chart;
+    }
     get centerTextPaint() {
         if (!this.mCenterTextPaint) {
             this.mCenterTextPaint = Utils.getTemplatePaint('black-fill');
@@ -58,10 +58,10 @@ export class PieChartRenderer extends DataRenderer {
         return this.mValuePaint;
     }
     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();
@@ -75,8 +75,8 @@ export class PieChartRenderer extends DataRenderer {
             this.mBitmapCanvas.clear();
         }
         let needsBitmapDrawing = false;
-        const pieData = this.mChart.getData();
-        for (const set of pieData.getDataSets()) {
+        const pieData = this.mChart.data;
+        for (const set of pieData.dataSets) {
             needsBitmapDrawing = this.drawDataSet(c, set) || needsBitmapDrawing;
         }
         if (needsBitmapDrawing) {
@@ -86,54 +86,70 @@ export class PieChartRenderer extends DataRenderer {
     }
     calculateMinimumRadiusForSpacedSlice(center, radius, angle, arcStartPointX, arcStartPointY, startAngle, sweepAngle) {
         const angleMiddle = startAngle + sweepAngle / 2;
+        // Other polet of the arc
         const arcEndPointX = center.x + radius * Math.cos((startAngle + sweepAngle) * Utils.DEG2RAD);
         const arcEndPointY = center.y + radius * Math.sin((startAngle + sweepAngle) * Utils.DEG2RAD);
+        // Middle polet on the arc
         const arcMidPointX = center.x + radius * Math.cos(angleMiddle * Utils.DEG2RAD);
         const arcMidPointY = center.y + radius * Math.sin(angleMiddle * Utils.DEG2RAD);
+        // This is the base of the contained triangle
         const basePointsDistance = Math.sqrt(Math.pow(arcEndPointX - arcStartPointX, 2) + Math.pow(arcEndPointY - arcStartPointY, 2));
+        // After reducing space from both sides of the "slice",
+        //   the angle of the contained triangle should stay the same.
+        // So let's find out the height of that triangle.
         const containedTriangleHeight = (basePointsDistance / 2.0) * Math.tan(((180.0 - angle) / 2.0) * Utils.DEG2RAD);
+        // Now we subtract that from the radius
         let spacedRadius = radius - containedTriangleHeight;
+        // And now subtract the height of the arc that's between the triangle and the outer circle
         spacedRadius -= Math.sqrt(Math.pow(arcMidPointX - (arcEndPointX + arcStartPointX) / 2, 2) + Math.pow(arcMidPointY - (arcEndPointY + arcStartPointY) / 2, 2));
         return spacedRadius;
     }
+    /**
+     * Calculates the sliceSpace to use based on visible values and their size compared to the set sliceSpace.
+     *
+     * @param dataSet
+     * @return
+     */
     getSliceSpace(dataSet) {
-        if (!dataSet.isAutomaticallyDisableSliceSpacingEnabled()) {
-            return dataSet.getSliceSpace();
+        if (!dataSet.automaticallyDisableSliceSpacing) {
+            return dataSet.sliceSpace;
         }
-        const spaceSizeRatio = dataSet.getSliceSpace() / this.mViewPortHandler.getSmallestContentExtension();
-        const minValueRatio = (dataSet.getYMin() / this.mChart.getData().getYValueSum()) * 2;
-        const sliceSpace = spaceSizeRatio > minValueRatio ? 0 : dataSet.getSliceSpace();
+        const spaceSizeRatio = dataSet.sliceSpace / this.mViewPortHandler.smallestContentExtension;
+        const minValueRatio = (dataSet.yMin / this.mChart.data.getYValueSum()) * 2;
+        const sliceSpace = spaceSizeRatio > minValueRatio ? 0 : dataSet.sliceSpace;
         return sliceSpace;
     }
     drawDataSet(c, dataSet) {
+        const chart = this.mChart;
         const result = false;
         let angle = 0;
         const yKey = dataSet.yProperty;
-        const rotationAngle = this.mChart.getRotationAngle();
-        const phaseX = this.mAnimator.getPhaseX();
-        const phaseY = this.mAnimator.getPhaseY();
-        const circleBox = this.mChart.getCircleBox();
-        const entryCount = dataSet.getEntryCount();
-        const drawAngles = this.mChart.getDrawAngles();
-        const center = this.mChart.getCenterCircleBox();
-        const radius = this.mChart.getRadius();
-        const drawInnerArc = this.mChart.isDrawHoleEnabled() && !this.mChart.isDrawSlicesUnderHoleEnabled();
-        const userInnerRadius = drawInnerArc ? radius * (this.mChart.getHoleRadius() / 100) : 0;
-        const roundedRadius = (radius - (radius * this.mChart.getHoleRadius()) / 100) / 2;
+        const rotationAngle = chart.rotationAngle;
+        const phaseX = this.animator.phaseX;
+        const phaseY = this.animator.phaseY;
+        const circleBox = chart.circleBox;
+        const entryCount = dataSet.entryCount;
+        const drawAngles = chart.drawAngles;
+        const center = chart.centerCircleBox;
+        const radius = chart.radius;
+        const drawInnerArc = chart.drawHoleEnabled && !chart.drawSlicesUnderHoleEnabled;
+        const userInnerRadius = drawInnerArc ? radius * (chart.holeRadius / 100) : 0;
+        const roundedRadius = (radius - (radius * chart.holeRadius) / 100) / 2;
         const roundedCircleBox = new RectF(0, 0, 0, 0);
-        const drawRoundedSlices = drawInnerArc && this.mChart.isDrawRoundedSlicesEnabled();
+        const drawRoundedSlices = drawInnerArc && chart.drawRoundedSlices;
         let visibleAngleCount = 0;
         for (let j = 0; j < entryCount; j++) {
+            // draw only if the value is greater than zero
             if (Math.abs(dataSet.getEntryForIndex(j)[yKey]) > Utils.NUMBER_EPSILON) {
                 visibleAngleCount++;
             }
         }
         const sliceSpace = visibleAngleCount <= 1 ? 0 : this.getSliceSpace(dataSet);
-        const customRender = this.mChart.getCustomRenderer();
+        const customRender = chart.customRenderer;
         const renderPaint = this.renderPaint;
         const pathBuffer = Utils.getTempPath();
         const previousShader = renderPaint.getShader();
-        const shader = dataSet.getFillShader();
+        const shader = dataSet.fillShader;
         if (shader) {
             renderPaint.setShader(shader);
         }
@@ -141,11 +157,13 @@ export class PieChartRenderer extends DataRenderer {
             const sliceAngle = drawAngles[j];
             let innerRadius = userInnerRadius;
             const e = dataSet.getEntryForIndex(j);
+            // draw only if the value is greater than zero
             if (!(Math.abs(e[yKey]) > Utils.NUMBER_EPSILON)) {
                 angle += sliceAngle * phaseX;
                 continue;
             }
-            if (this.mChart.needsHighlight(j) && !drawRoundedSlices) {
+            // Don't draw if it's highlighted, unless the chart uses rounded slices
+            if (chart.needsHighlight(j) && !drawRoundedSlices) {
                 angle += sliceAngle * phaseX;
                 continue;
             }
@@ -166,6 +184,7 @@ export class PieChartRenderer extends DataRenderer {
             const arcStartPointX = center.x + radius * Math.cos(startAngleOuter * Utils.DEG2RAD);
             const arcStartPointY = center.y + radius * Math.sin(startAngleOuter * Utils.DEG2RAD);
             if (sweepAngleOuter >= 360 && sweepAngleOuter % 360 <= Utils.NUMBER_EPSILON) {
+                // Android is doing "mod 360"
                 pathBuffer.addCircle(center.x, center.y, radius, Direction.CW);
             }
             else {
@@ -174,6 +193,7 @@ export class PieChartRenderer extends DataRenderer {
                 }
                 pathBuffer.arcTo(circleBox, startAngleOuter, sweepAngleOuter);
             }
+            // Android API < 21 does not receive floats in addArc, but a RectF
             if (drawInnerArc && (innerRadius > 0 || accountForSliceSpacing)) {
                 const innerRectBuffer = Utils.getTempRectF();
                 innerRectBuffer.set(center.x - innerRadius, center.y - innerRadius, center.x + innerRadius, center.y + innerRadius);
@@ -192,6 +212,7 @@ export class PieChartRenderer extends DataRenderer {
                 }
                 const endAngleInner = startAngleInner + sweepAngleInner;
                 if (sweepAngleOuter >= 360 && sweepAngleOuter % 360 <= Utils.NUMBER_EPSILON) {
+                    // Android is doing "mod 360"
                     pathBuffer.addCircle(center.x, center.y, innerRadius, Direction.CCW);
                 }
                 else {
@@ -234,25 +255,28 @@ export class PieChartRenderer extends DataRenderer {
         return result;
     }
     drawValues(c) {
-        const drawEntryLabels = this.mChart.isDrawEntryLabelsEnabled();
-        const data = this.mChart.getData();
-        const dataSets = data.getDataSets();
-        if (!drawEntryLabels || dataSets.some((d) => d.isDrawValuesEnabled() || d.isDrawIconsEnabled()) === false) {
+        const chart = this.mChart;
+        const drawEntryLabels = chart.drawEntryLabels;
+        const data = chart.data;
+        const dataSets = data.dataSets;
+        if (!drawEntryLabels || dataSets.some((d) => d.drawValuesEnabled || d.drawIconsEnabled) === false) {
             return;
         }
-        const center = this.mChart.getCenterCircleBox();
-        const radius = this.mChart.getRadius();
-        let rotationAngle = this.mChart.getRotationAngle();
-        const drawAngles = this.mChart.getDrawAngles();
-        const absoluteAngles = this.mChart.getAbsoluteAngles();
-        const phaseX = this.mAnimator.getPhaseX();
-        const phaseY = this.mAnimator.getPhaseY();
-        const roundedRadius = (radius - (radius * this.mChart.getHoleRadius()) / 100) / 2;
-        const holeRadiusPercent = this.mChart.getHoleRadius() / 100;
+        const center = chart.centerCircleBox;
+        // Get whole the radius
+        const radius = chart.radius;
+        let rotationAngle = chart.rotationAngle;
+        const drawAngles = chart.drawAngles;
+        const absoluteAngles = chart.absoluteAngles;
+        const phaseX = this.animator.phaseX;
+        const phaseY = this.animator.phaseY;
+        const roundedRadius = (radius - (radius * chart.holeRadius) / 100) / 2;
+        const holeRadiusPercent = chart.holeRadius / 100;
         let labelRadiusOffset = (radius / 10) * 3.6;
-        if (this.mChart.isDrawHoleEnabled()) {
+        if (chart.drawHoleEnabled) {
             labelRadiusOffset = (radius - radius * holeRadiusPercent) / 2;
-            if (!this.mChart.isDrawSlicesUnderHoleEnabled() && this.mChart.isDrawRoundedSlicesEnabled()) {
+            if (!chart.drawSlicesUnderHoleEnabled && chart.drawRoundedSlices) {
+                // Add curved circle slice and spacing to rotation angle, so that it sits nicely inside
                 rotationAngle += (roundedRadius * 360) / (Math.PI * 2 * radius);
             }
         }
@@ -264,28 +288,29 @@ export class PieChartRenderer extends DataRenderer {
         const offset = 5;
         const paint = this.valuePaint;
         const entryLabelsPaint = drawEntryLabels ? this.entryLabelsPaint : undefined;
-        const customRender = this.mChart.getCustomRenderer();
+        const customRender = chart.customRenderer;
         const valueLinePaint = Utils.getTempPaint();
         valueLinePaint.setStyle(Style.STROKE);
         for (let i = 0; i < dataSets.length; i++) {
             const dataSet = dataSets[i];
-            const drawValues = dataSet.isDrawValuesEnabled();
+            const drawValues = dataSet.drawValuesEnabled;
             if (!drawValues) {
                 continue;
             }
             const yKey = dataSet.yProperty;
-            const xValuePosition = dataSet.getXValuePosition();
-            const yValuePosition = dataSet.getYValuePosition();
+            const xValuePosition = dataSet.xValuePosition;
+            const yValuePosition = dataSet.yValuePosition;
+            // Apply the text-styling defined by the DataSet
             this.applyValueTextStyle(dataSet);
             const lineHeight = Utils.calcTextHeight(paint, 'Q') + 4;
-            const formatter = dataSet.getValueFormatter();
-            const entryCount = dataSet.getEntryCount();
-            valueLinePaint.setColor(dataSet.getValueLineColor());
-            valueLinePaint.setStrokeWidth(dataSet.getValueLineWidth());
+            const formatter = dataSet.valueFormatter;
+            const entryCount = dataSet.entryCount;
+            valueLinePaint.setColor(dataSet.valueLineColor);
+            valueLinePaint.setStrokeWidth(dataSet.valueLineWidth);
             const sliceSpace = this.getSliceSpace(dataSet);
-            const iconsOffset = dataSet.getIconsOffset();
-            const valuesOffset = dataSet.getValuesOffset();
-            const isDrawIconsEnabled = dataSet.isDrawIconsEnabled();
+            const iconsOffset = dataSet.iconsOffset;
+            const valuesOffset = dataSet.valuesOffset;
+            const isDrawIconsEnabled = dataSet.drawIconsEnabled;
             for (let j = 0; j < entryCount; j++) {
                 const entry = dataSet.getEntryForIndex(j);
                 if (xIndex === 0) {
@@ -296,11 +321,12 @@ export class PieChartRenderer extends DataRenderer {
                 }
                 const sliceAngle = drawAngles[xIndex];
                 const sliceSpaceMiddleAngle = sliceSpace / (Utils.DEG2RAD * labelRadius);
+                // offset needed to center the drawn text in the slice
                 const angleOffset = (sliceAngle - sliceSpaceMiddleAngle / 2) / 2;
                 angle = angle + angleOffset;
                 const transformedAngle = rotationAngle + angle * phaseY;
-                const value = this.mChart.isUsePercentValuesEnabled() ? (entry[yKey] / yValueSum) * 100 : entry[yKey];
-                const formattedValue = formatter.getPieLabel(value, entry);
+                const value = chart.usePercentValues ? (entry[yKey] / yValueSum) * 100 : entry[yKey];
+                const formattedValue = (formatter.getPieLabel || formatter.getFormattedValue)(value, entry);
                 const entryLabel = entry.label;
                 const sliceXBase = Math.cos(transformedAngle * Utils.DEG2RAD);
                 const sliceYBase = Math.sin(transformedAngle * Utils.DEG2RAD);
@@ -309,19 +335,19 @@ export class PieChartRenderer extends DataRenderer {
                 const drawXInside = drawEntryLabels && xValuePosition === ValuePosition.INSIDE_SLICE;
                 const drawYInside = drawValues && yValuePosition === ValuePosition.INSIDE_SLICE;
                 if (drawXOutside || drawYOutside) {
-                    const valueLineLength1 = dataSet.getValueLinePart1Length();
-                    const valueLineLength2 = dataSet.getValueLinePart2Length();
-                    const valueLinePart1OffsetPercentage = dataSet.getValueLinePart1OffsetPercentage() / 100;
+                    const valueLineLength1 = dataSet.valueLinePart1Length;
+                    const valueLineLength2 = dataSet.valueLinePart2Length;
+                    const valueLinePart1OffsetPercentage = dataSet.valueLinePart1OffsetPercentage / 100;
                     let pt2x, pt2y;
                     let labelPtx, labelPty;
                     let line1Radius;
-                    if (this.mChart.isDrawHoleEnabled()) {
+                    if (chart.drawHoleEnabled) {
                         line1Radius = (radius - radius * holeRadiusPercent) * valueLinePart1OffsetPercentage + radius * holeRadiusPercent;
                     }
                     else {
                         line1Radius = radius * valueLinePart1OffsetPercentage;
                     }
-                    const polyline2Width = dataSet.isValueLineVariableLength() ? labelRadius * valueLineLength2 * Math.abs(Math.sin(transformedAngle * Utils.DEG2RAD)) : labelRadius * valueLineLength2;
+                    const polyline2Width = dataSet.valueLineVariableLength ? labelRadius * valueLineLength2 * Math.abs(Math.sin(transformedAngle * Utils.DEG2RAD)) : labelRadius * valueLineLength2;
                     const pt0x = line1Radius * sliceXBase + center.x;
                     const pt0y = line1Radius * sliceYBase + center.y;
                     const pt1x = labelRadius * (1 + valueLineLength1) * sliceXBase + center.x;
@@ -346,59 +372,69 @@ export class PieChartRenderer extends DataRenderer {
                         labelPtx = pt2x + offset;
                         labelPty = pt2y;
                     }
-                    if (dataSet.getValueLineColor() !== ColorTemplate.COLOR_NONE) {
-                        if (dataSet.isUsingSliceColorAsValueLineColor()) {
+                    if (dataSet.valueLineColor !== ColorTemplate.COLOR_NONE) {
+                        if (dataSet.usingSliceColorAsValueLineColor) {
                             valueLinePaint.setColor(dataSet.getColor(j));
                         }
                         c.drawLine(pt0x, pt0y, pt1x, pt1y, valueLinePaint);
                         c.drawLine(pt1x, pt1y, pt2x, pt2y, valueLinePaint);
                     }
+                    // draw everything, depending on settings
                     if (drawXOutside && drawYOutside) {
-                        this.drawValue(c, formattedValue, labelPtx + valuesOffset.x, labelPty + valuesOffset.y, dataSet.getValueTextColor(j), paint, customRender);
-                        if (j < data.getEntryCount() && entryLabel != null) {
+                        this.drawValue(c, chart, dataSet, i, entry, j, formattedValue, labelPtx + valuesOffset.x, labelPty + valuesOffset.y, dataSet.getValueTextColor(j), paint, customRender);
+                        if (j < data.entryCount && entryLabel) {
                             this.drawEntryLabel(c, entryLabel, labelPtx, labelPty + lineHeight, entryLabelsPaint);
                         }
                     }
                     else if (drawXOutside) {
-                        if (j < data.getEntryCount() && entryLabel != null) {
+                        if (j < data.entryCount && entryLabel) {
                             this.drawEntryLabel(c, entryLabel, labelPtx, labelPty + lineHeight / 2, entryLabelsPaint);
                         }
                     }
                     else if (drawYOutside) {
-                        this.drawValue(c, formattedValue, labelPtx + valuesOffset.x, labelPty + valuesOffset.y + lineHeight / 2, dataSet.getValueTextColor(j), paint, customRender);
+                        this.drawValue(c, chart, dataSet, i, entry, j, formattedValue, labelPtx + valuesOffset.x, labelPty + valuesOffset.y + lineHeight / 2, dataSet.getValueTextColor(j), paint, customRender);
                     }
                 }
                 if (drawXInside || drawYInside) {
+                    // calculate the text position
                     const x = labelRadius * sliceXBase + center.x;
                     const y = labelRadius * sliceYBase + center.y;
                     paint.setTextAlign(Align.CENTER);
+                    // draw everything, depending on settings
                     if (drawXInside && drawYInside) {
-                        this.drawValue(c, formattedValue, x + valuesOffset.x, y + valuesOffset.y, dataSet.getValueTextColor(j), paint, customRender);
-                        if (j < data.getEntryCount() && entryLabel != null) {
+                        this.drawValue(c, chart, dataSet, i, entry, j, formattedValue, x + valuesOffset.x, y + valuesOffset.y, dataSet.getValueTextColor(j), paint, customRender);
+                        if (j < data.entryCount && entryLabel) {
                             this.drawEntryLabel(c, entryLabel, x, y + lineHeight, entryLabelsPaint);
                         }
                     }
                     else if (drawXInside) {
-                        if (j < data.getEntryCount() && entryLabel != null) {
+                        if (j < data.entryCount && entryLabel) {
                             this.drawEntryLabel(c, entryLabel, x, y + lineHeight / 2, entryLabelsPaint);
                         }
                     }
                     else if (drawYInside) {
-                        this.drawValue(c, formattedValue, x + valuesOffset.x, y + valuesOffset.y + lineHeight / 2, dataSet.getValueTextColor(j), paint, customRender);
+                        this.drawValue(c, chart, dataSet, i, entry, j, formattedValue, x + valuesOffset.x, y + valuesOffset.y + lineHeight / 2, dataSet.getValueTextColor(j), paint, customRender);
                     }
                 }
-                if (isDrawIconsEnabled && entry.icon != null) {
-                    const icon = entry.icon;
+                if (isDrawIconsEnabled) {
                     const x = (labelRadius + iconsOffset.y) * sliceXBase + center.x;
                     let y = (labelRadius + iconsOffset.y) * sliceYBase + center.y;
                     y += iconsOffset.x;
-                    Utils.drawIcon(c, this.mChart, icon, x, y);
+                    this.drawIcon(c, chart, dataSet, i, entry, j, dataSet.getEntryIcon(entry), x, y, customRender);
                 }
                 xIndex++;
             }
         }
         c.restore();
     }
+    /**
+     * Draws an entry label at the specified position.
+     *
+     * @param c
+     * @param label
+     * @param x
+     * @param y
+     */
     drawEntryLabel(c, label, x, y, paint) {
         c.drawText(label.toString(), x, y, paint);
     }
@@ -409,37 +445,51 @@ export class PieChartRenderer extends DataRenderer {
         }
         this.drawCenterText(c);
     }
+    /**
+     * Draws the hole in the center of the chart and the transparent circle /
+     * hole.
+     */
     drawHole(c) {
-        if (this.mChart.isDrawHoleEnabled()) {
-            const radius = this.mChart.getRadius();
-            const holeRadius = radius * (this.mChart.getHoleRadius() / 100);
-            const center = this.mChart.getCenterCircleBox();
+        const chart = this.mChart;
+        if (chart.drawHoleEnabled) {
+            const radius = chart.radius;
+            const holeRadius = radius * (chart.holeRadius / 100);
+            const center = chart.centerCircleBox;
             const paint = this.holePaint;
             if (ColorTemplate.getColorInstance(paint.getColor()).a > 0) {
+                // draw the hole-circle
                 c.drawCircle(center.x, center.y, holeRadius, paint);
             }
             const transparentCirclePaint = this.transparentCirclePaint;
-            if (ColorTemplate.getColorInstance(transparentCirclePaint.getColor()).a > 0 && this.mChart.getTransparentCircleRadius() > this.mChart.getHoleRadius()) {
+            // only draw the circle if it can be seen (not covered by the hole)
+            if (ColorTemplate.getColorInstance(transparentCirclePaint.getColor()).a > 0 && chart.transparentCircleRadiusPercent > chart.holeRadius) {
                 const alpha = transparentCirclePaint.getAlpha();
-                const secondHoleRadius = radius * (this.mChart.getTransparentCircleRadius() / 100);
-                transparentCirclePaint.setAlpha(alpha * this.mAnimator.getPhaseX() * this.mAnimator.getPhaseY());
+                const secondHoleRadius = radius * (chart.transparentCircleRadiusPercent / 100);
+                transparentCirclePaint.setAlpha(alpha * this.animator.phaseX * this.animator.phaseY);
+                // draw the transparent-circle
                 const path = Utils.getTempPath();
                 path.reset();
                 path.addCircle(center.x, center.y, secondHoleRadius, Direction.CW);
                 path.addCircle(center.x, center.y, holeRadius, Direction.CCW);
                 c.drawPath(path, transparentCirclePaint);
+                // reset alpha
                 transparentCirclePaint.setAlpha(alpha);
             }
         }
     }
+    /**
+     * Draws the description text in the center of the pie chart makes most
+     * sense when center-hole is enabled.
+     */
     drawCenterText(c) {
-        const centerText = this.mChart.getCenterText();
-        if (this.mChart.isDrawCenterTextEnabled() && centerText != null) {
-            const center = this.mChart.getCenterCircleBox();
-            const offset = this.mChart.getCenterTextOffset();
+        const chart = this.mChart;
+        const centerText = chart.centerText;
+        if (centerText && chart.drawCenterText) {
+            const center = chart.centerCircleBox;
+            const offset = chart.centerTextOffset;
             const x = center.x + offset.x;
             const y = center.y + offset.y;
-            const innerRadius = this.mChart.isDrawHoleEnabled() && !this.mChart.isDrawSlicesUnderHoleEnabled() ? this.mChart.getRadius() * (this.mChart.getHoleRadius() / 100) : this.mChart.getRadius();
+            const innerRadius = chart.drawHoleEnabled && !chart.drawSlicesUnderHoleEnabled ? chart.radius * (chart.holeRadius / 100) : chart.radius;
             const rectBuffer = this.rectBuffer;
             const holeRect = rectBuffer[0];
             holeRect.left = x - innerRadius;
@@ -448,17 +498,20 @@ export class PieChartRenderer extends DataRenderer {
             holeRect.bottom = y + innerRadius;
             const boundingRect = rectBuffer[1];
             boundingRect.set(holeRect);
-            const radiusPercent = this.mChart.getCenterTextRadiusPercent() / 100;
+            const radiusPercent = chart.centerTextRadiusPercent / 100;
             if (radiusPercent > 0.0) {
                 boundingRect.inset((boundingRect.width() - boundingRect.width() * radiusPercent) / 2, (boundingRect.height() - boundingRect.height() * radiusPercent) / 2);
             }
             const centerTextLastBounds = this.centerTextLastBounds;
-            if (centerText !== this.mCenterTextLastValue || boundingRect !== centerTextLastBounds) {
+            if (!this.mCenterTextLayout || centerText !== this.mCenterTextLastValue || boundingRect !== centerTextLastBounds) {
+                // Next time we won't recalculate StaticLayout...
                 centerTextLastBounds.set(boundingRect);
                 this.mCenterTextLastValue = centerText;
                 const width = centerTextLastBounds.width();
+                // If width is 0, it will crash. Always have a minimum of 1
                 this.mCenterTextLayout = new StaticLayout(centerText, this.centerTextPaint, Math.max(Math.ceil(width), 1), LayoutAlignment.ALIGN_CENTER, 1, 0, false);
             }
+            //let layoutWidth = Utils.getStaticLayoutMaxWidth(mCenterTextLayout);
             const layoutHeight = this.mCenterTextLayout.getHeight();
             c.save();
             if (__ANDROID__) {
@@ -475,37 +528,44 @@ export class PieChartRenderer extends DataRenderer {
         }
     }
     drawHighlighted(c, indices) {
-        const drawInnerArc = this.mChart.isDrawHoleEnabled() && !this.mChart.isDrawSlicesUnderHoleEnabled();
-        if (drawInnerArc && this.mChart.isDrawRoundedSlicesEnabled()) {
+        /* Skip entirely if using rounded circle slices, because it doesn't make sense to highlight
+         * in this way.
+         * TODO: add support for changing slice color with highlighting rather than only shifting the slice
+         */
+        const chart = this.mChart;
+        const drawInnerArc = chart.drawHoleEnabled && !chart.drawSlicesUnderHoleEnabled;
+        if (drawInnerArc && chart.drawRoundedSlices) {
             return;
         }
-        const phaseX = this.mAnimator.getPhaseX();
-        const phaseY = this.mAnimator.getPhaseY();
+        const phaseX = this.animator.phaseX;
+        const phaseY = this.animator.phaseY;
         let angle;
-        const rotationAngle = this.mChart.getRotationAngle();
-        const drawAngles = this.mChart.getDrawAngles();
-        const absoluteAngles = this.mChart.getAbsoluteAngles();
-        const center = this.mChart.getCenterCircleBox();
-        const radius = this.mChart.getRadius();
-        const userInnerRadius = drawInnerArc ? radius * (this.mChart.getHoleRadius() / 100) : 0;
+        const rotationAngle = chart.rotationAngle;
+        const drawAngles = chart.drawAngles;
+        const absoluteAngles = chart.absoluteAngles;
+        const center = chart.centerCircleBox;
+        const radius = chart.radius;
+        const userInnerRadius = drawInnerArc ? radius * (chart.holeRadius / 100) : 0;
         const highlightedCircleBox = Utils.getTempRectF();
-        const customRender = this.mChart.getCustomRenderer();
+        const customRender = chart.customRenderer;
         const renderPaint = this.renderPaint;
         const pathBuffer = Utils.getTempPath();
         for (let i = 0; i < indices.length; i++) {
+            // get the index to highlight
             const high = indices[i];
             const index = high.x;
             if (index >= drawAngles.length) {
                 continue;
             }
-            const set = this.mChart.getData().getDataSetByIndex(high.dataSetIndex);
-            if (set == null || !set.isHighlightEnabled()) {
+            const set = chart.data.getDataSetByIndex(high.dataSetIndex);
+            if (!set || !set.highlightEnabled) {
                 continue;
             }
             const yKey = set.yProperty;
-            const entryCount = set.getEntryCount();
+            const entryCount = set.entryCount;
             let visibleAngleCount = 0;
             for (let j = 0; j < entryCount; j++) {
+                // draw only if the value is greater than zero
                 if (Math.abs(set.getEntryForIndex(j)[yKey]) > Utils.NUMBER_EPSILON) {
                     visibleAngleCount++;
                 }
@@ -516,12 +576,12 @@ export class PieChartRenderer extends DataRenderer {
             else {
                 angle = absoluteAngles[index - 1] * phaseX;
             }
-            const sliceSpace = visibleAngleCount <= 1 ? 0 : set.getSliceSpace();
+            const sliceSpace = visibleAngleCount <= 1 ? 0 : set.sliceSpace;
             const sliceAngle = drawAngles[index];
             let innerRadius = userInnerRadius;
-            const shift = set.getSelectionShift();
+            const shift = set.selectionShift;
             const highlightedRadius = radius + shift;
-            highlightedCircleBox.set(this.mChart.getCircleBox());
+            highlightedCircleBox.set(chart.circleBox);
             highlightedCircleBox.inset(-shift, -shift);
             const accountForSliceSpacing = sliceSpace > 0 && sliceAngle <= 180;
             renderPaint.setColor(set.getColor(index));
@@ -539,6 +599,7 @@ export class PieChartRenderer extends DataRenderer {
             }
             pathBuffer.reset();
             if (sweepAngleOuter >= 360 && sweepAngleOuter % 360 <= Utils.NUMBER_EPSILON) {
+                // Android is doing "mod 360"
                 pathBuffer.addCircle(center.x, center.y, highlightedRadius, Direction.CW);
             }
             else {
@@ -550,6 +611,7 @@ export class PieChartRenderer extends DataRenderer {
                 sliceSpaceRadius = this.calculateMinimumRadiusForSpacedSlice(center, radius, sliceAngle * phaseY, center.x + radius * Math.cos(startAngleOuter * Utils.DEG2RAD), center.y + radius * Math.sin(startAngleOuter * Utils.DEG2RAD), startAngleOuter, sweepAngleOuter);
             }
             if (drawInnerArc && (innerRadius > 0 || accountForSliceSpacing)) {
+                // Android API < 21 does not receive floats in addArc, but a RectF
                 const innerRectBuffer = Utils.getTempRectF();
                 innerRectBuffer.set(center.x - innerRadius, center.y - innerRadius, center.x + innerRadius, center.y + innerRadius);
                 if (accountForSliceSpacing) {
@@ -566,6 +628,7 @@ export class PieChartRenderer extends DataRenderer {
                 }
                 const endAngleInner = startAngleInner + sweepAngleInner;
                 if (sweepAngleOuter >= 360 && sweepAngleOuter % 360 <= Utils.NUMBER_EPSILON) {
+                    // Android is doing "mod 360"
                     pathBuffer.addCircle(center.x, center.y, innerRadius, Direction.CCW);
                 }
                 else {
@@ -595,26 +658,34 @@ export class PieChartRenderer extends DataRenderer {
             }
         }
     }
+    /**
+     * This gives all pie-slices a rounded edge.
+     *
+     * @param c
+     */
     drawRoundedSlices(c) {
-        if (!this.mChart.isDrawRoundedSlicesEnabled()) {
+        const chart = this.mChart;
+        if (!chart.drawRoundedSlices) {
             return;
         }
-        const dataSet = this.mChart.getData().getDataSet();
-        if (!dataSet.isVisible()) {
+        const dataSet = chart.data.getDataSet();
+        if (!dataSet.visible) {
             return;
         }
         const yKey = dataSet.yProperty;
-        const phaseX = this.mAnimator.getPhaseX();
-        const phaseY = this.mAnimator.getPhaseY();
-        const center = this.mChart.getCenterCircleBox();
-        const r = this.mChart.getRadius();
-        const circleRadius = (r - (r * this.mChart.getHoleRadius()) / 100) / 2;
-        const drawAngles = this.mChart.getDrawAngles();
-        let angle = this.mChart.getRotationAngle();
+        const phaseX = this.animator.phaseX;
+        const phaseY = this.animator.phaseY;
+        const center = chart.centerCircleBox;
+        const r = chart.radius;
+        // calculate the radius of the "slice-circle"
+        const circleRadius = (r - (r * chart.holeRadius) / 100) / 2;
+        const drawAngles = chart.drawAngles;
+        let angle = chart.rotationAngle;
         const renderPaint = this.renderPaint;
-        for (let j = 0; j < dataSet.getEntryCount(); j++) {
+        for (let j = 0; j < dataSet.entryCount; j++) {
             const sliceAngle = drawAngles[j];
             const e = dataSet.getEntryForIndex(j);
+            // draw only if the value is greater than zero
             if (Math.abs(e[yKey]) > Utils.NUMBER_EPSILON) {
                 const x = (r - circleRadius) * Math.cos((angle + sliceAngle) * phaseY * Utils.DEG2RAD) + center.x;
                 const y = (r - circleRadius) * Math.sin((angle + sliceAngle) * phaseY * Utils.DEG2RAD) + center.y;
@@ -624,17 +695,19 @@ export class PieChartRenderer extends DataRenderer {
             angle += sliceAngle * phaseX;
         }
     }
+    /**
+     * Releases the drawing bitmap.
+     */
     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;
         }
     }