@nativescript-community/ui-chart 2.0.5 → 2.0.7

package/charts/BarLineChartBase.js

@@ -1,1253 +0,0 @@
-import { Matrix } from '@nativescript-community/ui-canvas';
-import { Observable, Trace, profile } from '@nativescript/core';
-import { getEventOrGestureName } from '@nativescript/core/ui/core/bindable';
-import { GestureTypes } from '@nativescript/core/ui/gestures';
-import { LegendHorizontalAlignment, LegendOrientation, LegendVerticalAlignment } from '../components/Legend';
-import { XAxisPosition } from '../components/XAxis';
-import { AxisDependency, YAxis } from '../components/YAxis';
-import { ChartHighlighter } from '../highlight/ChartHighlighter';
-import { AnimatedMoveViewJob } from '../jobs/AnimatedMoveViewJob';
-import { AnimatedZoomJob } from '../jobs/AnimatedZoomJob';
-import { MoveViewJob } from '../jobs/MoveViewJob';
-import { ZoomJob } from '../jobs/ZoomJob';
-import { BarLineChartTouchListener } from '../listener/BarLineChartTouchListener';
-import { XAxisRenderer } from '../renderer/XAxisRenderer';
-import { YAxisRenderer } from '../renderer/YAxisRenderer';
-import { Transformer } from '../utils/Transformer';
-import { CLog, CLogTypes, Utils } from '../utils/Utils';
-import { Chart } from './Chart';
-const LOG_TAG = 'BarLineChartBase';
-export class BarLineChartBase extends Chart {
-    constructor() {
-        super(...arguments);
-        /**
-         * 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.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();
-        /**
-         * 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, 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'); // light
-        }
-        return this.mGridBackgroundPaint;
-    }
-    get borderPaint() {
-        if (!this.mBorderPaint) {
-            this.mBorderPaint = Utils.getTemplatePaint('black-stroke');
-        }
-        return this.mBorderPaint;
-    }
-    getOrCreateBarTouchListener() {
-        if (!this.chartTouchListener) {
-            this.chartTouchListener = new BarLineChartTouchListener(this, this.viewPortHandler.getMatrixTouch(), 3);
-            if (!!this.nativeViewProtected) {
-                this.chartTouchListener.init();
-            }
-        }
-        return this.chartTouchListener;
-    }
-    onDraw(canvas) {
-        const startTime = Date.now();
-        super.onDraw(canvas);
-        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);
-        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();
-        }
-        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.viewPortHandler.contentRect);
-            this.renderer.drawData(canvas);
-        }
-        else {
-            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.hasValuesToHighlight && this.drawHighlight) {
-            this.renderer.drawHighlighted(canvas, this.indicesToHighlight, this.drawHighlight);
-        }
-        // Removes clipping rectangle
-        if (this.clipHighlightToContent && this.clipDataToContent) {
-            canvas.restore();
-        }
-        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.viewPortHandler.contentRect);
-            this.renderer.drawValues(canvas);
-            canvas.restore();
-        }
-        else {
-            this.renderer.drawValues(canvas);
-        }
-        this.legendRenderer?.renderLegend(canvas);
-        this.drawDescription(canvas);
-        this.drawMarkers(canvas);
-        this.notify({ eventName: 'postDraw', canvas, object: this });
-        if (Trace.isEnabled()) {
-            const drawtime = Date.now() - startTime;
-            this.totalTime += drawtime;
-            this.drawCycles += 1;
-            const average = this.totalTime / this.drawCycles;
-            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.xAxis.axisMinimum + ', xmax: ' + this.xAxis.axisMaximum + ', xdelta: ' + this.xAxis.axisRange);
-        }
-        if (this.mAxisRight?.enabled) {
-            this.rightAxisTransformer.prepareMatrixValuePx(this.xAxis.axisMinimum, this.xAxis.axisRange, this.mAxisRight.axisRange, this.mAxisRight.axisMinimum);
-        }
-        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?.enabled) {
-            this.rightAxisTransformer.prepareMatrixOffset(this.mAxisRight.inverted);
-        }
-        if (this.mAxisLeft?.enabled || this.xAxis.enabled) {
-            this.leftAxisTransformer.prepareMatrixOffset(this.mAxisLeft.inverted);
-        }
-    }
-    notifyDataSetChanged() {
-        if (!this.mData || this.mData.dataSetCount === 0) {
-            if (Trace.isEnabled()) {
-                CLog(CLogTypes.info, LOG_TAG, 'Preparing... DATA NOT SET.');
-            }
-            return;
-        }
-        else if (!this.viewPortHandler.hasChartDimens) {
-            if (Trace.isEnabled()) {
-                CLog(CLogTypes.info, LOG_TAG, 'Preparing... NOT SIZED YET.');
-            }
-            return;
-        }
-        else {
-            if (Trace.isEnabled()) {
-                CLog(CLogTypes.info, LOG_TAG, 'Preparing...');
-            }
-        }
-        this.renderer?.initBuffers();
-        this.calcMinMax();
-        if (this.mAxisLeft?.enabled) {
-            this.rendererLeftYAxis.computeAxis(this.mAxisLeft.axisMinimum, this.mAxisLeft.axisMaximum, this.mAxisLeft.inverted);
-        }
-        if (this.mAxisRight?.enabled) {
-            this.rendererRightYAxis.computeAxis(this.mAxisRight.axisMinimum, this.mAxisRight.axisMaximum, this.mAxisRight.inverted);
-        }
-        if (this.xAxis.enabled) {
-            this.rendererXAxis.computeAxis(this.xAxis.axisMinimum, this.xAxis.axisMaximum, false);
-        }
-        if (this.mLegend?.enabled) {
-            this.legendRenderer.computeLegend(this.mData);
-        }
-        // 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.lowestVisibleX;
-        const toX = this.highestVisibleX;
-        this.mData.calcMinMaxYRange(fromX, toX);
-        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?.enabled) {
-            this.mAxisRight.calculate(this.mData.getYMin(AxisDependency.RIGHT), this.mData.getYMax(AxisDependency.RIGHT));
-        }
-    }
-    calcMinMax() {
-        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?.enabled) {
-            this.mAxisRight.calculate(this.mData.getYMin(AxisDependency.RIGHT), this.mData.getYMax(AxisDependency.RIGHT));
-        }
-    }
-    calculateLegendOffsets(offsets) {
-        offsets.left = 0;
-        offsets.right = 0;
-        offsets.top = 0;
-        offsets.bottom = 0;
-        // setup offsets for legend
-        if (this.mLegend?.enabled && !this.mLegend.drawInside) {
-            switch (this.mLegend.orientation) {
-                case LegendOrientation.VERTICAL:
-                    switch (this.mLegend.horizontalAlignment) {
-                        case LegendHorizontalAlignment.LEFT:
-                            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.viewPortHandler.chartWidth * this.mLegend.maxSizePercent) + this.mLegend.xOffset;
-                            break;
-                        case LegendHorizontalAlignment.CENTER:
-                            switch (this.mLegend.verticalAlignment) {
-                                case LegendVerticalAlignment.TOP:
-                                    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.viewPortHandler.chartHeight * this.mLegend.maxSizePercent) + this.mLegend.yOffset;
-                                    break;
-                                default:
-                                    break;
-                            }
-                    }
-                    break;
-                case LegendOrientation.HORIZONTAL:
-                    switch (this.mLegend.verticalAlignment) {
-                        case LegendVerticalAlignment.TOP:
-                            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.viewPortHandler.chartHeight * this.mLegend.maxSizePercent) + this.mLegend.yOffset;
-                            break;
-                        default:
-                            break;
-                    }
-                    break;
-            }
-        }
-    }
-    calculateOffsets(force = true) {
-        if (this.offsetsCalculated && !force) {
-            return;
-        }
-        this.offsetsCalculated = true;
-        if (!this.mCustomViewPortEnabled) {
-            const offsetBuffer = Utils.getTempRectF();
-            this.calculateLegendOffsets(offsetBuffer);
-            let offsetLeft = offsetBuffer.left;
-            let offsetTop = offsetBuffer.top;
-            let offsetRight = offsetBuffer.right;
-            let offsetBottom = offsetBuffer.bottom;
-            // offsets for y-labels
-            if (this.mAxisLeft?.needsOffset) {
-                offsetLeft += this.mAxisLeft.getRequiredWidthSpace(this.rendererLeftYAxis.axisLabelsPaint);
-            }
-            if (this.mAxisRight?.needsOffset) {
-                offsetRight += this.mAxisRight.getRequiredWidthSpace(this.rendererRightYAxis.axisLabelsPaint);
-            }
-            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.xAxis.position === XAxisPosition.TOP) {
-                    offsetTop += xLabelHeight;
-                }
-                else if (this.xAxis.position === XAxisPosition.BOTH_SIDED) {
-                    offsetBottom += xLabelHeight;
-                    offsetTop += xLabelHeight;
-                }
-            }
-            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.viewPortHandler.contentRect.toString());
-            }
-        }
-        this.prepareOffsetMatrix();
-        this.prepareValuePxMatrix();
-    }
-    /**
-     * draws the grid background
-     */
-    drawGridBackground(c) {
-        if (this.drawGridBackgroundEnabled) {
-            // draw the grid background
-            c.drawRect(this.viewPortHandler.contentRect, this.gridBackgroundPaint);
-        }
-        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) {
-            return this.transformer;
-        }
-        if (which === AxisDependency.LEFT)
-            return this.leftAxisTransformer;
-        else
-            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.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.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.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.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.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.centerOffsets;
-        const save = this.mZoomMatrixBuffer;
-        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.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.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.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.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);
-        // 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();
-    }
-    /**
-     * 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.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.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.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.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.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.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.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.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.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.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;
-        // 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.axisRange;
-        else
-            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.chartTouchListener) {
-            this.chartTouchListener.setPan(false);
-        }
-    }
-    get highlightPerDragEnabled() {
-        return this.mHighlightPerDragEnabled;
-    }
-    /**
-     * 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);
-    }
-    /**
-     * 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.chartTouchListener) {
-            this.chartTouchListener.setPan(false);
-        }
-    }
-    /**
-     * Returns true if dragging is enabled for the chart, false if not.
-     */
-    get dragEnabled() {
-        return this.dragXEnabled || this.dragYEnabled;
-    }
-    /**
-     * 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.chartTouchListener) {
-            this.chartTouchListener.setPinch(false);
-        }
-    }
-    set scaleXEnabled(enabled) {
-        this.mScaleXEnabled = enabled;
-        if (enabled) {
-            this.getOrCreateBarTouchListener().setPinch(true);
-        }
-        else if (!this.mScaleYEnabled && this.chartTouchListener) {
-            this.chartTouchListener.setPinch(false);
-        }
-    }
-    get scaleXEnabled() {
-        return this.mScaleXEnabled;
-    }
-    set scaleYEnabled(enabled) {
-        this.mScaleYEnabled = enabled;
-        if (enabled) {
-            this.getOrCreateBarTouchListener().setPinch(true);
-        }
-        else if (!this.mScaleXEnabled && this.chartTouchListener) {
-            this.chartTouchListener.setPinch(false);
-        }
-    }
-    get scaleYEnabled() {
-        return this.mScaleYEnabled;
-    }
-    /**
-     * 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.chartTouchListener) {
-            this.chartTouchListener.setDoubleTap(false);
-        }
-    }
-    /**
-     * 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.chartTouchListener) {
-            this.chartTouchListener.setTap(false);
-        }
-    }
-    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);
-    }
-    /**
-     * 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) {
-            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) {
-            return this.mData.getDataSetByIndex(h.dataSetIndex);
-        }
-        return null;
-    }
-    /**
-     * 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;
-    }
-    /**
-     * 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.highestVisibleX - this.lowestVisibleX);
-    }
-    /**
-     * returns the current x-scale factor
-     */
-    getScaleX() {
-        if (this.viewPortHandler == null)
-            return 1;
-        else
-            return this.viewPortHandler.getScaleX();
-    }
-    /**
-     * returns the current y-scale factor
-     */
-    getScaleY() {
-        if (this.viewPortHandler == null)
-            return 1;
-        else
-            return this.viewPortHandler.getScaleY();
-    }
-    /**
-     * if the chart is fully zoomed out, return true
-     */
-    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;
-    }
-    /**
-     * 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, new WeakRef(this));
-            this.rightAxisTransformer = new Transformer(this.viewPortHandler);
-            this.rendererRightYAxis = new YAxisRenderer(this.viewPortHandler, this.mAxisRight, this.rightAxisTransformer);
-        }
-        return this.mAxisRight;
-    }
-    /**
-     * @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;
-        else
-            return this.mAxisRight;
-    }
-    isInverted(axis) {
-        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.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.viewPortHandler.setDragOffsetY(offset);
-    }
-    /**
-     * Returns true if both drag offsets (x and y) are zero or smaller.
-     */
-    hasNoDragOffset() {
-        return this.viewPortHandler.hasNoDragOffset();
-    }
-    get yChartMax() {
-        let max = -Infinity;
-        if (this.mAxisLeft.enabled) {
-            max = Math.max(this.mAxisLeft.axisMaximum, max);
-        }
-        if (this.mAxisRight?.enabled) {
-            max = Math.max(this.mAxisRight.axisMaximum, max);
-        }
-        return max;
-    }
-    get yChartMin() {
-        let min = Infinity;
-        if (this.mAxisLeft.enabled) {
-            min = Math.min(this.mAxisLeft.axisMinimum, min);
-        }
-        if (this.mAxisRight?.enabled) {
-            min = Math.min(this.mAxisRight.axisMinimum, min);
-        }
-        return min;
-    }
-    /**
-     * 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?.enabled && this.mAxisRight.inverted)
-            return true;
-        return false;
-    }
-    onSizeChanged(w, h, oldw, oldh) {
-        // Saving current position of chart.
-        this.mOnSizeChangedBuffer[0] = this.mOnSizeChangedBuffer[1] = 0;
-        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.keepPositionOnRotation) {
-            //Restoring old position of chart.
-            this.transformer.pointValuesToPixel(this.mOnSizeChangedBuffer);
-            this.viewPortHandler.centerViewPort(this.mOnSizeChangedBuffer, this);
-        }
-        else {
-            // a resize of the view will redraw the view anyway?
-            this.viewPortHandler.refresh(this.viewPortHandler.getMatrixTouch(), this, false);
-        }
-    }
-    addEventListener(arg, callback, thisArg) {
-        if (typeof arg === 'number') {
-            arg = GestureTypes[arg];
-        }
-        if (typeof arg === 'string') {
-            arg = getEventOrGestureName(arg);
-            const events = arg.split(',');
-            if (events.length > 0) {
-                for (let i = 0; i < events.length; i++) {
-                    const evt = events[i].trim();
-                    if (arg === 'tap') {
-                        this.getOrCreateBarTouchListener().setTap(true);
-                    }
-                    else if (arg === 'doubleTap') {
-                        this.getOrCreateBarTouchListener().setDoubleTap(true);
-                    }
-                    else if (arg === 'pan') {
-                        this.getOrCreateBarTouchListener().setPan(true);
-                    }
-                    else if (arg === 'pinch') {
-                        this.getOrCreateBarTouchListener().setPinch(true);
-                    }
-                    Observable.prototype.addEventListener.call(this, evt, callback, thisArg);
-                }
-            }
-            else {
-                Observable.prototype.addEventListener.call(this, arg, callback, thisArg);
-            }
-        }
-    }
-    removeEventListener(arg, callback, thisArg) {
-        if (typeof arg === 'number') {
-            arg = GestureTypes[arg];
-        }
-        if (typeof arg === 'string') {
-            arg = getEventOrGestureName(arg);
-            const events = arg.split(',');
-            if (events.length > 0) {
-                for (let i = 0; i < events.length; i++) {
-                    const evt = events[i].trim();
-                    if (arg === 'tap' && !this.highlightPerTapEnabled) {
-                        this.chartTouchListener && this.chartTouchListener.setTap(false);
-                    }
-                    else if (arg === 'doubleTap' && !this.doubleTapToZoomEnabled) {
-                        this.chartTouchListener && this.chartTouchListener.setDoubleTap(false);
-                    }
-                    else if (arg === 'pan' && !this.highlightPerDragEnabled && !this.dragEnabled) {
-                        this.chartTouchListener && this.chartTouchListener.setPan(false);
-                    }
-                    else if (arg === 'pinch' && !this.pinchZoomEnabled) {
-                        this.chartTouchListener && this.chartTouchListener.setPinch(false);
-                    }
-                    Observable.prototype.removeEventListener.call(this, evt, callback, thisArg);
-                }
-            }
-            else {
-                Observable.prototype.removeEventListener.call(this, arg, callback, thisArg);
-            }
-        }
-    }
-}
-__decorate([
-    profile
-], BarLineChartBase.prototype, "onDraw", null);
-//# sourceMappingURL=BarLineChartBase.js.map