@nativescript-community/ui-chart 1.2.35 → 2.0.0

package/listener/BarLineChartTouchListener.d.ts

@@ -1,15 +1,38 @@
+import { GestureStateEventData, GestureTouchEventData, PanGestureHandler, PinchGestureHandler, TapGestureHandler } from '@nativescript-community/gesturehandler';
 import { Matrix } from '@nativescript-community/ui-canvas';
 import { BarLineChartBase } from '../charts/BarLineChartBase';
 import { ChartTouchListener } from './ChartTouchListener';
-import { GestureStateEventData, GestureTouchEventData, PanGestureHandler, PinchGestureHandler, TapGestureHandler } from '@nativescript-community/gesturehandler';
+/**
+ * TouchListener for Bar-, Line-, Scatter- and CandleStickChart with handles all
+ * touch interaction. Longpress === Zoom out. Double-Tap === Zoom in.
+ *
+
+ */
 export declare class BarLineChartTouchListener extends ChartTouchListener<BarLineChartBase<any, any, any>> {
+    /**
+     * the original touch-matrix from the chart
+     */
     private mMatrix;
+    /**
+     * matrix for saving the original matrix state
+     */
     private mSavedMatrix;
+    /**
+     * center between two pointers (fingers on the display)
+     */
     private mTouchPointCenter;
     private mSavedXDist;
     private mSavedYDist;
     private mClosestDataSetToTouch;
     private mDecelerationVelocity;
+    /**
+     * Constructor with initialization parameters.
+     *
+     * @param chart               instance of the chart
+     * @param touchMatrix         the touch-matrix of the chart
+     * @param dragTriggerDistance the minimum movement distance that will be interpreted as a "drag" gesture in dp (3dp equals
+     *                            to about 9 pixels on a 5.5" FHD screen)
+     */
     TAP_HANDLER_TAG: any;
     DOUBLE_TAP_HANDLER_TAG: any;
     PINCH_HANDLER_TAG: any;
@@ -37,6 +60,7 @@ export declare class BarLineChartTouchListener extends ChartTouchListener<BarLin
         gestureTag: any;
     };
     getPinchGestureOptions(): {
+        minSpan?: number;
         enabled?: boolean;
         shouldCancelWhenOutside?: boolean;
         waitFor?: number[];
@@ -88,16 +112,74 @@ export declare class BarLineChartTouchListener extends ChartTouchListener<BarLin
     onPanGestureTouch(event: GestureTouchEventData): void;
     onPinchGestureState(event: GestureStateEventData): void;
     onPinchGestureTouch(event: GestureTouchEventData): void;
+    /**
+     * ################ ################ ################ ################
+     */
+    /** BELOW CODE PERFORMS THE ACTUAL TOUCH ACTIONS */
+    /**
+     * Saves the current Matrix state and the touch-start point.
+     *
+     * @param event
+     */
     private saveTouchStart;
+    /**
+     * Performs all necessary operations needed for dragging.
+     *
+     * @param event
+     */
     private performDrag;
+    /**
+     * Highlights upon dragging, generates callbacks for the selection-listener.
+     *
+     * @param e
+     */
     private performHighlightDrag;
+    /**
+     * Highlights upon dragging, generates callbacks for the selection-listener.
+     *
+     * @param e
+     */
+    private handleTouchHighlight;
+    /**
+     * calculates the distance on the x-axis between two pointers (fingers on
+     * the display)
+     *
+     * @param e
+     * @return
+     */
     private static getXDist;
+    /**
+     * calculates the distance on the y-axis between two pointers (fingers on
+     * the display)
+     *
+     * @param e
+     * @return
+     */
     private static getYDist;
+    /**
+     * Returns a recyclable MPPointF instance.
+     * returns the correct translation depending on the provided x and y touch
+     * points
+     *
+     * @param x
+     * @param y
+     * @return
+     */
     getTrans(x: any, y: any): {
         x: number;
         y: number;
     };
+    /**
+     * Returns true if the current touch situation should be interpreted as inverted, false if not.
+     */
     private inverted;
+    /**
+     * ################ ################ ################ ################
+     */
+    /** GETTERS AND GESTURE RECOGNITION BELOW */
+    /**
+     * returns the matrix object the listener holds
+     */
     getMatrix(): Matrix;
     onDoubleTapGesture(event: GestureStateEventData): void;
     onTapGesture(event: GestureStateEventData): void;

package/listener/BarLineChartTouchListener.js

@@ -1,18 +1,33 @@
+import { GestureHandlerStateEvent, GestureHandlerTouchEvent, GestureState, HandlerType, Manager } from '@nativescript-community/gesturehandler';
 import { Matrix } from '@nativescript-community/ui-canvas';
+import { Trace } from '@nativescript/core';
 import { CLog, CLogTypes } from '../utils/Utils';
 import { ChartGesture, ChartTouchListener } from './ChartTouchListener';
-import { GestureHandlerStateEvent, GestureHandlerTouchEvent, GestureState, HandlerType, Manager } from '@nativescript-community/gesturehandler';
-import { Trace } from '@nativescript/core';
 const LOG_TAG = 'BarLineChartTouchListener';
 let TAP_HANDLER_TAG = 12450000;
 let DOUBLE_TAP_HANDLER_TAG = 12451000;
 let PINCH_HANDLER_TAG = 12452000;
 let PAN_HANDLER_TAG = 12453000;
+/**
+ * TouchListener for Bar-, Line-, Scatter- and CandleStickChart with handles all
+ * touch interaction. Longpress === Zoom out. Double-Tap === Zoom in.
+ *
+
+ */
 export class BarLineChartTouchListener extends ChartTouchListener {
     constructor(chart, touchMatrix, dragTriggerDistance) {
         super(chart);
+        /**
+         * the original touch-matrix from the chart
+         */
         this.mMatrix = new Matrix();
+        /**
+         * matrix for saving the original matrix state
+         */
         this.mSavedMatrix = new Matrix();
+        /**
+         * center between two pointers (fingers on the display)
+         */
         this.mTouchPointCenter = { x: 0, y: 0 };
         this.mSavedXDist = 1;
         this.mSavedYDist = 1;
@@ -24,16 +39,16 @@ export class BarLineChartTouchListener extends ChartTouchListener {
         this.PAN_HANDLER_TAG = PAN_HANDLER_TAG++;
     }
     getPanGestureOptions() {
-        return { gestureTag: this.PAN_HANDLER_TAG, ...(this.mChart.panGestureOptions || {}) };
+        return { gestureTag: this.PAN_HANDLER_TAG, ...(this.chart.panGestureOptions || {}) };
     }
     getPinchGestureOptions() {
-        return { gestureTag: this.PINCH_HANDLER_TAG, ...(this.mChart.pinchGestureOptions || {}) };
+        return { gestureTag: this.PINCH_HANDLER_TAG, ...(this.chart.pinchGestureOptions || {}) };
     }
     getTapGestureOptions() {
-        return { gestureTag: this.TAP_HANDLER_TAG, ...(this.mChart.tapGestureOptions || {}) };
+        return { gestureTag: this.TAP_HANDLER_TAG, ...(this.chart.tapGestureOptions || {}) };
     }
     getDoubleTapGestureOptions() {
-        return { gestureTag: this.DOUBLE_TAP_HANDLER_TAG, ...(this.mChart.doubleTapGestureOptions || {}) };
+        return { gestureTag: this.DOUBLE_TAP_HANDLER_TAG, ...(this.chart.doubleTapGestureOptions || {}) };
     }
     getOrCreateDoubleTapGestureHandler() {
         if (!this.doubleTapGestureHandler) {
@@ -42,9 +57,8 @@ export class BarLineChartTouchListener extends ChartTouchListener {
                 CLog(CLogTypes.log, LOG_TAG, 'creating double tap gesture');
             }
             const options = this.getDoubleTapGestureOptions();
-            this.doubleTapGestureHandler = manager
-                .createGestureHandler(HandlerType.TAP, options.gestureTag, { numberOfTaps: 2, ...options })
-                .on(GestureHandlerStateEvent, this.onDoubleTapGesture, this);
+            this.doubleTapGestureHandler = manager.createGestureHandler(HandlerType.TAP, options.gestureTag, { numberOfTaps: 2, ...options });
+            this.doubleTapGestureHandler.on(GestureHandlerStateEvent, this.onDoubleTapGesture, this);
         }
         return this.doubleTapGestureHandler;
     }
@@ -104,7 +118,7 @@ export class BarLineChartTouchListener extends ChartTouchListener {
         return this.panGestureHandler;
     }
     setDoubleTap(enabled) {
-        const chart = this.mChart;
+        const chart = this.chart;
         if (enabled) {
             this.getOrCreateDoubleTapGestureHandler().attachToView(chart);
             if (Trace.isEnabled()) {
@@ -119,7 +133,7 @@ export class BarLineChartTouchListener extends ChartTouchListener {
         }
     }
     setTap(enabled) {
-        const chart = this.mChart;
+        const chart = this.chart;
         if (enabled) {
             this.getOrCreateTapGestureHandler().attachToView(chart);
             if (Trace.isEnabled()) {
@@ -134,7 +148,7 @@ export class BarLineChartTouchListener extends ChartTouchListener {
         }
     }
     setPinch(enabled) {
-        const chart = this.mChart;
+        const chart = this.chart;
         if (enabled) {
             this.getOrCreatePinchGestureHandler().attachToView(chart);
             if (Trace.isEnabled()) {
@@ -149,7 +163,7 @@ export class BarLineChartTouchListener extends ChartTouchListener {
         }
     }
     setPan(enabled) {
-        const chart = this.mChart;
+        const chart = this.chart;
         if (enabled) {
             this.getOrCreatePanGestureHandler().attachToView(chart);
             if (Trace.isEnabled()) {
@@ -165,7 +179,7 @@ export class BarLineChartTouchListener extends ChartTouchListener {
     }
     dispose() {
         super.dispose();
-        const chart = this.mChart;
+        const chart = this.chart;
         this.panGestureHandler && this.panGestureHandler.detachFromView(chart);
         this.pinchGestureHandler && this.pinchGestureHandler.detachFromView(chart);
         this.tapGestureHandler && this.tapGestureHandler.detachFromView(chart);
@@ -177,26 +191,28 @@ export class BarLineChartTouchListener extends ChartTouchListener {
     }
     init() {
         super.init();
-        const chart = this.mChart;
-        if (chart.isDoubleTapToZoomEnabled()) {
+        const chart = this.chart;
+        if (chart.doubleTapToZoomEnabled) {
             this.setDoubleTap(true);
         }
-        if (chart.isHighlightPerTapEnabled()) {
+        if (chart.highlightPerTapEnabled) {
             this.setTap(true);
         }
-        if (chart.isHighlightPerDragEnabled() || chart.isDragEnabled()) {
+        if (chart.highlightPerDragEnabled || chart.dragEnabled) {
             this.setPan(true);
         }
-        if (chart.isPinchZoomEnabled()) {
+        if (chart.pinchZoomEnabled) {
             this.setPinch(true);
         }
     }
     onPanGestureState(event) {
-        const chart = this.mChart;
-        if (!chart.isHighlightPerDragEnabled() && !chart.isDragEnabled())
+        const chart = this.chart;
+        if (!chart.highlightPerDragEnabled && !chart.dragEnabled)
             return;
         const state = event.data.state;
+        chart.noComputeAutoScaleOnNextDraw = true;
         switch (state) {
+            // break;
             case GestureState.ACTIVE:
                 this.stopDeceleration();
                 this.saveTouchStart(event);
@@ -214,8 +230,8 @@ export class BarLineChartTouchListener extends ChartTouchListener {
         }
     }
     onPanGestureTouch(event) {
-        const chart = this.mChart;
-        if (!chart.isHighlightPerDragEnabled() && !chart.isDragEnabled())
+        const chart = this.chart;
+        if (!chart.highlightPerDragEnabled && !chart.dragEnabled)
             return;
         const data = event.data;
         if (data.state !== GestureState.ACTIVE) {
@@ -229,19 +245,20 @@ export class BarLineChartTouchListener extends ChartTouchListener {
             const x = event.data.extraData.translationX;
             const y = event.data.extraData.translationY;
             this.performDrag(event, x, y);
-            this.mMatrix = chart.getViewPortHandler().refresh(this.mMatrix, chart, true);
+            this.mMatrix = chart.viewPortHandler.refresh(this.mMatrix, chart, true);
         }
         else if (this.mTouchMode === ChartTouchListener.NONE) {
             const shouldPan = (!chart.isFullyZoomedOut() || !chart.hasNoDragOffset()) && (!chart.zoomedPanWith2Pointers || event.data.extraData.numberOfPointers === 2);
             if (shouldPan) {
-                if (chart.isDragXEnabled() && chart.isDragYEnabled()) {
+                // Disable dragging in a direction that's disallowed
+                if (chart.dragXEnabled && chart.dragYEnabled) {
                     chart.disableScroll();
                     this.mLastGesture = ChartGesture.DRAG;
                     this.mTouchMode = ChartTouchListener.DRAG;
                 }
             }
             else {
-                if (chart.isHighlightPerDragEnabled()) {
+                if (chart.highlightPerDragEnabled) {
                     chart.disableScroll();
                     this.mLastGesture = ChartGesture.DRAG;
                     this.performHighlightDrag(event);
@@ -250,27 +267,31 @@ export class BarLineChartTouchListener extends ChartTouchListener {
         }
     }
     onPinchGestureState(event) {
-        const chart = this.mChart;
-        if (!chart.isScaleXEnabled() && !chart.isScaleYEnabled())
+        const chart = this.chart;
+        if (!chart.scaleXEnabled && !chart.scaleYEnabled)
             return;
+        chart.noComputeAutoScaleOnNextDraw = true;
         const state = event.data.state;
         switch (state) {
             case GestureState.ACTIVE:
                 this.saveTouchStart(event);
+                // get the distance between the pointers on the x-axis
                 this.mSavedXDist = BarLineChartTouchListener.getXDist(event);
                 chart.disableScroll();
+                // get the distance between the pointers on the y-axis
                 this.mSavedYDist = BarLineChartTouchListener.getYDist(event);
-                if (chart.isPinchZoomEnabled()) {
+                if (chart.pinchZoomEnabled) {
                     this.mTouchMode = ChartTouchListener.PINCH_ZOOM;
                 }
                 else {
-                    if (chart.isScaleXEnabled() !== chart.isScaleYEnabled()) {
-                        this.mTouchMode = chart.isScaleXEnabled() ? ChartTouchListener.X_ZOOM : ChartTouchListener.Y_ZOOM;
+                    if (chart.scaleXEnabled !== chart.scaleYEnabled) {
+                        this.mTouchMode = chart.scaleXEnabled ? ChartTouchListener.X_ZOOM : ChartTouchListener.Y_ZOOM;
                     }
                     else {
                         this.mTouchMode = this.mSavedXDist > this.mSavedYDist ? ChartTouchListener.X_ZOOM : ChartTouchListener.Y_ZOOM;
                     }
                 }
+                // determine the touch-pointer center
                 this.mTouchPointCenter.x = event.data.extraData.focalX;
                 this.mTouchPointCenter.y = event.data.extraData.focalY;
                 break;
@@ -281,6 +302,9 @@ export class BarLineChartTouchListener extends ChartTouchListener {
                     this.mTouchMode === ChartTouchListener.PINCH_ZOOM ||
                     this.mTouchMode === ChartTouchListener.POST_ZOOM) {
                     this.mTouchMode = ChartTouchListener.NONE;
+                    // 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.
                     chart.calculateOffsets();
                     chart.invalidate();
                 }
@@ -289,8 +313,8 @@ export class BarLineChartTouchListener extends ChartTouchListener {
         }
     }
     onPinchGestureTouch(event) {
-        const chart = this.mChart;
-        if (!chart.isScaleXEnabled() && !chart.isScaleYEnabled())
+        const chart = this.chart;
+        if (!chart.scaleXEnabled && !chart.scaleYEnabled)
             return;
         if (event.data.state !== GestureState.ACTIVE) {
             return;
@@ -301,14 +325,14 @@ export class BarLineChartTouchListener extends ChartTouchListener {
         if (this.mTouchMode === ChartTouchListener.X_ZOOM || this.mTouchMode === ChartTouchListener.Y_ZOOM || this.mTouchMode === ChartTouchListener.PINCH_ZOOM) {
             if (this.mTouchMode === ChartTouchListener.PINCH_ZOOM) {
                 this.mLastGesture = ChartGesture.PINCH_ZOOM;
-                const t = this.getTrans(this.mTouchPointCenter.x, this.mTouchPointCenter.y);
+                const t = this.getTrans(this.mTouchPointCenter.x, this.mTouchPointCenter.y); //focalPoint
                 const scale = event.data.extraData.scale;
                 const isZoomingOut = scale < 1;
-                const h = chart.getViewPortHandler();
+                const h = chart.viewPortHandler;
                 const canZoomMoreX = isZoomingOut ? h.canZoomOutMoreX() : h.canZoomInMoreX();
                 const canZoomMoreY = isZoomingOut ? h.canZoomOutMoreY() : h.canZoomInMoreY();
-                const scaleX = chart.isScaleXEnabled() ? scale : 1;
-                const scaleY = chart.isScaleYEnabled() ? scale : 1;
+                const scaleX = chart.scaleXEnabled ? scale : 1;
+                const scaleY = chart.scaleYEnabled ? scale : 1;
                 if (canZoomMoreY || canZoomMoreX) {
                     this.mMatrix.set(this.mSavedMatrix);
                     this.mMatrix.postScale(scaleX, scaleY, t.x, t.y);
@@ -317,11 +341,11 @@ export class BarLineChartTouchListener extends ChartTouchListener {
                     chart.notify({ eventName: 'zoom', scaleX, scaleY, ...t });
                 }
             }
-            else if (this.mTouchMode === ChartTouchListener.X_ZOOM && chart.isScaleXEnabled()) {
+            else if (this.mTouchMode === ChartTouchListener.X_ZOOM && chart.scaleXEnabled) {
                 this.mLastGesture = ChartGesture.X_ZOOM;
                 const t = this.getTrans(this.mTouchPointCenter.x, this.mTouchPointCenter.y);
                 const scaleX = event.data.extraData.scale;
-                const h = chart.getViewPortHandler();
+                const h = chart.viewPortHandler;
                 const isZoomingOut = scaleX < 1;
                 const canZoomMoreX = isZoomingOut ? h.canZoomOutMoreX() : h.canZoomInMoreX();
                 if (canZoomMoreX) {
@@ -332,11 +356,11 @@ export class BarLineChartTouchListener extends ChartTouchListener {
                     chart.notify({ eventName: 'zoom', scaleX, scaleY: 1, ...t });
                 }
             }
-            else if (this.mTouchMode === ChartTouchListener.Y_ZOOM && chart.isScaleYEnabled()) {
+            else if (this.mTouchMode === ChartTouchListener.Y_ZOOM && chart.scaleYEnabled) {
                 this.mLastGesture = ChartGesture.Y_ZOOM;
                 const t = this.getTrans(this.mTouchPointCenter.x, this.mTouchPointCenter.y);
                 const scaleY = event.data.extraData.scale;
-                const h = chart.getViewPortHandler();
+                const h = chart.viewPortHandler;
                 const isZoomingOut = scaleY < 1;
                 const canZoomMoreY = isZoomingOut ? h.canZoomOutMoreY() : h.canZoomInMoreY();
                 if (canZoomMoreY) {
@@ -347,66 +371,143 @@ export class BarLineChartTouchListener extends ChartTouchListener {
                     chart.notify({ eventName: 'zoom', scaleX: 1, scaleY, ...t });
                 }
             }
-            this.mMatrix = chart.getViewPortHandler().refresh(this.mMatrix, chart, true);
+            this.mMatrix = chart.viewPortHandler.refresh(this.mMatrix, chart, true);
+            chart.noComputeAutoScaleOnNextDraw = true;
+            // }
         }
     }
+    /**
+     * ################ ################ ################ ################
+     */
+    /** BELOW CODE PERFORMS THE ACTUAL TOUCH ACTIONS */
+    /**
+     * Saves the current Matrix state and the touch-start point.
+     *
+     * @param event
+     */
     saveTouchStart(event) {
         this.mSavedMatrix.set(this.mMatrix);
     }
+    /**
+     * Performs all necessary operations needed for dragging.
+     *
+     * @param event
+     */
     performDrag(event, distanceX, distanceY) {
         this.mLastGesture = ChartTouchListener.DRAG;
         this.mMatrix.set(this.mSavedMatrix);
+        // check if axis is inverted
         if (this.inverted()) {
             distanceY = -distanceY;
         }
+        this.chart.noComputeAutoScaleOnNextDraw = true;
         this.mMatrix.postTranslate(distanceX, distanceY);
-        if (this.mChart.hasListeners('translate')) {
-            this.mChart.notify({ eventName: 'translate', object: this.mChart, distanceX, distanceY });
+        if (this.chart.hasListeners('translate')) {
+            this.chart.notify({ eventName: 'translate', object: this.chart, distanceX, distanceY });
         }
     }
+    /**
+     * Highlights upon dragging, generates callbacks for the selection-listener.
+     *
+     * @param e
+     */
     performHighlightDrag(event) {
-        const h = this.mChart.getHighlightByTouchPoint(event.data.extraData.x, event.data.extraData.y);
-        if (h != null && h !== this.mLastHighlighted) {
-            this.mLastHighlighted = h;
-            this.mChart.highlight(h, true);
+        // const highlights = this.chart.getHighlightsByTouchPoint(event.data.extraData.x, event.data.extraData.y);
+        // const h = highlights[0];
+        // if (h && h !== this.lastHighlighted) {
+        //     this.chart.highlights(highlights, true);
+        // }
+        this.handleTouchHighlight(event, true);
+    }
+    /**
+     * Highlights upon dragging, generates callbacks for the selection-listener.
+     *
+     * @param e
+     */
+    handleTouchHighlight(event, highlightInChart, checkForLast = true, eventName) {
+        const highlights = this.chart.getHighlightsByTouchPoint(event.data.extraData.x, event.data.extraData.y);
+        const h = highlights[0];
+        if (h) {
+            if (highlightInChart && (!checkForLast || h !== this.lastHighlighted)) {
+                this.chart.highlight(highlights, true);
+            }
+        }
+        if (eventName) {
+            this.chart.notify({ eventName, data: event.data, highlight: h, highlights });
         }
     }
+    /**
+     * calculates the distance on the x-axis between two pointers (fingers on
+     * the display)
+     *
+     * @param e
+     * @return
+     */
     static getXDist(e) {
         const x = Math.abs(e.data.extraData.positions[0] - e.data.extraData.positions[2]);
         return x;
     }
+    /**
+     * calculates the distance on the y-axis between two pointers (fingers on
+     * the display)
+     *
+     * @param e
+     * @return
+     */
     static getYDist(e) {
         const y = Math.abs(e.data.extraData.positions[1] - e.data.extraData.positions[3]);
         return y;
     }
+    /**
+     * Returns a recyclable MPPointF instance.
+     * returns the correct translation depending on the provided x and y touch
+     * points
+     *
+     * @param x
+     * @param y
+     * @return
+     */
     getTrans(x, y) {
-        const vph = this.mChart.getViewPortHandler();
-        const xTrans = x - vph.offsetLeft();
+        const vph = this.chart.viewPortHandler;
+        const xTrans = x - vph.offsetLeft;
         let yTrans = 0;
+        // check if axis is inverted
         if (this.inverted()) {
-            yTrans = -(y - vph.offsetTop());
+            yTrans = -(y - vph.offsetTop);
         }
         else {
-            yTrans = -(vph.getChartHeight() - y - vph.offsetBottom());
+            yTrans = -(vph.chartHeight - y - vph.offsetBottom);
         }
         return { x: xTrans, y: yTrans };
     }
+    /**
+     * Returns true if the current touch situation should be interpreted as inverted, false if not.
+     */
     inverted() {
-        return ((this.mClosestDataSetToTouch == null && this.mChart.isAnyAxisInverted()) || (this.mClosestDataSetToTouch != null && this.mChart.isInverted(this.mClosestDataSetToTouch.getAxisDependency())));
+        return (!this.mClosestDataSetToTouch && this.chart.anyAxisInverted) || (this.mClosestDataSetToTouch && this.chart.isInverted(this.mClosestDataSetToTouch.axisDependency));
     }
+    /**
+     * ################ ################ ################ ################
+     */
+    /** GETTERS AND GESTURE RECOGNITION BELOW */
+    /**
+     * returns the matrix object the listener holds
+     */
     getMatrix() {
         return this.mMatrix;
     }
     onDoubleTapGesture(event) {
         if (event.data.state === GestureState.END && event.data.prevState === GestureState.ACTIVE) {
-            const chart = this.mChart;
+            const chart = this.chart;
+            // check if double-tap zooming is enabled
             if (chart.hasListeners('doubleTap')) {
-                const h = chart.getHighlightByTouchPoint(event.data.extraData.x, event.data.extraData.y);
-                chart.notify({ eventName: 'doubleTap', data: event.data, object: chart, highlight: h });
+                this.handleTouchHighlight(event, false, false, 'doubleTap');
+                // const h = chart.getHighlightByTouchPoint(event.data.extraData.x, event.data.extraData.y);
+                // chart.notify({ eventName: 'doubleTap', data: event.data, object: chart, highlight: h });
             }
-            if (chart.isDoubleTapToZoomEnabled() && chart.getData()?.getEntryCount() > 0) {
+            if (chart.doubleTapToZoomEnabled && chart.data?.entryCount > 0) {
                 const trans = this.getTrans(event.data.extraData.x, event.data.extraData.y);
-                chart.zoom(chart.isScaleXEnabled() ? 1.4 : 1, chart.isScaleYEnabled() ? 1.4 : 1, trans.x, trans.y);
+                chart.zoom(chart.scaleXEnabled ? 1.4 : 1, chart.scaleYEnabled ? 1.4 : 1, trans.x, trans.y);
                 if (Trace.isEnabled()) {
                     CLog(CLogTypes.info, LOG_TAG, 'Double-Tap, Zooming In, x: ' + trans.x + ', y: ' + trans.y);
                 }
@@ -419,19 +520,20 @@ export class BarLineChartTouchListener extends ChartTouchListener {
         }
         if (event.data.state === GestureState.END && event.data.prevState === GestureState.ACTIVE) {
             this.mLastGesture = ChartGesture.SINGLE_TAP;
-            const chart = this.mChart;
+            const chart = this.chart;
             const hasListener = chart.hasListeners('tap');
-            const isHighlightPerTapEnabled = chart.isHighlightPerTapEnabled();
+            const isHighlightPerTapEnabled = chart.highlightPerTapEnabled;
             if (!hasListener && !isHighlightPerTapEnabled) {
                 return;
             }
-            const h = chart.getHighlightByTouchPoint(event.data.extraData.x, event.data.extraData.y);
-            if (hasListener) {
-                chart.notify({ eventName: 'tap', data: event.data, object: chart, highlight: h });
-            }
-            if (isHighlightPerTapEnabled) {
-                this.performHighlight(h);
-            }
+            this.handleTouchHighlight(event, !isHighlightPerTapEnabled, false, hasListener ? 'tap' : undefined);
+            // const h = chart.getHighlightByTouchPoint(event.data.extraData.x, event.data.extraData.y);
+            // if (hasListener) {
+            //     chart.notify({ eventName: 'tap', data: event.data, object: chart, highlight: h });
+            // }
+            // if (isHighlightPerTapEnabled) {
+            //     this.performHighlight(h);
+            // }
         }
     }
     stopDeceleration() {