@nativescript-community/ui-chart 1.2.36 → 2.0.1

package/charts/BarLineChartBase.js

@@ -20,34 +20,81 @@ const LOG_TAG = 'BarLineChartBase';
 export class BarLineChartBase extends Chart {
     constructor() {
         super(...arguments);
-        this.mMaxVisibleCount = 100;
+        /**
+         * the maximum number of entries to which values will be drawn
+         * (entry numbers greater than this value will cause value-labels to disappear)
+         */
+        this.maxVisibleValueCount = 100;
+        /**
+         * flag that indicates if auto scaling on the y axis is enabled
+         */
+        this.autoScaleMinMaxEnabled = true;
+        /**
+         * flag that indicates zoomed pan gesture should only work with 2 pointers
+         */
         this.zoomedPanWith2Pointers = false;
-        this.mClipValuesToContent = true;
-        this.mClipDataToContent = true;
-        this.mDrawHighlight = true;
-        this.mMinOffset = 15;
+        this.clipValuesToContent = true;
+        this.clipDataToContent = true;
+        this.drawHighlight = true;
+        /**
+         * Sets the minimum offset (padding) around the chart, defaults to 15
+         */
+        this.minOffset = 15;
+        // for performance tracking
         this.totalTime = 0;
         this.drawCycles = 0;
+        // public onTouchEvent( event) {
+        //     super.onTouchEvent(event);
+        //     if (mChartTouchListener == null || this.mData == null)
+        //         return false;
+        //     // check if touch gestures are enabled
+        //     if (!mTouchEnabled)
+        //         return false;
+        //     else
+        //         return this.chartTouchListener.onTouch(this, event);
+        // }
+        // public computeScroll() {
+        // if (this.chartTouchListener instanceof BarLineChartTouchListener)
+        //     (this.chartTouchListener).computeScroll();
+        // }
+        /**
+         * ################ ################ ################ ################
+         */
+        /**
+         * CODE BELOW THIS RELATED TO SCALING AND GESTURES AND MODIFICATION OF THE
+         * VIEWPORT
+         */
         this.mZoomMatrixBuffer = new Matrix();
         this.mFitScreenMatrixBuffer = new Matrix();
-        this.mGetPositionBuffer = [];
+        /**
+         * wheter to highlight drawing will be clipped to contentRect,
+         * otherwise they can bleed outside the content rect.
+         */
         this.clipHighlightToContent = true;
+        /**
+         * buffer for storing lowest visible x point
+         */
         this.posForGetLowestVisibleX = { x: 0, y: 0 };
+        /**
+         * buffer for storing highest visible x point
+         */
         this.posForGetHighestVisibleX = { x: 0, y: 0 };
         this.mOnSizeChangedBuffer = Utils.createArrayBuffer(2);
     }
+    // /** the approximator object used for data filtering */
+    // private Approximator this.mApproximator;
     init() {
         super.init();
-        this.mAxisLeft = new YAxis(AxisDependency.LEFT);
-        this.mLeftAxisTransformer = new Transformer(this.mViewPortHandler);
-        this.mAxisRendererLeft = new YAxisRenderer(this.mViewPortHandler, this.mAxisLeft, this.mLeftAxisTransformer);
-        this.mXAxisRenderer = new XAxisRenderer(this.mViewPortHandler, this.mXAxis, this.mLeftAxisTransformer);
-        this.setHighlighter(new ChartHighlighter(this));
+        this.mAxisLeft = new YAxis(AxisDependency.LEFT, new WeakRef(this));
+        this.leftAxisTransformer = new Transformer(this.viewPortHandler);
+        this.rendererLeftYAxis = new YAxisRenderer(this.viewPortHandler, this.mAxisLeft, this.leftAxisTransformer);
+        this.rendererXAxis = new XAxisRenderer(this.viewPortHandler, this.xAxis, this.leftAxisTransformer);
+        this.highlighter = new ChartHighlighter(this);
     }
     get gridBackgroundPaint() {
         if (!this.mGridBackgroundPaint) {
             this.mGridBackgroundPaint = Utils.getTemplatePaint('black-fill');
-            this.mGridBackgroundPaint.setColor('#F0F0F0');
+            this.mGridBackgroundPaint.setColor('#F0F0F0'); // light
         }
         return this.mGridBackgroundPaint;
     }
@@ -58,110 +105,114 @@ export class BarLineChartBase extends Chart {
         return this.mBorderPaint;
     }
     getOrCreateBarTouchListener() {
-        if (!this.mChartTouchListener) {
-            this.mChartTouchListener = new BarLineChartTouchListener(this, this.mViewPortHandler.getMatrixTouch(), 3);
+        if (!this.chartTouchListener) {
+            this.chartTouchListener = new BarLineChartTouchListener(this, this.viewPortHandler.getMatrixTouch(), 3);
             if (!!this.nativeViewProtected) {
-                this.mChartTouchListener.init();
+                this.chartTouchListener.init();
             }
         }
-        return this.mChartTouchListener;
+        return this.chartTouchListener;
     }
     onDraw(canvas) {
         const startTime = Date.now();
         super.onDraw(canvas);
-        const noComputeOnNextDraw = this.noComputeOnNextDraw;
-        this.noComputeOnNextDraw = false;
-        if (this.mData === null)
+        const noComputeAutoScaleOnNextDraw = this.noComputeAutoScaleOnNextDraw;
+        const noComputeAxisOnNextDraw = this.noComputeAxisOnNextDraw;
+        this.noComputeAxisOnNextDraw = false;
+        this.noComputeAutoScaleOnNextDraw = false;
+        if (!this.mData)
             return;
+        // execute all drawing commands
         this.drawGridBackground(canvas);
-        if (!noComputeOnNextDraw && this.mAutoScaleMinMaxEnabled) {
+        const xAxis = this.xAxis;
+        const axisLeft = this.mAxisLeft;
+        const axisRight = this.mAxisRight;
+        // the order is important:
+        // * computeAxis needs axis.axisMinimum set in autoScale
+        // * calculateOffsets needs computeAxis because it needs axis longestLabel
+        if (!noComputeAutoScaleOnNextDraw && this.autoScaleMinMaxEnabled) {
             this.autoScale();
         }
-        const leftEnabled = this.mAxisLeft.isEnabled();
-        const rightEnabled = this.mAxisRight && this.mAxisRight.isEnabled();
-        const xEnabled = this.mXAxis.isEnabled();
-        const leftLimitEnabled = leftEnabled && this.mAxisLeft.isDrawLimitLinesEnabled();
-        const rightLimitEnabled = rightEnabled && this.mAxisRight.isDrawLimitLinesEnabled();
-        const xLimitEnabled = xEnabled && this.mXAxis.isDrawLimitLinesEnabled();
-        if (!noComputeOnNextDraw) {
-            if (leftEnabled)
-                this.mAxisRendererLeft.computeAxis(this.mAxisLeft.mAxisMinimum, this.mAxisLeft.mAxisMaximum, this.mAxisLeft.isInverted());
-            if (rightEnabled)
-                this.mAxisRendererRight.computeAxis(this.mAxisRight.mAxisMinimum, this.mAxisRight.mAxisMaximum, this.mAxisRight.isInverted());
-            if (xEnabled)
-                this.mXAxisRenderer.computeAxis(this.mXAxis.mAxisMinimum, this.mXAxis.mAxisMaximum, false);
-        }
-        if (xEnabled && this.mXAxis.isDrawGridLinesBehindDataEnabled())
-            this.mXAxisRenderer.renderGridLines(canvas);
-        if (leftEnabled && this.mAxisLeft.isDrawGridLinesBehindDataEnabled())
-            this.mAxisRendererLeft.renderGridLines(canvas);
-        if (rightEnabled && this.mAxisRight.isDrawGridLinesBehindDataEnabled())
-            this.mAxisRendererRight.renderGridLines(canvas);
-        if (xLimitEnabled && this.mXAxis.isDrawLimitLinesBehindDataEnabled())
-            this.mXAxisRenderer.renderLimitLines(canvas);
-        if (leftLimitEnabled && this.mAxisLeft.isDrawLimitLinesBehindDataEnabled())
-            this.mAxisRendererLeft.renderLimitLines(canvas);
-        if (rightLimitEnabled && this.mAxisRight.isDrawLimitLinesBehindDataEnabled())
-            this.mAxisRendererRight.renderLimitLines(canvas);
-        if (xEnabled)
-            this.mXAxisRenderer.renderAxisLine(canvas);
-        if (leftEnabled)
-            this.mAxisRendererLeft.renderAxisLine(canvas);
-        if (rightEnabled)
-            this.mAxisRendererRight.renderAxisLine(canvas);
-        if (xEnabled && this.mXAxis.isDrawLabelsBehindDataEnabled())
-            this.mXAxisRenderer.renderAxisLabels(canvas);
-        if (leftEnabled && this.mAxisLeft.isDrawLabelsBehindDataEnabled())
-            this.mAxisRendererLeft.renderAxisLabels(canvas);
-        if (rightEnabled && this.mAxisRight.isDrawLabelsBehindDataEnabled())
-            this.mAxisRendererRight.renderAxisLabels(canvas);
-        if (this.isClipDataToContentEnabled()) {
+        if (!noComputeAxisOnNextDraw) {
+            this.rendererLeftYAxis?.computeAxis(axisLeft.axisMinimum, axisLeft.axisMaximum, axisLeft.inverted);
+            this.rendererRightYAxis?.computeAxis(axisRight.axisMinimum, axisRight.axisMaximum, axisRight.inverted);
+            this.rendererXAxis?.computeAxis(this.xAxis.axisMinimum, this.xAxis.axisMaximum, false);
+        }
+        if (!this.offsetsCalculated) {
+            this.calculateOffsets(false);
+            this.offsetsCalculated = true;
+        }
+        if (xAxis.drawGridLinesBehindData)
+            this.rendererXAxis.renderGridLines(canvas);
+        if (axisLeft.drawGridLinesBehindData)
+            this.rendererLeftYAxis.renderGridLines(canvas);
+        if (axisRight?.drawGridLinesBehindData)
+            this.rendererRightYAxis.renderGridLines(canvas);
+        if (xAxis.drawLimitLinesBehindData)
+            this.rendererXAxis.renderLimitLines(canvas);
+        if (axisLeft.drawLimitLinesBehindData)
+            this.rendererLeftYAxis.renderLimitLines(canvas);
+        if (axisRight?.drawLimitLinesBehindData)
+            this.rendererRightYAxis.renderLimitLines(canvas);
+        this.rendererXAxis.renderAxisLine(canvas);
+        this.rendererLeftYAxis.renderAxisLine(canvas);
+        this.rendererRightYAxis?.renderAxisLine(canvas);
+        if (xAxis.drawLabelsBehindData)
+            this.rendererXAxis.renderAxisLabels(canvas);
+        if (axisLeft.drawLabelsBehindData)
+            this.rendererLeftYAxis.renderAxisLabels(canvas);
+        if (axisRight?.drawLabelsBehindData)
+            this.rendererRightYAxis.renderAxisLabels(canvas);
+        // make sure the data cannot be drawn outside the content-rect
+        if (this.clipDataToContent) {
             canvas.save();
-            canvas.clipRect(this.mViewPortHandler.getContentRect());
-            this.mRenderer.drawData(canvas);
+            canvas.clipRect(this.viewPortHandler.contentRect);
+            this.renderer.drawData(canvas);
         }
         else {
-            this.mRenderer.drawData(canvas);
-        }
-        if (xEnabled && !this.mXAxis.isDrawGridLinesBehindDataEnabled())
-            this.mXAxisRenderer.renderGridLines(canvas);
-        if (leftEnabled && !this.mAxisLeft.isDrawGridLinesBehindDataEnabled())
-            this.mAxisRendererLeft.renderGridLines(canvas);
-        if (rightEnabled && !this.mAxisRight.isDrawGridLinesBehindDataEnabled())
-            this.mAxisRendererRight.renderGridLines(canvas);
-        if (!this.clipHighlightToContent && this.isClipDataToContentEnabled()) {
+            this.renderer.drawData(canvas);
+        }
+        if (!xAxis.drawGridLinesBehindData)
+            this.rendererXAxis.renderGridLines(canvas);
+        if (!axisLeft.drawGridLinesBehindData)
+            this.rendererLeftYAxis.renderGridLines(canvas);
+        if (axisRight?.drawGridLinesBehindData === false)
+            this.rendererRightYAxis.renderGridLines(canvas);
+        if (!this.clipHighlightToContent && this.clipDataToContent) {
+            // restore before drawing highlight
             canvas.restore();
         }
-        if (this.valuesToHighlight()) {
-            this.mRenderer.drawHighlighted(canvas, this.mIndicesToHighlight, this.isDrawHighlightEnabled());
+        if (this.hasValuesToHighlight && this.drawHighlight) {
+            this.renderer.drawHighlighted(canvas, this.indicesToHighlight, this.drawHighlight);
         }
-        if (this.clipHighlightToContent && this.isClipDataToContentEnabled()) {
+        // Removes clipping rectangle
+        if (this.clipHighlightToContent && this.clipDataToContent) {
             canvas.restore();
         }
-        this.mRenderer.drawExtras(canvas);
-        if (xLimitEnabled && !this.mXAxis.isDrawLimitLinesBehindDataEnabled())
-            this.mXAxisRenderer.renderLimitLines(canvas);
-        if (leftLimitEnabled && !this.mAxisLeft.isDrawLimitLinesBehindDataEnabled())
-            this.mAxisRendererLeft.renderLimitLines(canvas);
-        if (rightLimitEnabled && !this.mAxisRight.isDrawLimitLinesBehindDataEnabled())
-            this.mAxisRendererRight.renderLimitLines(canvas);
-        if (xEnabled && !this.mXAxis.isDrawLabelsBehindDataEnabled())
-            this.mXAxisRenderer.renderAxisLabels(canvas);
-        if (leftEnabled && !this.mAxisLeft.isDrawLabelsBehindDataEnabled())
-            this.mAxisRendererLeft.renderAxisLabels(canvas);
-        if (rightEnabled && !this.mAxisRight.isDrawLabelsBehindDataEnabled())
-            this.mAxisRendererRight.renderAxisLabels(canvas);
-        if (this.isClipValuesToContentEnabled()) {
+        this.renderer.drawExtras(canvas);
+        if (!xAxis.drawLimitLinesBehindData)
+            this.rendererXAxis.renderLimitLines(canvas);
+        if (!axisLeft.drawLimitLinesBehindData)
+            this.rendererLeftYAxis.renderLimitLines(canvas);
+        if (axisRight?.drawLimitLinesBehindData === false)
+            this.rendererRightYAxis.renderLimitLines(canvas);
+        if (!xAxis.drawLabelsBehindData)
+            this.rendererXAxis.renderAxisLabels(canvas);
+        if (!axisLeft.drawLabelsBehindData)
+            this.rendererLeftYAxis.renderAxisLabels(canvas);
+        if (axisRight?.drawLabelsBehindData === false)
+            this.rendererRightYAxis.renderAxisLabels(canvas);
+        if (this.clipValuesToContent) {
             canvas.save();
-            canvas.clipRect(this.mViewPortHandler.getContentRect());
-            this.mRenderer.drawValues(canvas);
+            canvas.clipRect(this.viewPortHandler.contentRect);
+            this.renderer.drawValues(canvas);
             canvas.restore();
         }
         else {
-            this.mRenderer.drawValues(canvas);
+            this.renderer.drawValues(canvas);
         }
-        if (this.mLegendRenderer) {
-            this.mLegendRenderer.renderLegend(canvas);
+        if (this.legendRenderer) {
+            this.legendRenderer.renderLegend(canvas);
         }
         this.drawDescription(canvas);
         this.drawMarkers(canvas);
@@ -174,37 +225,40 @@ export class BarLineChartBase extends Chart {
             CLog(CLogTypes.log, this.constructor.name, 'Drawtime: ' + drawtime + ' ms, average: ' + average + ' ms, cycles: ' + this.drawCycles);
         }
     }
+    /**
+     * RESET PERFORMANCE TRACKING FIELDS
+     */
     resetTracking() {
         this.totalTime = 0;
         this.drawCycles = 0;
     }
     prepareValuePxMatrix() {
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, LOG_TAG, 'Preparing Value-Px Matrix, xmin: ' + this.mXAxis.mAxisMinimum + ', xmax: ' + this.mXAxis.mAxisMaximum + ', xdelta: ' + this.mXAxis.mAxisRange);
+            CLog(CLogTypes.info, LOG_TAG, 'Preparing Value-Px Matrix, xmin: ' + this.xAxis.axisMinimum + ', xmax: ' + this.xAxis.axisMaximum + ', xdelta: ' + this.xAxis.axisRange);
         }
-        if (this.mAxisRight && this.mAxisRight.isEnabled()) {
-            this.mRightAxisTransformer.prepareMatrixValuePx(this.mXAxis.mAxisMinimum, this.mXAxis.mAxisRange, this.mAxisRight.mAxisRange, this.mAxisRight.mAxisMinimum);
+        if (this.mAxisRight?.enabled) {
+            this.rightAxisTransformer.prepareMatrixValuePx(this.xAxis.axisMinimum, this.xAxis.axisRange, this.mAxisRight.axisRange, this.mAxisRight.axisMinimum);
         }
-        if ((this.mAxisLeft && this.mAxisLeft.isEnabled()) || this.mXAxis.isEnabled()) {
-            this.mLeftAxisTransformer.prepareMatrixValuePx(this.mXAxis.mAxisMinimum, this.mXAxis.mAxisRange, this.mAxisLeft.mAxisRange, this.mAxisLeft.mAxisMinimum);
+        if (this.mAxisLeft?.enabled || this.xAxis.enabled) {
+            this.leftAxisTransformer.prepareMatrixValuePx(this.xAxis.axisMinimum, this.xAxis.axisRange, this.mAxisLeft.axisRange, this.mAxisLeft.axisMinimum);
         }
     }
     prepareOffsetMatrix() {
-        if (this.mAxisRight && this.mAxisRight.isEnabled()) {
-            this.mRightAxisTransformer.prepareMatrixOffset(this.mAxisRight.isInverted());
+        if (this.mAxisRight?.enabled) {
+            this.rightAxisTransformer.prepareMatrixOffset(this.mAxisRight.inverted);
         }
-        if ((this.mAxisLeft && this.mAxisLeft.isEnabled()) || this.mXAxis.isEnabled()) {
-            this.mLeftAxisTransformer.prepareMatrixOffset(this.mAxisLeft.isInverted());
+        if (this.mAxisLeft?.enabled || this.xAxis.enabled) {
+            this.leftAxisTransformer.prepareMatrixOffset(this.mAxisLeft.inverted);
         }
     }
     notifyDataSetChanged() {
-        if (this.mData == null) {
+        if (!this.mData || this.mData.dataSetCount === 0) {
             if (Trace.isEnabled()) {
                 CLog(CLogTypes.info, LOG_TAG, 'Preparing... DATA NOT SET.');
             }
             return;
         }
-        else if (!this.mViewPortHandler.hasChartDimens()) {
+        else if (!this.viewPortHandler.hasChartDimens) {
             if (Trace.isEnabled()) {
                 CLog(CLogTypes.info, LOG_TAG, 'Preparing... NOT SIZED YET.');
             }
@@ -215,43 +269,47 @@ export class BarLineChartBase extends Chart {
                 CLog(CLogTypes.info, LOG_TAG, 'Preparing...');
             }
         }
-        if (this.mRenderer != null)
-            this.mRenderer.initBuffers();
+        this.renderer?.initBuffers();
         this.calcMinMax();
-        if (this.mAxisLeft && this.mAxisLeft.isEnabled()) {
-            this.mAxisRendererLeft.computeAxis(this.mAxisLeft.mAxisMinimum, this.mAxisLeft.mAxisMaximum, this.mAxisLeft.isInverted());
+        if (this.mAxisLeft?.enabled) {
+            this.rendererLeftYAxis.computeAxis(this.mAxisLeft.axisMinimum, this.mAxisLeft.axisMaximum, this.mAxisLeft.inverted);
         }
-        if (this.mAxisRight && this.mAxisRight.isEnabled()) {
-            this.mAxisRendererRight.computeAxis(this.mAxisRight.mAxisMinimum, this.mAxisRight.mAxisMaximum, this.mAxisRight.isInverted());
+        if (this.mAxisRight?.enabled) {
+            this.rendererRightYAxis.computeAxis(this.mAxisRight.axisMinimum, this.mAxisRight.axisMaximum, this.mAxisRight.inverted);
         }
-        if (this.mXAxis.isEnabled()) {
-            this.mXAxisRenderer.computeAxis(this.mXAxis.mAxisMinimum, this.mXAxis.mAxisMaximum, false);
+        if (this.xAxis.enabled) {
+            this.rendererXAxis.computeAxis(this.xAxis.axisMinimum, this.xAxis.axisMaximum, false);
         }
-        if (this.mLegend != null && this.mLegend.isEnabled()) {
-            this.mLegendRenderer.computeLegend(this.mData);
+        if (this.mLegend?.enabled) {
+            this.legendRenderer.computeLegend(this.mData);
         }
-        this.calculateOffsets();
+        // offsets will be calculated on draw
+        this.offsetsCalculated = false;
         this.invalidate();
     }
+    /**
+     * Performs auto scaling of the axis by recalculating the minimum and maximum y-values based on the entries currently in view.
+     */
     autoScale() {
-        const fromX = this.getLowestVisibleX();
-        const toX = this.getHighestVisibleX();
+        const fromX = this.lowestVisibleX;
+        const toX = this.highestVisibleX;
         this.mData.calcMinMaxYRange(fromX, toX);
-        this.mXAxis.calculate(this.mData.getXMin(), this.mData.getXMax());
-        if (this.mAxisLeft && this.mAxisLeft.isEnabled()) {
+        this.xAxis.calculate(this.mData.xMin, this.mData.xMax);
+        // calculate axis range (min / max) according to provided data
+        if (this.mAxisLeft?.enabled) {
             this.mAxisLeft.calculate(this.mData.getYMin(AxisDependency.LEFT), this.mData.getYMax(AxisDependency.LEFT));
         }
-        if (this.mAxisRight && this.mAxisRight.isEnabled()) {
+        if (this.mAxisRight?.enabled) {
             this.mAxisRight.calculate(this.mData.getYMin(AxisDependency.RIGHT), this.mData.getYMax(AxisDependency.RIGHT));
         }
-        this.calculateOffsets();
     }
     calcMinMax() {
-        this.mXAxis.calculate(this.mData.getXMin(), this.mData.getXMax());
-        if (this.mAxisLeft && this.mAxisLeft.isEnabled()) {
+        this.xAxis.calculate(this.mData.xMin, this.mData.xMax);
+        // calculate axis range (min / max) according to provided data
+        if (this.mAxisLeft?.enabled) {
             this.mAxisLeft.calculate(this.mData.getYMin(AxisDependency.LEFT), this.mData.getYMax(AxisDependency.LEFT));
         }
-        if (this.mAxisRight && this.mAxisRight.isEnabled()) {
+        if (this.mAxisRight?.enabled) {
             this.mAxisRight.calculate(this.mData.getYMin(AxisDependency.RIGHT), this.mData.getYMax(AxisDependency.RIGHT));
         }
     }
@@ -260,23 +318,24 @@ export class BarLineChartBase extends Chart {
         offsets.right = 0;
         offsets.top = 0;
         offsets.bottom = 0;
-        if (this.mLegend != null && this.mLegend.isEnabled() && !this.mLegend.isDrawInsideEnabled()) {
-            switch (this.mLegend.getOrientation()) {
+        // setup offsets for legend
+        if (this.mLegend?.enabled && !this.mLegend.drawInside) {
+            switch (this.mLegend.orientation) {
                 case LegendOrientation.VERTICAL:
-                    switch (this.mLegend.getHorizontalAlignment()) {
+                    switch (this.mLegend.horizontalAlignment) {
                         case LegendHorizontalAlignment.LEFT:
-                            offsets.left += Math.min(this.mLegend.mNeededWidth, this.mViewPortHandler.getChartWidth() * this.mLegend.getMaxSizePercent()) + this.mLegend.getXOffset();
+                            offsets.left += Math.min(this.mLegend.mNeededWidth, this.viewPortHandler.chartWidth * this.mLegend.maxSizePercent) + this.mLegend.xOffset;
                             break;
                         case LegendHorizontalAlignment.RIGHT:
-                            offsets.right += Math.min(this.mLegend.mNeededWidth, this.mViewPortHandler.getChartWidth() * this.mLegend.getMaxSizePercent()) + this.mLegend.getXOffset();
+                            offsets.right += Math.min(this.mLegend.mNeededWidth, this.viewPortHandler.chartWidth * this.mLegend.maxSizePercent) + this.mLegend.xOffset;
                             break;
                         case LegendHorizontalAlignment.CENTER:
-                            switch (this.mLegend.getVerticalAlignment()) {
+                            switch (this.mLegend.verticalAlignment) {
                                 case LegendVerticalAlignment.TOP:
-                                    offsets.top += Math.min(this.mLegend.mNeededHeight, this.mViewPortHandler.getChartHeight() * this.mLegend.getMaxSizePercent()) + this.mLegend.getYOffset();
+                                    offsets.top += Math.min(this.mLegend.mNeededHeight, this.viewPortHandler.chartHeight * this.mLegend.maxSizePercent) + this.mLegend.yOffset;
                                     break;
                                 case LegendVerticalAlignment.BOTTOM:
-                                    offsets.bottom += Math.min(this.mLegend.mNeededHeight, this.mViewPortHandler.getChartHeight() * this.mLegend.getMaxSizePercent()) + this.mLegend.getYOffset();
+                                    offsets.bottom += Math.min(this.mLegend.mNeededHeight, this.viewPortHandler.chartHeight * this.mLegend.maxSizePercent) + this.mLegend.yOffset;
                                     break;
                                 default:
                                     break;
@@ -284,12 +343,12 @@ export class BarLineChartBase extends Chart {
                     }
                     break;
                 case LegendOrientation.HORIZONTAL:
-                    switch (this.mLegend.getVerticalAlignment()) {
+                    switch (this.mLegend.verticalAlignment) {
                         case LegendVerticalAlignment.TOP:
-                            offsets.top += Math.min(this.mLegend.mNeededHeight, this.mViewPortHandler.getChartHeight() * this.mLegend.getMaxSizePercent()) + this.mLegend.getYOffset();
+                            offsets.top += Math.min(this.mLegend.mNeededHeight, this.viewPortHandler.chartHeight * this.mLegend.maxSizePercent) + this.mLegend.yOffset;
                             break;
                         case LegendVerticalAlignment.BOTTOM:
-                            offsets.bottom += Math.min(this.mLegend.mNeededHeight, this.mViewPortHandler.getChartHeight() * this.mLegend.getMaxSizePercent()) + this.mLegend.getYOffset();
+                            offsets.bottom += Math.min(this.mLegend.mNeededHeight, this.viewPortHandler.chartHeight * this.mLegend.maxSizePercent) + this.mLegend.yOffset;
                             break;
                         default:
                             break;
@@ -299,10 +358,10 @@ export class BarLineChartBase extends Chart {
         }
     }
     calculateOffsets(force = true) {
-        if (this.mOffsetsCalculated && !force) {
+        if (this.offsetsCalculated && !force) {
             return;
         }
-        this.mOffsetsCalculated = true;
+        this.offsetsCalculated = true;
         if (!this.mCustomViewPortEnabled) {
             const offsetBuffer = Utils.getTempRectF();
             this.calculateLegendOffsets(offsetBuffer);
@@ -310,407 +369,737 @@ export class BarLineChartBase extends Chart {
             let offsetTop = offsetBuffer.top;
             let offsetRight = offsetBuffer.right;
             let offsetBottom = offsetBuffer.bottom;
-            if (this.mAxisLeft && this.mAxisLeft.needsOffset()) {
-                offsetLeft += this.mAxisLeft.getRequiredWidthSpace(this.mAxisRendererLeft.axisLabelsPaint);
+            // offsets for y-labels
+            if (this.mAxisLeft?.needsOffset) {
+                offsetLeft += this.mAxisLeft.getRequiredWidthSpace(this.rendererLeftYAxis.axisLabelsPaint);
             }
-            if (this.mAxisRight && this.mAxisRight.needsOffset()) {
-                offsetRight += this.mAxisRight.getRequiredWidthSpace(this.mAxisRendererRight.axisLabelsPaint);
+            if (this.mAxisRight?.needsOffset) {
+                offsetRight += this.mAxisRight.getRequiredWidthSpace(this.rendererRightYAxis.axisLabelsPaint);
             }
-            if (this.mXAxis.isEnabled() && this.mXAxis.isDrawLabelsEnabled()) {
-                const xLabelHeight = this.mXAxis.mLabelRotatedHeight + this.mXAxis.getYOffset();
-                if (this.mXAxis.getPosition() === XAxisPosition.BOTTOM) {
+            if (this.xAxis.enabled && this.xAxis.drawLabels) {
+                const xLabelHeight = this.xAxis.mLabelRotatedHeight + this.xAxis.yOffset;
+                // offsets for x-labels
+                if (this.xAxis.position === XAxisPosition.BOTTOM) {
                     offsetBottom += xLabelHeight;
                 }
-                else if (this.mXAxis.getPosition() === XAxisPosition.TOP) {
+                else if (this.xAxis.position === XAxisPosition.TOP) {
                     offsetTop += xLabelHeight;
                 }
-                else if (this.mXAxis.getPosition() === XAxisPosition.BOTH_SIDED) {
+                else if (this.xAxis.position === XAxisPosition.BOTH_SIDED) {
                     offsetBottom += xLabelHeight;
                     offsetTop += xLabelHeight;
                 }
             }
-            offsetTop += this.getExtraTopOffset();
-            offsetRight += this.getExtraRightOffset();
-            offsetBottom += this.getExtraBottomOffset();
-            offsetLeft += this.getExtraLeftOffset();
-            const minOffset = this.mMinOffset;
-            this.mViewPortHandler.restrainViewPort(Math.max(minOffset, offsetLeft), Math.max(minOffset, offsetTop), Math.max(minOffset, offsetRight), Math.max(minOffset, offsetBottom));
+            offsetTop += this.extraTopOffset;
+            offsetRight += this.extraRightOffset;
+            offsetBottom += this.extraBottomOffset;
+            offsetLeft += this.extraLeftOffset;
+            const minOffset = this.minOffset;
+            this.viewPortHandler.restrainViewPort(Math.max(minOffset, offsetLeft), Math.max(minOffset, offsetTop), Math.max(minOffset, offsetRight), Math.max(minOffset, offsetBottom));
             if (Trace.isEnabled()) {
                 CLog(CLogTypes.info, LOG_TAG, 'offsetLeft: ' + offsetLeft + ', offsetTop: ' + offsetTop + ', offsetRight: ' + offsetRight + ', offsetBottom: ' + offsetBottom);
-                CLog(CLogTypes.info, LOG_TAG, 'Content: ' + this.mViewPortHandler.getContentRect().toString());
+                CLog(CLogTypes.info, LOG_TAG, 'Content: ' + this.viewPortHandler.contentRect.toString());
             }
         }
         this.prepareOffsetMatrix();
         this.prepareValuePxMatrix();
     }
+    /**
+     * draws the grid background
+     */
     drawGridBackground(c) {
-        if (this.mDrawGridBackground) {
-            c.drawRect(this.mViewPortHandler.getContentRect(), this.gridBackgroundPaint);
+        if (this.drawGridBackgroundEnabled) {
+            // draw the grid background
+            c.drawRect(this.viewPortHandler.contentRect, this.gridBackgroundPaint);
         }
-        if (this.mDrawBorders) {
-            c.drawRect(this.mViewPortHandler.getContentRect(), this.borderPaint);
+        if (this.drawBorders) {
+            c.drawRect(this.viewPortHandler.contentRect, this.borderPaint);
         }
     }
+    /**
+     * Returns the Transformer class that contains all matrices and is
+     * responsible for transforming values into pixels on the screen and
+     * backwards.
+     */
     getTransformer(which) {
         if (which === undefined) {
-            if (this.getAxisLeft().isEnabled()) {
-                return this.mLeftAxisTransformer;
-            }
-            return this.mRightAxisTransformer;
+            return this.transformer;
         }
         if (which === AxisDependency.LEFT)
-            return this.mLeftAxisTransformer;
+            return this.leftAxisTransformer;
         else
-            return this.mRightAxisTransformer;
+            return this.rightAxisTransformer;
+    }
+    get transformer() {
+        if (this.mAxisLeft.enabled) {
+            return this.leftAxisTransformer;
+        }
+        return this.rightAxisTransformer;
     }
+    /**
+     * Zooms in by 1.4f, into the charts center.
+     */
     zoomIn() {
-        const center = this.mViewPortHandler.getContentCenter();
-        this.mViewPortHandler.zoomIn(center.x, -center.y, this.mZoomMatrixBuffer);
-        this.mViewPortHandler.refresh(this.mZoomMatrixBuffer, this, false);
+        const center = this.viewPortHandler.contentCenter;
+        this.viewPortHandler.zoomIn(center.x, -center.y, this.mZoomMatrixBuffer);
+        this.viewPortHandler.refresh(this.mZoomMatrixBuffer, this, false);
+        // Range might have changed, which means that Y-axis labels
+        // could have changed in size, affecting Y-axis size.
+        // So we need to recalculate offsets.
         this.calculateOffsets();
         this.invalidate();
     }
+    /**
+     * Zooms out by 0.7f, from the charts center.
+     */
     zoomOut() {
-        const center = this.mViewPortHandler.getContentCenter();
-        this.mViewPortHandler.zoomOut(center.x, -center.y, this.mZoomMatrixBuffer);
-        this.mViewPortHandler.refresh(this.mZoomMatrixBuffer, this, false);
+        const center = this.viewPortHandler.contentCenter;
+        this.viewPortHandler.zoomOut(center.x, -center.y, this.mZoomMatrixBuffer);
+        this.viewPortHandler.refresh(this.mZoomMatrixBuffer, this, false);
+        // Range might have changed, which means that Y-axis labels
+        // could have changed in size, affecting Y-axis size.
+        // So we need to recalculate offsets.
         this.calculateOffsets();
         this.invalidate();
     }
+    /**
+     * Zooms out to original size.
+     */
     resetZoom() {
-        this.mViewPortHandler.mMatrixTouch.reset();
-        this.mViewPortHandler.resetZoom(this.mZoomMatrixBuffer);
-        this.mViewPortHandler.refresh(this.mZoomMatrixBuffer, this, false);
+        this.viewPortHandler.mMatrixTouch.reset();
+        this.viewPortHandler.resetZoom(this.mZoomMatrixBuffer);
+        this.viewPortHandler.refresh(this.mZoomMatrixBuffer, this, false);
+        // Range might have changed, which means that Y-axis labels
+        // could have changed in size, affecting Y-axis size.
+        // So we need to recalculate offsets.
         this.calculateOffsets();
         this.invalidate();
     }
+    /**
+     * Zooms in or out by the given scale factor. x and y are the coordinates
+     * (in pixels) of the zoom center.
+     *
+     * @param scaleX if < 1 --> zoom out, if > 1 --> zoom in
+     * @param scaleY if < 1 --> zoom out, if > 1 --> zoom in
+     * @param x
+     * @param y
+     */
     zoom(scaleX, scaleY, x, y) {
-        this.mViewPortHandler.zoomAtPosition(scaleX, scaleY, x, y, this.mZoomMatrixBuffer);
-        this.mViewPortHandler.refresh(this.mZoomMatrixBuffer, this, false);
+        this.viewPortHandler.zoomAtPosition(scaleX, scaleY, x, y, this.mZoomMatrixBuffer);
+        this.viewPortHandler.refresh(this.mZoomMatrixBuffer, this, false);
+        // Range might have changed, which  means that Y-axis labels
+        // could have changed in size, affecting Y-axis size.
+        // So we need to recalculate offsets.
         this.calculateOffsets();
         this.invalidate();
         if (this.hasListeners('zoom')) {
             this.notify({ eventName: 'zoom', object: this, scaleX, scaleY, x, y });
         }
     }
+    /**
+     * Zooms in or out by the given scale factor.
+     * x and y are the values (NOT PIXELS) of the zoom center..
+     *
+     * @param scaleX
+     * @param scaleY
+     * @param xValue
+     * @param yValue
+     * @param axis   the axis relative to which the zoom should take place
+     */
     zoomAtValue(scaleX, scaleY, xValue, yValue, axis) {
-        const job = ZoomJob.getInstance(this.mViewPortHandler, scaleX, scaleY, xValue, yValue, this.getTransformer(axis), axis, this);
+        const job = ZoomJob.getInstance(this.viewPortHandler, scaleX, scaleY, xValue, yValue, this.getTransformer(axis), axis, this);
         this.addViewportJob(job);
     }
+    /**
+     * Zooms to the center of the chart with the given scale factor.
+     *
+     * @param scaleX
+     * @param scaleY
+     */
     zoomToCenter(scaleX, scaleY) {
-        const center = this.getCenterOffsets();
+        const center = this.centerOffsets;
         const save = this.mZoomMatrixBuffer;
-        this.mViewPortHandler.zoomAtPosition(scaleX, scaleY, center.x, -center.y, save);
-        this.mViewPortHandler.refresh(save, this, false);
-    }
+        this.viewPortHandler.zoomAtPosition(scaleX, scaleY, center.x, -center.y, save);
+        this.viewPortHandler.refresh(save, this, false);
+    }
+    /**
+     * Zooms by the specified scale factor to the specified values on the specified axis.
+     *
+     * @param scaleX
+     * @param scaleY
+     * @param xValue
+     * @param yValue
+     * @param axis
+     * @param duration
+     */
     zoomAndCenterAnimated(scaleX, scaleY, xValue, yValue, axis, duration) {
-        const origin = this.getValuesByTouchPoint(this.mViewPortHandler.contentLeft(), this.mViewPortHandler.contentTop(), axis);
-        const job = AnimatedZoomJob.getInstance(this.mViewPortHandler, this, this.getTransformer(axis), this.getAxis(axis), this.mXAxis.mAxisRange, scaleX, scaleY, this.mViewPortHandler.getScaleX(), this.mViewPortHandler.getScaleY(), xValue, yValue, origin.x, origin.y, duration);
+        const origin = this.getValuesByTouchPoint(this.viewPortHandler.contentLeft, this.viewPortHandler.contentTop, axis);
+        const job = AnimatedZoomJob.getInstance(this.viewPortHandler, this, this.getTransformer(axis), this.getAxis(axis), this.xAxis.axisRange, scaleX, scaleY, this.viewPortHandler.getScaleX(), this.viewPortHandler.getScaleY(), xValue, yValue, origin.x, origin.y, duration);
         this.addViewportJob(job);
     }
+    /**
+     * Zooms by the specified scale factor to the specified values on the specified axis.
+     *
+     * @param scaleX
+     * @param scaleY
+     * @param xValue
+     * @param yValue
+     * @param axis
+     */
     zoomAndCenter(scaleX, scaleY, xValue, yValue, axis) {
-        const origin = this.getValuesByTouchPoint(this.mViewPortHandler.contentLeft(), this.mViewPortHandler.contentTop(), axis);
-        const job = AnimatedZoomJob.getInstance(this.mViewPortHandler, this, this.getTransformer(axis), this.getAxis(axis), this.mXAxis.mAxisRange, scaleX, scaleY, this.mViewPortHandler.getScaleX(), this.mViewPortHandler.getScaleY(), xValue, yValue, origin.x, origin.y, 0);
-        job.setPhase(1);
+        const origin = this.getValuesByTouchPoint(this.viewPortHandler.contentLeft, this.viewPortHandler.contentTop, axis);
+        const job = AnimatedZoomJob.getInstance(this.viewPortHandler, this, this.getTransformer(axis), this.getAxis(axis), this.xAxis.axisRange, scaleX, scaleY, this.viewPortHandler.getScaleX(), this.viewPortHandler.getScaleY(), xValue, yValue, origin.x, origin.y, 0);
+        job.phase = 1;
         job.onAnimationUpdate(0);
     }
+    /**
+     * Resets all zooming and dragging and makes the chart fit exactly it's
+     * bounds.
+     */
     fitScreen() {
         const save = this.mFitScreenMatrixBuffer;
-        this.mViewPortHandler.fitScreen(save);
-        this.mViewPortHandler.refresh(save, this, false);
+        this.viewPortHandler.fitScreen(save);
+        this.viewPortHandler.refresh(save, this, false);
         this.calculateOffsets();
         this.invalidate();
     }
+    /**
+     * Sets the minimum scale factor value to which can be zoomed out. 1 =
+     * fitScreen
+     *
+     * @param scaleX
+     * @param scaleY
+     */
     setScaleMinima(scaleX, scaleY) {
-        this.mViewPortHandler.setMinimumScaleX(scaleX);
-        this.mViewPortHandler.setMinimumScaleY(scaleY);
-    }
-    setVisibleXRangeMaximum(maxXRange) {
-        const xScale = this.mXAxis.mAxisRange / maxXRange;
-        this.mViewPortHandler.setMinimumScaleX(xScale);
-    }
-    setVisibleXRangeMinimum(minXRange) {
-        const xScale = this.mXAxis.mAxisRange / minXRange;
-        this.mViewPortHandler.setMaximumScaleX(xScale);
-    }
+        this.viewPortHandler.setMinimumScaleX(scaleX);
+        this.viewPortHandler.setMinimumScaleY(scaleY);
+    }
+    /**
+     * Sets the  scale factor. 1 =
+     * fitScreen
+     *
+     * @param scaleX
+     * @param scaleY
+     */
+    setScale(scaleX, scaleY) {
+        this.viewPortHandler.setScale(scaleX, scaleY);
+    }
+    /**
+     * Sets the size of the area (range on the x-axis) that should be maximum
+     * visible at once (no further zooming out allowed). If this is e.g. set to
+     * 10, no more than a range of 10 on the x-axis can be viewed at once without
+     * scrolling.
+     *
+     * @param maxXRange The maximum visible range of x-values.
+     */
+    set visibleXRangeMaximum(maxXRange) {
+        const xScale = this.xAxis.axisRange / maxXRange;
+        this.viewPortHandler.setMinimumScaleX(xScale);
+    }
+    /**
+     * Sets the size of the area (range on the x-axis) that should be minimum
+     * visible at once (no further zooming in allowed). If this is e.g. set to
+     * 10, no less than a range of 10 on the x-axis can be viewed at once without
+     * scrolling.
+     *
+     * @param minXRange The minimum visible range of x-values.
+     */
+    set visibleXRangeMinimum(minXRange) {
+        const xScale = this.xAxis.axisRange / minXRange;
+        this.viewPortHandler.setMaximumScaleX(xScale);
+    }
+    /**
+     * Limits the maximum and minimum x range that can be visible by pinching and zooming. e.g. minRange=10, maxRange=100 the
+     * smallest range to be displayed at once is 10, and no more than a range of 100 values can be viewed at once without
+     * scrolling
+     *
+     * @param minXRange
+     * @param maxXRange
+     */
     setVisibleXRange(minXRange, maxXRange) {
-        const minScale = this.mXAxis.mAxisRange / minXRange;
-        const maxScale = this.mXAxis.mAxisRange / maxXRange;
-        this.mViewPortHandler.setMinMaxScaleX(minScale, maxScale);
-    }
+        const minScale = this.xAxis.axisRange / minXRange;
+        const maxScale = this.xAxis.axisRange / maxXRange;
+        this.viewPortHandler.setMinMaxScaleX(minScale, maxScale);
+    }
+    /**
+     * Sets the size of the area (range on the y-axis) that should be maximum
+     * visible at once.
+     *
+     * @param maxYRange the maximum visible range on the y-axis
+     * @param axis      the axis for which this limit should apply
+     */
     setVisibleYRangeMaximum(maxYRange, axis) {
         const yScale = this.getAxisRange(axis) / maxYRange;
-        this.mViewPortHandler.setMinimumScaleY(yScale);
-    }
+        this.viewPortHandler.setMinimumScaleY(yScale);
+    }
+    /**
+     * Sets the size of the area (range on the y-axis) that should be minimum visible at once, no further zooming in possible.
+     *
+     * @param minYRange
+     * @param axis      the axis for which this limit should apply
+     */
     setVisibleYRangeMinimum(minYRange, axis) {
         const yScale = this.getAxisRange(axis) / minYRange;
-        this.mViewPortHandler.setMaximumScaleY(yScale);
-    }
+        this.viewPortHandler.setMaximumScaleY(yScale);
+    }
+    /**
+     * Limits the maximum and minimum y range that can be visible by pinching and zooming.
+     *
+     * @param minYRange
+     * @param maxYRange
+     * @param axis
+     */
     setVisibleYRange(minYRange, maxYRange, axis) {
         const minScale = this.getAxisRange(axis) / minYRange;
         const maxScale = this.getAxisRange(axis) / maxYRange;
-        this.mViewPortHandler.setMinMaxScaleY(minScale, maxScale);
-    }
+        this.viewPortHandler.setMinMaxScaleY(minScale, maxScale);
+    }
+    /**
+     * Moves the left side of the current viewport to the specified x-position.
+     * This also refreshes the chart by calling invalidate().
+     *
+     * @param xValue
+     */
     moveViewToX(xValue) {
-        const job = MoveViewJob.getInstance(this.mViewPortHandler, xValue, 0, this.getTransformer(), this);
+        const job = MoveViewJob.getInstance(this.viewPortHandler, xValue, 0, this.transformer, this);
         this.addViewportJob(job);
     }
+    /**
+     * This will move the left side of the current viewport to the specified
+     * x-value on the x-axis, and center the viewport to the specified y value on the y-axis.
+     * This also refreshes the chart by calling invalidate().
+     *
+     * @param xValue
+     * @param yValue
+     * @param axis   - which axis should be used as a reference for the y-axis
+     */
     moveViewTo(xValue, yValue, axis) {
-        const yInView = this.getAxisRange(axis) / this.mViewPortHandler.getScaleY();
-        const job = MoveViewJob.getInstance(this.mViewPortHandler, xValue, yValue + yInView / 2, this.getTransformer(axis), this);
+        const yInView = this.getAxisRange(axis) / this.viewPortHandler.getScaleY();
+        const job = MoveViewJob.getInstance(this.viewPortHandler, xValue, yValue + yInView / 2, this.getTransformer(axis), this);
         this.addViewportJob(job);
     }
+    /**
+     * This will move the left side of the current viewport to the specified x-value
+     * and center the viewport to the y value animated.
+     * This also refreshes the chart by calling invalidate().
+     *
+     * @param xValue
+     * @param yValue
+     * @param axis
+     * @param duration the duration of the animation in milliseconds
+     */
     moveViewToAnimated(xValue, yValue, axis, duration) {
-        const bounds = this.getValuesByTouchPoint(this.mViewPortHandler.contentLeft(), this.mViewPortHandler.contentTop(), axis);
-        const yInView = this.getAxisRange(axis) / this.mViewPortHandler.getScaleY();
-        const job = AnimatedMoveViewJob.getInstance(this.mViewPortHandler, xValue, yValue + yInView / 2, this.getTransformer(axis), this, bounds.x, bounds.y, duration);
+        const bounds = this.getValuesByTouchPoint(this.viewPortHandler.contentLeft, this.viewPortHandler.contentTop, axis);
+        const yInView = this.getAxisRange(axis) / this.viewPortHandler.getScaleY();
+        const job = AnimatedMoveViewJob.getInstance(this.viewPortHandler, xValue, yValue + yInView / 2, this.getTransformer(axis), this, bounds.x, bounds.y, duration);
         this.addViewportJob(job);
-    }
+        // MPPointD.recycleInstance(bounds);
+    }
+    /**
+     * Centers the viewport to the specified y value on the y-axis.
+     * This also refreshes the chart by calling invalidate().
+     *
+     * @param yValue
+     * @param axis   - which axis should be used as a reference for the y-axis
+     */
     centerViewToY(yValue, axis) {
-        const valsInView = this.getAxisRange(axis) / this.mViewPortHandler.getScaleY();
-        const job = MoveViewJob.getInstance(this.mViewPortHandler, 0, yValue + valsInView / 2, this.getTransformer(axis), this);
+        const valsInView = this.getAxisRange(axis) / this.viewPortHandler.getScaleY();
+        const job = MoveViewJob.getInstance(this.viewPortHandler, 0, yValue + valsInView / 2, this.getTransformer(axis), this);
         this.addViewportJob(job);
     }
+    /**
+     * This will move the center of the current viewport to the specified
+     * x and y value.
+     * This also refreshes the chart by calling invalidate().
+     *
+     * @param xValue
+     * @param yValue
+     * @param axis   - which axis should be used as a reference for the y axis
+     */
     centerViewTo(xValue, yValue, axis) {
-        const yInView = this.getAxisRange(axis) / this.mViewPortHandler.getScaleY();
-        const xInView = this.getXAxis().mAxisRange / this.mViewPortHandler.getScaleX();
-        const job = MoveViewJob.getInstance(this.mViewPortHandler, xValue - xInView / 2, yValue + yInView / 2, this.getTransformer(axis), this);
+        const yInView = this.getAxisRange(axis) / this.viewPortHandler.getScaleY();
+        const xInView = this.xAxis.axisRange / this.viewPortHandler.getScaleX();
+        const job = MoveViewJob.getInstance(this.viewPortHandler, xValue - xInView / 2, yValue + yInView / 2, this.getTransformer(axis), this);
         this.addViewportJob(job);
     }
+    /**
+     * This will move the center of the current viewport to the specified
+     * x and y value animated.
+     *
+     * @param xValue
+     * @param yValue
+     * @param axis
+     * @param duration the duration of the animation in milliseconds
+     */
     centerViewToAnimated(xValue, yValue, axis, duration) {
-        const bounds = this.getValuesByTouchPoint(this.mViewPortHandler.contentLeft(), this.mViewPortHandler.contentTop(), axis);
-        const yInView = this.getAxisRange(axis) / this.mViewPortHandler.getScaleY();
-        const xInView = this.getXAxis().mAxisRange / this.mViewPortHandler.getScaleX();
-        const job = AnimatedMoveViewJob.getInstance(this.mViewPortHandler, xValue - xInView / 2, yValue + yInView / 2, this.getTransformer(axis), this, bounds.x, bounds.y, duration);
+        const bounds = this.getValuesByTouchPoint(this.viewPortHandler.contentLeft, this.viewPortHandler.contentTop, axis);
+        const yInView = this.getAxisRange(axis) / this.viewPortHandler.getScaleY();
+        const xInView = this.xAxis.axisRange / this.viewPortHandler.getScaleX();
+        const job = AnimatedMoveViewJob.getInstance(this.viewPortHandler, xValue - xInView / 2, yValue + yInView / 2, this.getTransformer(axis), this, bounds.x, bounds.y, duration);
         this.addViewportJob(job);
-    }
+        // MPPointD.recycleInstance(bounds);
+    }
+    /**
+     * Sets custom offsets for the current ViewPort (the offsets on the sides of
+     * the actual chart window). Setting this will prevent the chart from
+     * automatically calculating it's offsets. Use resetViewPortOffsets() to
+     * undo this. ONLY USE THIS WHEN YOU KNOW WHAT YOU ARE DOING, else use
+     * setExtraOffsets(...).
+     *
+     * @param left
+     * @param top
+     * @param right
+     * @param bottom
+     */
     setViewPortOffsets(left, top, right, bottom) {
         this.mCustomViewPortEnabled = true;
-        this.mViewPortHandler.restrainViewPort(left, top, right, bottom);
+        // post(new Runnable() {
+        //     public run() {
+        this.viewPortHandler.restrainViewPort(left, top, right, bottom);
         this.prepareOffsetMatrix();
         this.prepareValuePxMatrix();
+        // }
+        // });
     }
+    /**
+     * Resets all custom offsets set via setViewPortOffsets(...) method. Allows
+     * the chart to again calculate all offsets automatically.
+     */
     resetViewPortOffsets() {
         this.mCustomViewPortEnabled = false;
         this.calculateOffsets();
     }
+    /**
+     * ################ ################ ################ ################
+     */
+    /** CODE BELOW IS GETTERS AND SETTERS */
+    /**
+     * Returns the range of the specified axis.
+     *
+     * @param axis
+     * @return
+     */
     getAxisRange(axis) {
         if (axis === AxisDependency.LEFT)
-            return this.mAxisLeft.mAxisRange;
+            return this.mAxisLeft.axisRange;
         else
-            return this.mAxisRight && this.mAxisRight.mAxisRange;
-    }
-    setMaxVisibleValueCount(count) {
-        this.mMaxVisibleCount = count;
-    }
-    getMaxVisibleCount() {
-        return this.mMaxVisibleCount;
-    }
-    setHighlightPerDragEnabled(enabled) {
+            return this.mAxisRight && this.mAxisRight.axisRange;
+    }
+    /**
+     * Returns a recyclable MPPointF instance.
+     * Returns the position (in pixels) the provided Entry has inside the chart
+     * view or null, if the provided Entry is null.
+     *
+     * @param e
+     * @return
+     */
+    getPosition(e, axis) {
+        if (!e)
+            return null;
+        const pts = Utils.getTempArray(2);
+        pts[0] = e.getX();
+        pts[1] = e.getY();
+        this.getTransformer(axis).pointValuesToPixel(pts);
+        return { x: pts[0], y: pts[1] };
+    }
+    /**
+     * Set this to true to allow highlighting per dragging over the chart
+     * surface when it is fully zoomed out. Default: true
+     *
+     * @param enabled
+     */
+    set highlightPerDragEnabled(enabled) {
         this.mHighlightPerDragEnabled = enabled;
         if (enabled) {
             this.getOrCreateBarTouchListener().setPan(true);
         }
-        else if (this.mChartTouchListener) {
-            this.mChartTouchListener.setPan(false);
+        else if (this.chartTouchListener) {
+            this.chartTouchListener.setPan(false);
         }
     }
-    isHighlightPerDragEnabled() {
+    get highlightPerDragEnabled() {
         return this.mHighlightPerDragEnabled;
     }
-    setGridBackgroundColor(color) {
+    /**
+     * Sets the color for the background of the chart-drawing area (everything
+     * behind the grid lines).
+     *
+     * @param color
+     */
+    set gridBackgroundColor(color) {
         this.gridBackgroundPaint.setColor(color);
     }
-    setDragEnabled(enabled) {
-        this.mDragXEnabled = enabled;
-        this.mDragYEnabled = enabled;
+    /**
+     * Set this to true to enable dragging (moving the chart with the finger)
+     * for the chart (this does not effect scaling).
+     *
+     * @param enabled
+     */
+    set dragEnabled(enabled) {
+        this.dragXEnabled = enabled;
+        this.dragYEnabled = enabled;
         if (enabled) {
             this.getOrCreateBarTouchListener().setPan(true);
         }
-        else if (this.mChartTouchListener) {
-            this.mChartTouchListener.setPan(false);
+        else if (this.chartTouchListener) {
+            this.chartTouchListener.setPan(false);
         }
     }
-    isDragEnabled() {
-        return this.mDragXEnabled || this.mDragYEnabled;
-    }
-    setDragXEnabled(enabled) {
-        this.mDragXEnabled = enabled;
+    /**
+     * Returns true if dragging is enabled for the chart, false if not.
+     */
+    get dragEnabled() {
+        return this.dragXEnabled || this.dragYEnabled;
     }
-    isDragXEnabled() {
-        return this.mDragXEnabled;
-    }
-    setDragYEnabled(enabled) {
-        this.mDragYEnabled = enabled;
-    }
-    isDragYEnabled() {
-        return this.mDragYEnabled;
-    }
-    setScaleEnabled(enabled) {
+    /**
+     * Set this to true to enable scaling (zooming in and out by gesture) for
+     * the chart (this does not effect dragging) on both X- and Y-Axis.
+     *
+     * @param enabled
+     */
+    set scaleEnabled(enabled) {
         this.mScaleXEnabled = enabled;
         this.mScaleYEnabled = enabled;
         if (enabled) {
             this.getOrCreateBarTouchListener().setPinch(true);
         }
-        else if (this.mChartTouchListener) {
-            this.mChartTouchListener.setPinch(false);
+        else if (this.chartTouchListener) {
+            this.chartTouchListener.setPinch(false);
         }
     }
-    setScaleXEnabled(enabled) {
+    set scaleXEnabled(enabled) {
         this.mScaleXEnabled = enabled;
         if (enabled) {
             this.getOrCreateBarTouchListener().setPinch(true);
         }
-        else if (!this.mScaleYEnabled && this.mChartTouchListener) {
-            this.mChartTouchListener.setPinch(false);
+        else if (!this.mScaleYEnabled && this.chartTouchListener) {
+            this.chartTouchListener.setPinch(false);
         }
     }
-    setScaleYEnabled(enabled) {
+    get scaleXEnabled() {
+        return this.mScaleXEnabled;
+    }
+    set scaleYEnabled(enabled) {
         this.mScaleYEnabled = enabled;
         if (enabled) {
             this.getOrCreateBarTouchListener().setPinch(true);
         }
-        else if (!this.mScaleXEnabled && this.mChartTouchListener) {
-            this.mChartTouchListener.setPinch(false);
+        else if (!this.mScaleXEnabled && this.chartTouchListener) {
+            this.chartTouchListener.setPinch(false);
         }
     }
-    isScaleXEnabled() {
-        return this.mScaleXEnabled;
-    }
-    isScaleYEnabled() {
+    get scaleYEnabled() {
         return this.mScaleYEnabled;
     }
-    setDoubleTapToZoomEnabled(enabled) {
+    /**
+     * Set this to true to enable zooming in by double-tap on the chart.
+     * Default: enabled
+     *
+     * @param enabled
+     */
+    set doubleTapToZoomEnabled(enabled) {
         this.mDoubleTapToZoomEnabled = enabled;
         if (enabled) {
             this.getOrCreateBarTouchListener().setDoubleTap(true);
         }
-        else if (this.mChartTouchListener) {
-            this.mChartTouchListener.setDoubleTap(false);
+        else if (this.chartTouchListener) {
+            this.chartTouchListener.setDoubleTap(false);
         }
     }
-    setHighlightPerTapEnabled(enabled) {
-        super.setHighlightPerTapEnabled(enabled);
+    /**
+     * Returns true if zooming via double-tap is enabled false if not.
+     */
+    get doubleTapToZoomEnabled() {
+        return this.mDoubleTapToZoomEnabled;
+    }
+    set highlightPerTapEnabled(enabled) {
+        this.mHighlightPerTapEnabled = enabled;
         if (enabled) {
             this.getOrCreateBarTouchListener().setTap(true);
         }
-        else if (this.mChartTouchListener) {
-            this.mChartTouchListener.setTap(false);
+        else if (this.chartTouchListener) {
+            this.chartTouchListener.setTap(false);
         }
     }
-    isDoubleTapToZoomEnabled() {
-        return this.mDoubleTapToZoomEnabled;
-    }
-    setDrawGridBackground(enabled) {
-        this.mDrawGridBackground = enabled;
-    }
-    setDrawBorders(enabled) {
-        this.mDrawBorders = enabled;
-    }
-    isDrawBordersEnabled() {
-        return this.mDrawBorders;
-    }
-    setClipValuesToContent(enabled) {
-        this.mClipValuesToContent = enabled;
-    }
-    isClipValuesToContentEnabled() {
-        return this.mClipValuesToContent;
-    }
-    setClipDataToContent(enabled) {
-        this.mClipDataToContent = enabled;
-    }
-    isClipDataToContentEnabled() {
-        return this.mClipDataToContent;
-    }
-    setDrawHighlight(enabled) {
-        this.mDrawHighlight = enabled;
-    }
-    isDrawHighlightEnabled() {
-        return this.mDrawHighlight;
+    get highlightPerTapEnabled() {
+        return this.mHighlightPerTapEnabled;
     }
+    /**
+     * Sets the width of the border lines in dp.
+     *
+     * @param width
+     */
     setBorderWidth(width) {
         this.borderPaint.setStrokeWidth(width);
     }
+    /**
+     * Sets the color of the chart border lines.
+     *
+     * @param color
+     */
     setBorderColor(color) {
         this.borderPaint.setColor(color);
     }
-    getMinOffset() {
-        return this.mMinOffset;
-    }
-    setMinOffset(minOffset) {
-        this.mMinOffset = minOffset;
-    }
-    isKeepPositionOnRotation() {
-        return this.mKeepPositionOnRotation;
-    }
-    setKeepPositionOnRotation(keepPositionOnRotation) {
-        this.mKeepPositionOnRotation = keepPositionOnRotation;
-    }
+    /**
+     * Returns a recyclable MPPointD instance
+     * Returns the x and y values in the chart at the given touch point
+     * (encapsulated in a MPPointD). This method transforms pixel coordinates to
+     * coordinates / values in the chart. This is the opposite method to
+     * getPixelForValues(...).
+     *
+     * @param x
+     * @param y
+     * @return
+     */
+    // public  getValuesByTouchPoint( x ,y,  axis) {
+    //     const result = {x:0, y:0};
+    //     this.getValuesByTouchPoint(x, y, axis, result);
+    //     return result;
+    // }
     getValuesByTouchPoint(x, y, axis) {
         return this.getTransformer(axis).getValuesByTouchPoint(x, y);
     }
+    /**
+     * Returns a recyclable MPPointD instance
+     * Transforms the given chart values into pixels. This is the opposite
+     * method to getValuesByTouchPoint(...).
+     *
+     * @param x
+     * @param y
+     * @return
+     */
     getPixelForValues(x, y, axis) {
         return this.getTransformer(axis).getPixelForValues(x, y);
     }
+    /**
+     * Returns a recyclable MPPointD instance
+     * Transforms the given chart values into pixels. This is the opposite
+     * method to getValuesByTouchPoint(...).
+     *
+     * @param set
+     * @param entry
+     * @param entry
+     * @return
+     */
+    getPixelForEntry(set, entry, index) {
+        const xVal = set.getEntryXValue(entry, index);
+        return this.getTransformer(set.axisDependency).getPixelForValues(xVal, set.getEntryYValue(entry));
+        // return this.getTransformer(axis).getPixelForValues(x, y);
+    }
+    /**
+     * returns the Entry object displayed at the touched position of the chart
+     *
+     * @param x
+     * @param y
+     * @return
+     */
     getEntryByTouchPoint(x, y) {
         const h = this.getHighlightByTouchPoint(x, y);
-        if (h != null) {
+        if (h) {
             return this.mData.getEntryForHighlight(h);
         }
         return null;
     }
+    /**
+     * returns the DataSet object displayed at the touched position of the chart
+     *
+     * @param x
+     * @param y
+     * @return
+     */
     getDataSetByTouchPoint(x, y) {
         const h = this.getHighlightByTouchPoint(x, y);
-        if (h != null) {
+        if (h) {
             return this.mData.getDataSetByIndex(h.dataSetIndex);
         }
         return null;
     }
-    getLowestVisibleX() {
-        this.getTransformer().getValuesByTouchPoint(this.mViewPortHandler.contentLeft(), this.mViewPortHandler.contentBottom(), this.posForGetLowestVisibleX);
-        const result = Math.max(this.mXAxis.mAxisMinimum, this.posForGetLowestVisibleX.x);
+    /**
+     * Returns the lowest x-index (value on the x-axis) that is still visible on
+     * the chart.
+     */
+    get lowestVisibleX() {
+        this.transformer.getValuesByTouchPoint(this.viewPortHandler.contentLeft, this.viewPortHandler.contentBottom, this.posForGetLowestVisibleX);
+        const result = Math.max(this.xAxis.axisMinimum, this.posForGetLowestVisibleX.x);
         return result;
     }
-    getHighestVisibleX() {
-        this.getTransformer().getValuesByTouchPoint(this.mViewPortHandler.contentRight(), this.mViewPortHandler.contentBottom(), this.posForGetHighestVisibleX);
-        const result = Math.min(this.mXAxis.mAxisMaximum, this.posForGetHighestVisibleX.x);
+    /**
+     * Returns the highest x-index (value on the x-axis) that is still visible
+     * on the chart.
+     */
+    get highestVisibleX() {
+        this.transformer.getValuesByTouchPoint(this.viewPortHandler.contentRight, this.viewPortHandler.contentBottom, this.posForGetHighestVisibleX);
+        const result = Math.min(this.xAxis.axisMaximum, this.posForGetHighestVisibleX.x);
         return result;
     }
+    /**
+     * Returns the range visible on the x-axis.
+     */
     getVisibleXRange() {
-        return Math.abs(this.getHighestVisibleX() - this.getLowestVisibleX());
+        return Math.abs(this.highestVisibleX - this.lowestVisibleX);
     }
+    /**
+     * returns the current x-scale factor
+     */
     getScaleX() {
-        if (this.mViewPortHandler == null)
+        if (this.viewPortHandler == null)
             return 1;
         else
-            return this.mViewPortHandler.getScaleX();
+            return this.viewPortHandler.getScaleX();
     }
+    /**
+     * returns the current y-scale factor
+     */
     getScaleY() {
-        if (this.mViewPortHandler == null)
+        if (this.viewPortHandler == null)
             return 1;
         else
-            return this.mViewPortHandler.getScaleY();
+            return this.viewPortHandler.getScaleY();
     }
+    /**
+     * if the chart is fully zoomed out, return true
+     */
     isFullyZoomedOut() {
-        return this.mViewPortHandler.isFullyZoomedOut();
+        return this.viewPortHandler.isFullyZoomedOut();
     }
+    /**
+     * Returns the left y-axis object. In the horizontal bar-chart, this is the
+     * top axis.
+     */
+    get leftAxis() {
+        return this.mAxisLeft;
+    }
+    /**
+     * @deprecated use leftAxis
+     */
     get axisLeft() {
         return this.mAxisLeft;
     }
-    get axisRight() {
+    /**
+     * Returns the right y-axis object. In the horizontal bar-chart, this is the
+     * bottom axis.
+     */
+    get rightAxis() {
         if (!this.mAxisRight) {
-            this.mAxisRight = new YAxis(AxisDependency.RIGHT);
-            this.mRightAxisTransformer = new Transformer(this.mViewPortHandler);
-            this.mAxisRendererRight = new YAxisRenderer(this.mViewPortHandler, this.mAxisRight, this.mRightAxisTransformer);
+            this.mAxisRight = new YAxis(AxisDependency.RIGHT, new WeakRef(this));
+            this.rightAxisTransformer = new Transformer(this.viewPortHandler);
+            this.rendererRightYAxis = new YAxisRenderer(this.viewPortHandler, this.mAxisRight, this.rightAxisTransformer);
         }
         return this.mAxisRight;
     }
-    getAxisLeft() {
-        return this.axisLeft;
-    }
-    getAxisRight() {
-        return this.axisRight;
-    }
+    /**
+     * @deprecated use rightAxis
+     */
+    get axisRight() {
+        return this.rightAxis;
+    }
+    /**
+     * Returns the y-axis object to the corresponding AxisDependency. In the
+     * horizontal bar-chart, LEFT == top, RIGHT == BOTTOM
+     *
+     * @param axis
+     * @return
+     */
     getAxis(axis) {
         if (axis === AxisDependency.LEFT)
             return this.mAxisLeft;
@@ -718,88 +1107,80 @@ export class BarLineChartBase extends Chart {
             return this.mAxisRight;
     }
     isInverted(axis) {
-        return this.getAxis(axis).isInverted();
-    }
-    setPinchZoom(enabled) {
-        this.mPinchZoomEnabled = enabled;
-    }
-    isPinchZoomEnabled() {
-        return this.mPinchZoomEnabled;
-    }
+        return this.getAxis(axis).inverted;
+    }
+    /**
+     * Set an offset in dp that allows the user to drag the chart over it's
+     * bounds on the x-axis.
+     *
+     * @param offset
+     */
     setDragOffsetX(offset) {
-        this.mViewPortHandler.setDragOffsetX(offset);
-    }
+        this.viewPortHandler.setDragOffsetX(offset);
+    }
+    /**
+     * Set an offset in dp that allows the user to drag the chart over it's
+     * bounds on the y-axis.
+     *
+     * @param offset
+     */
     setDragOffsetY(offset) {
-        this.mViewPortHandler.setDragOffsetY(offset);
+        this.viewPortHandler.setDragOffsetY(offset);
     }
+    /**
+     * Returns true if both drag offsets (x and y) are zero or smaller.
+     */
     hasNoDragOffset() {
-        return this.mViewPortHandler.hasNoDragOffset();
-    }
-    getRendererXAxis() {
-        return this.mXAxisRenderer;
+        return this.viewPortHandler.hasNoDragOffset();
     }
-    setXAxisRenderer(xAxisRenderer) {
-        this.mXAxisRenderer = xAxisRenderer;
-    }
-    getRendererLeftYAxis() {
-        return this.mAxisRendererLeft;
-    }
-    setRendererLeftYAxis(rendererLeftYAxis) {
-        this.mAxisRendererLeft = rendererLeftYAxis;
-    }
-    getRendererRightYAxis() {
-        return this.mAxisRendererRight;
-    }
-    setRendererRightYAxis(rendererRightYAxis) {
-        this.mAxisRendererRight = rendererRightYAxis;
-    }
-    getYChartMax() {
+    get yChartMax() {
         let max = -Infinity;
-        if (this.mAxisLeft.isEnabled()) {
-            max = Math.max(this.mAxisLeft.mAxisMaximum, max);
+        if (this.mAxisLeft.enabled) {
+            max = Math.max(this.mAxisLeft.axisMaximum, max);
         }
-        if (this.mAxisRight && this.mAxisRight.isEnabled()) {
-            max = Math.max(this.mAxisRight.mAxisMaximum, max);
+        if (this.mAxisRight?.enabled) {
+            max = Math.max(this.mAxisRight.axisMaximum, max);
         }
         return max;
     }
-    getYChartMin() {
+    get yChartMin() {
         let min = Infinity;
-        if (this.mAxisLeft.isEnabled()) {
-            min = Math.min(this.mAxisLeft.mAxisMinimum, min);
+        if (this.mAxisLeft.enabled) {
+            min = Math.min(this.mAxisLeft.axisMinimum, min);
         }
-        if (this.mAxisRight && this.mAxisRight.isEnabled()) {
-            min = Math.min(this.mAxisRight.mAxisMinimum, min);
+        if (this.mAxisRight?.enabled) {
+            min = Math.min(this.mAxisRight.axisMinimum, min);
         }
         return min;
     }
-    isAnyAxisInverted() {
-        if (this.mAxisLeft.isEnabled() && this.mAxisLeft.isInverted())
+    /**
+     * Returns true if either the left or the right or both axes are inverted.
+     */
+    get anyAxisInverted() {
+        if (this.mAxisLeft.enabled && this.mAxisLeft.inverted)
             return true;
-        if (this.mAxisRight && this.mAxisRight.isEnabled() && this.mAxisRight.isInverted())
+        if (this.mAxisRight?.enabled && this.mAxisRight.inverted)
             return true;
         return false;
     }
-    setAutoScaleMinMaxEnabled(enabled) {
-        this.mAutoScaleMinMaxEnabled = enabled;
-    }
-    isAutoScaleMinMaxEnabled() {
-        return this.mAutoScaleMinMaxEnabled;
-    }
     onSizeChanged(w, h, oldw, oldh) {
+        // Saving current position of chart.
         this.mOnSizeChangedBuffer[0] = this.mOnSizeChangedBuffer[1] = 0;
-        if (this.mKeepPositionOnRotation) {
-            this.mOnSizeChangedBuffer[0] = this.mViewPortHandler.contentLeft();
-            this.mOnSizeChangedBuffer[1] = this.mViewPortHandler.contentTop();
-            this.getTransformer().pixelsToValue(this.mOnSizeChangedBuffer);
+        if (this.keepPositionOnRotation) {
+            this.mOnSizeChangedBuffer[0] = this.viewPortHandler.contentLeft;
+            this.mOnSizeChangedBuffer[1] = this.viewPortHandler.contentTop;
+            this.transformer.pixelsToValue(this.mOnSizeChangedBuffer);
         }
+        //Superclass transforms chart.
         super.onSizeChanged(w, h, oldw, oldh);
-        if (this.mKeepPositionOnRotation) {
-            this.getTransformer().pointValuesToPixel(this.mOnSizeChangedBuffer);
-            this.mViewPortHandler.centerViewPort(this.mOnSizeChangedBuffer, this);
+        if (this.keepPositionOnRotation) {
+            //Restoring old position of chart.
+            this.transformer.pointValuesToPixel(this.mOnSizeChangedBuffer);
+            this.viewPortHandler.centerViewPort(this.mOnSizeChangedBuffer, this);
         }
         else {
-            this.mViewPortHandler.refresh(this.mViewPortHandler.getMatrixTouch(), this, false);
+            // a resize of the view will redraw the view anyway?
+            this.viewPortHandler.refresh(this.viewPortHandler.getMatrixTouch(), this, false);
         }
     }
     addEventListener(arg, callback, thisArg) {
@@ -842,17 +1223,17 @@ export class BarLineChartBase extends Chart {
             if (events.length > 0) {
                 for (let i = 0; i < events.length; i++) {
                     const evt = events[i].trim();
-                    if (arg === 'tap' && !this.isHighlightPerTapEnabled()) {
-                        this.mChartTouchListener && this.mChartTouchListener.setTap(false);
+                    if (arg === 'tap' && !this.highlightPerTapEnabled) {
+                        this.chartTouchListener && this.chartTouchListener.setTap(false);
                     }
-                    else if (arg === 'doubleTap' && !this.isDoubleTapToZoomEnabled()) {
-                        this.mChartTouchListener && this.mChartTouchListener.setDoubleTap(false);
+                    else if (arg === 'doubleTap' && !this.doubleTapToZoomEnabled) {
+                        this.chartTouchListener && this.chartTouchListener.setDoubleTap(false);
                     }
-                    else if (arg === 'pan' && !this.isHighlightPerDragEnabled() && !this.isDragEnabled()) {
-                        this.mChartTouchListener && this.mChartTouchListener.setPan(false);
+                    else if (arg === 'pan' && !this.highlightPerDragEnabled && !this.dragEnabled) {
+                        this.chartTouchListener && this.chartTouchListener.setPan(false);
                     }
-                    else if (arg === 'pinch' && !this.isPinchZoomEnabled()) {
-                        this.mChartTouchListener && this.mChartTouchListener.setPinch(false);
+                    else if (arg === 'pinch' && !this.pinchZoomEnabled) {
+                        this.chartTouchListener && this.chartTouchListener.setPinch(false);
                     }
                     Observable.prototype.removeEventListener.call(this, evt, callback, thisArg);
                 }