@kevinburke/flot 5.0.0

package/source/jquery.flot.touch.js

@@ -0,0 +1,320 @@
+
+/* global jQuery */
+
+import { plugins } from './jquery.flot.js';
+
+    'use strict';
+
+    var options = {
+        propagateSupportedGesture: false
+    };
+
+    function init(plot) {
+        plot.hooks.processOptions.push(initTouchNavigation);
+    }
+
+    function initTouchNavigation(plot, options) {
+        var gestureState = {
+                twoTouches: false,
+                currentTapStart: { x: 0, y: 0 },
+                currentTapEnd: { x: 0, y: 0 },
+                prevTap: { x: 0, y: 0 },
+                currentTap: { x: 0, y: 0 },
+                interceptedLongTap: false,
+                isUnsupportedGesture: false,
+                prevTapTime: null,
+                tapStartTime: null,
+                longTapTriggerId: null
+            },
+            maxDistanceBetweenTaps = 20,
+            maxIntervalBetweenTaps = 500,
+            maxLongTapDistance = 20,
+            minLongTapDuration = 1500,
+            pressedTapDuration = 125,
+            mainEventHolder;
+
+        function interpretGestures(e) {
+            var o = plot.getOptions();
+
+            if (!o.pan.active && !o.zoom.active) {
+                return;
+            }
+
+            updateOnMultipleTouches(e);
+            mainEventHolder.dispatchEvent(new CustomEvent('touchevent', { detail: e }));
+
+            if (isPinchEvent(e)) {
+                executeAction(e, 'pinch');
+            } else {
+                executeAction(e, 'pan');
+                if (!wasPinchEvent(e)) {
+                    if (isDoubleTap(e)) {
+                        executeAction(e, 'doubleTap');
+                    }
+                    executeAction(e, 'tap');
+                    executeAction(e, 'longTap');
+                }
+            }
+        }
+
+        function executeAction(e, gesture) {
+            switch (gesture) {
+                case 'pan':
+                    pan[e.type](e);
+                    break;
+                case 'pinch':
+                    pinch[e.type](e);
+                    break;
+                case 'doubleTap':
+                    doubleTap.onDoubleTap(e);
+                    break;
+                case 'longTap':
+                    longTap[e.type](e);
+                    break;
+                case 'tap':
+                    tap[e.type](e);
+                    break;
+            }
+        }
+
+        function bindEvents(plot, eventHolder) {
+            mainEventHolder = eventHolder;
+            eventHolder.addEventListener('touchstart', interpretGestures, false);
+            eventHolder.addEventListener('touchmove', interpretGestures, false);
+            eventHolder.addEventListener('touchend', interpretGestures, false);
+        }
+
+        function shutdown(plot, eventHolder) {
+            eventHolder.removeEventListener('touchstart', interpretGestures);
+            eventHolder.removeEventListener('touchmove', interpretGestures);
+            eventHolder.removeEventListener('touchend', interpretGestures);
+            if (gestureState.longTapTriggerId) {
+                clearTimeout(gestureState.longTapTriggerId);
+                gestureState.longTapTriggerId = null;
+            }
+        }
+
+        var pan = {
+            touchstart: function(e) {
+                updatePrevForDoubleTap();
+                updateCurrentForDoubleTap(e);
+                updateStateForLongTapStart(e);
+
+                mainEventHolder.dispatchEvent(new CustomEvent('panstart', { detail: e }));
+            },
+
+            touchmove: function(e) {
+                preventEventBehaviors(e);
+
+                updateCurrentForDoubleTap(e);
+                updateStateForLongTapEnd(e);
+
+                if (!gestureState.isUnsupportedGesture) {
+                    mainEventHolder.dispatchEvent(new CustomEvent('pandrag', { detail: e }));
+                }
+            },
+
+            touchend: function(e) {
+                preventEventBehaviors(e);
+
+                if (wasPinchEvent(e)) {
+                    mainEventHolder.dispatchEvent(new CustomEvent('pinchend', { detail: e }));
+                    mainEventHolder.dispatchEvent(new CustomEvent('panstart', { detail: e }));
+                } else if (noTouchActive(e)) {
+                    mainEventHolder.dispatchEvent(new CustomEvent('panend', { detail: e }));
+                }
+            }
+        };
+
+        var pinch = {
+            touchstart: function(e) {
+                mainEventHolder.dispatchEvent(new CustomEvent('pinchstart', { detail: e }));
+            },
+
+            touchmove: function(e) {
+                preventEventBehaviors(e);
+                gestureState.twoTouches = isPinchEvent(e);
+                if (!gestureState.isUnsupportedGesture) {
+                    mainEventHolder.dispatchEvent(new CustomEvent('pinchdrag', { detail: e }));
+                }
+            },
+
+            touchend: function(e) {
+                preventEventBehaviors(e);
+            }
+        };
+
+        var doubleTap = {
+            onDoubleTap: function(e) {
+                preventEventBehaviors(e);
+                mainEventHolder.dispatchEvent(new CustomEvent('doubletap', { detail: e }));
+            }
+        };
+
+        var longTap = {
+            touchstart: function(e) {
+                longTap.waitForLongTap(e);
+            },
+
+            touchmove: function(e) {
+            },
+
+            touchend: function(e) {
+                if (gestureState.longTapTriggerId) {
+                    clearTimeout(gestureState.longTapTriggerId);
+                    gestureState.longTapTriggerId = null;
+                }
+            },
+
+            isLongTap: function(e) {
+                var currentTime = new Date().getTime(),
+                    tapDuration = currentTime - gestureState.tapStartTime;
+                if (tapDuration >= minLongTapDuration && !gestureState.interceptedLongTap) {
+                    if (distance(gestureState.currentTapStart.x, gestureState.currentTapStart.y, gestureState.currentTapEnd.x, gestureState.currentTapEnd.y) < maxLongTapDistance) {
+                        gestureState.interceptedLongTap = true;
+                        return true;
+                    }
+                }
+                return false;
+            },
+
+            waitForLongTap: function(e) {
+                var longTapTrigger = function() {
+                    if (longTap.isLongTap(e)) {
+                        mainEventHolder.dispatchEvent(new CustomEvent('longtap', { detail: e }));
+                    }
+                    gestureState.longTapTriggerId = null;
+                };
+                if (!gestureState.longTapTriggerId) {
+                    gestureState.longTapTriggerId = setTimeout(longTapTrigger, minLongTapDuration);
+                }
+            }
+        };
+
+        var tap = {
+            touchstart: function(e) {
+                gestureState.tapStartTime = new Date().getTime();
+            },
+
+            touchmove: function(e) {
+            },
+
+            touchend: function(e) {
+                if (tap.isTap(e)) {
+                    mainEventHolder.dispatchEvent(new CustomEvent('tap', { detail: e }));
+                    preventEventBehaviors(e);
+                }
+            },
+
+            isTap: function(e) {
+                var currentTime = new Date().getTime(),
+                    tapDuration = currentTime - gestureState.tapStartTime;
+                if (tapDuration <= pressedTapDuration) {
+                    if (distance(gestureState.currentTapStart.x, gestureState.currentTapStart.y, gestureState.currentTapEnd.x, gestureState.currentTapEnd.y) < maxLongTapDistance) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        };
+
+        if (options.pan.enableTouch === true || options.zoom.enableTouch) {
+            plot.hooks.bindEvents.push(bindEvents);
+            plot.hooks.shutdown.push(shutdown);
+        };
+
+        function updatePrevForDoubleTap() {
+            gestureState.prevTap = {
+                x: gestureState.currentTap.x,
+                y: gestureState.currentTap.y
+            };
+        };
+
+        function updateCurrentForDoubleTap(e) {
+            gestureState.currentTap = {
+                x: e.touches[0].pageX,
+                y: e.touches[0].pageY
+            };
+        }
+
+        function updateStateForLongTapStart(e) {
+            gestureState.tapStartTime = new Date().getTime();
+            gestureState.interceptedLongTap = false;
+            gestureState.currentTapStart = {
+                x: e.touches[0].pageX,
+                y: e.touches[0].pageY
+            };
+            gestureState.currentTapEnd = {
+                x: e.touches[0].pageX,
+                y: e.touches[0].pageY
+            };
+        };
+
+        function updateStateForLongTapEnd(e) {
+            gestureState.currentTapEnd = {
+                x: e.touches[0].pageX,
+                y: e.touches[0].pageY
+            };
+        };
+
+        function isDoubleTap(e) {
+            var currentTime = new Date().getTime(),
+                intervalBetweenTaps = currentTime - gestureState.prevTapTime;
+
+            if (intervalBetweenTaps >= 0 && intervalBetweenTaps < maxIntervalBetweenTaps) {
+                if (distance(gestureState.prevTap.x, gestureState.prevTap.y, gestureState.currentTap.x, gestureState.currentTap.y) < maxDistanceBetweenTaps) {
+                    e.firstTouch = gestureState.prevTap;
+                    e.secondTouch = gestureState.currentTap;
+                    return true;
+                }
+            }
+            gestureState.prevTapTime = currentTime;
+            return false;
+        }
+
+        function preventEventBehaviors(e) {
+            if (!gestureState.isUnsupportedGesture) {
+                e.preventDefault();
+                if (!plot.getOptions().propagateSupportedGesture) {
+                    e.stopPropagation();
+                }
+            }
+        }
+
+        function distance(x1, y1, x2, y2) {
+            return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
+        }
+
+        function noTouchActive(e) {
+            return (e.touches && e.touches.length === 0);
+        }
+
+        function wasPinchEvent(e) {
+            return (gestureState.twoTouches && e.touches.length === 1);
+        }
+
+        function updateOnMultipleTouches(e) {
+            if (e.touches.length >= 3) {
+                gestureState.isUnsupportedGesture = true;
+            } else {
+                gestureState.isUnsupportedGesture = false;
+            }
+        }
+
+        function isPinchEvent(e) {
+            if (e.touches && e.touches.length >= 2) {
+                if (e.touches[0].target === plot.getEventHolder() &&
+                    e.touches[1].target === plot.getEventHolder()) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    plugins.push({
+        init: init,
+        options: options,
+        name: 'navigateTouch',
+        version: '0.3'
+    });

package/source/jquery.flot.touchNavigate.js

@@ -0,0 +1,357 @@
+import { plugins } from './jquery.flot.js';
+import { uiConstants } from './jquery.flot.uiConstants.js';
+import { trigger } from './helpers.js';
+
+    'use strict';
+
+    var options = {
+        zoom: {
+            enableTouch: false
+        },
+        pan: {
+            enableTouch: false,
+            touchMode: 'manual'
+        },
+        recenter: {
+            enableTouch: true
+        }
+    };
+
+    var ZOOM_DISTANCE_MARGIN = uiConstants.ZOOM_DISTANCE_MARGIN;
+
+    function init(plot) {
+        plot.hooks.processOptions.push(initTouchNavigation);
+    }
+
+    function initTouchNavigation(plot, options) {
+        var gestureState = {
+                zoomEnable: false,
+                prevDistance: null,
+                prevTapTime: 0,
+                prevPanPosition: { x: 0, y: 0 },
+                prevTapPosition: { x: 0, y: 0 }
+            },
+            navigationState = {
+                prevTouchedAxis: 'none',
+                currentTouchedAxis: 'none',
+                touchedAxis: null,
+                navigationConstraint: 'unconstrained',
+                initialState: null
+            },
+            useManualPan = options.pan.interactive && options.pan.touchMode === 'manual',
+            smartPanLock = options.pan.touchMode === 'smartLock',
+            useSmartPan = options.pan.interactive && (smartPanLock || options.pan.touchMode === 'smart'),
+            pan, pinch, doubleTap;
+
+        function bindEvents(plot, eventHolder) {
+            var o = plot.getOptions();
+
+            if (o.zoom.interactive && o.zoom.enableTouch) {
+                eventHolder.addEventListener('pinchstart', pinch.start, false);
+                eventHolder.addEventListener('pinchdrag', pinch.drag, false);
+                eventHolder.addEventListener('pinchend', pinch.end, false);
+            }
+
+            if (o.pan.interactive && o.pan.enableTouch) {
+                eventHolder.addEventListener('panstart', pan.start, false);
+                eventHolder.addEventListener('pandrag', pan.drag, false);
+                eventHolder.addEventListener('panend', pan.end, false);
+            }
+
+            if ((o.recenter.interactive && o.recenter.enableTouch)) {
+                eventHolder.addEventListener('doubletap', doubleTap.recenterPlot, false);
+            }
+        }
+
+        function shutdown(plot, eventHolder) {
+            eventHolder.removeEventListener('panstart', pan.start);
+            eventHolder.removeEventListener('pandrag', pan.drag);
+            eventHolder.removeEventListener('panend', pan.end);
+            eventHolder.removeEventListener('pinchstart', pinch.start);
+            eventHolder.removeEventListener('pinchdrag', pinch.drag);
+            eventHolder.removeEventListener('pinchend', pinch.end);
+            eventHolder.removeEventListener('doubletap', doubleTap.recenterPlot);
+        }
+
+        pan = {
+            start: function(e) {
+                presetNavigationState(e, 'pan', gestureState);
+                updateData(e, 'pan', gestureState, navigationState);
+
+                if (useSmartPan) {
+                    var point = getPoint(e, 'pan');
+                    navigationState.initialState = plot.navigationState(point.x, point.y);
+                }
+            },
+
+            drag: function(e) {
+                presetNavigationState(e, 'pan', gestureState);
+
+                if (useSmartPan) {
+                    var point = getPoint(e, 'pan');
+                    plot.smartPan({
+                        x: navigationState.initialState.startPageX - point.x,
+                        y: navigationState.initialState.startPageY - point.y
+                    }, navigationState.initialState, navigationState.touchedAxis, false, smartPanLock);
+                } else if (useManualPan) {
+                    plot.pan({
+                        left: -delta(e, 'pan', gestureState).x,
+                        top: -delta(e, 'pan', gestureState).y,
+                        axes: navigationState.touchedAxis
+                    });
+                    updatePrevPanPosition(e, 'pan', gestureState, navigationState);
+                }
+            },
+
+            end: function(e) {
+                presetNavigationState(e, 'pan', gestureState);
+
+                if (useSmartPan) {
+                    plot.smartPan.end();
+                }
+
+                if (wasPinchEvent(e, gestureState)) {
+                    updateprevPanPosition(e, 'pan', gestureState, navigationState);
+                }
+            }
+        };
+
+        var pinchDragTimeout;
+        pinch = {
+            start: function(e) {
+                if (pinchDragTimeout) {
+                    clearTimeout(pinchDragTimeout);
+                    pinchDragTimeout = null;
+                }
+                presetNavigationState(e, 'pinch', gestureState);
+                setPrevDistance(e, gestureState);
+                updateData(e, 'pinch', gestureState, navigationState);
+            },
+
+            drag: function(e) {
+                if (pinchDragTimeout) {
+                    return;
+                }
+                pinchDragTimeout = setTimeout(function() {
+                    presetNavigationState(e, 'pinch', gestureState);
+                    plot.pan({
+                        left: -delta(e, 'pinch', gestureState).x,
+                        top: -delta(e, 'pinch', gestureState).y,
+                        axes: navigationState.touchedAxis
+                    });
+                    updatePrevPanPosition(e, 'pinch', gestureState, navigationState);
+
+                    var dist = pinchDistance(e);
+
+                    if (gestureState.zoomEnable || Math.abs(dist - gestureState.prevDistance) > ZOOM_DISTANCE_MARGIN) {
+                        zoomPlot(plot, e, gestureState, navigationState);
+
+                        //activate zoom mode
+                        gestureState.zoomEnable = true;
+                    }
+                    pinchDragTimeout = null;
+                }, 1000 / 60);
+            },
+
+            end: function(e) {
+                if (pinchDragTimeout) {
+                    clearTimeout(pinchDragTimeout);
+                    pinchDragTimeout = null;
+                }
+                presetNavigationState(e, 'pinch', gestureState);
+                gestureState.prevDistance = null;
+            }
+        };
+
+        doubleTap = {
+            recenterPlot: function(e) {
+                if (e && e.detail && e.detail.type === 'touchstart') {
+                    // only do not recenter for touch start;
+                    recenterPlotOnDoubleTap(plot, e, gestureState, navigationState);
+                }
+            }
+        };
+
+        if (options.pan.enableTouch === true || options.zoom.enableTouch === true) {
+            plot.hooks.bindEvents.push(bindEvents);
+            plot.hooks.shutdown.push(shutdown);
+        }
+
+        function presetNavigationState(e, gesture, gestureState) {
+            navigationState.touchedAxis = getAxis(plot, e, gesture, navigationState);
+            if (noAxisTouched(navigationState)) {
+                navigationState.navigationConstraint = 'unconstrained';
+            } else {
+                navigationState.navigationConstraint = 'axisConstrained';
+            }
+        }
+    }
+
+    plugins.push({
+        init: init,
+        options: options,
+        name: 'navigateTouch',
+        version: '0.3'
+    });
+
+    function recenterPlotOnDoubleTap(plot, e, gestureState, navigationState) {
+        checkAxesForDoubleTap(plot, e, navigationState);
+        if ((navigationState.currentTouchedAxis === 'x' && navigationState.prevTouchedAxis === 'x') ||
+            (navigationState.currentTouchedAxis === 'y' && navigationState.prevTouchedAxis === 'y') ||
+            (navigationState.currentTouchedAxis === 'none' && navigationState.prevTouchedAxis === 'none')) {
+            plot.recenter({ axes: navigationState.touchedAxis });
+
+            if (navigationState.touchedAxis) {
+                trigger(plot.getPlaceholder(), 're-center', { axisTouched: navigationState.touchedAxis });
+            } else {
+                trigger(plot.getPlaceholder(), 're-center', e);
+            }
+        }
+    }
+
+    function checkAxesForDoubleTap(plot, e, navigationState) {
+        var axis = plot.getTouchedAxis(e.detail.firstTouch.x, e.detail.firstTouch.y);
+        if (axis[0] !== undefined) {
+            navigationState.prevTouchedAxis = axis[0].direction;
+        }
+
+        axis = plot.getTouchedAxis(e.detail.secondTouch.x, e.detail.secondTouch.y);
+        if (axis[0] !== undefined) {
+            navigationState.touchedAxis = axis;
+            navigationState.currentTouchedAxis = axis[0].direction;
+        }
+
+        if (noAxisTouched(navigationState)) {
+            navigationState.touchedAxis = null;
+            navigationState.prevTouchedAxis = 'none';
+            navigationState.currentTouchedAxis = 'none';
+        }
+    }
+
+    function zoomPlot(plot, e, gestureState, navigationState) {
+        var offset = plot.offset(),
+            center = {
+                left: 0,
+                top: 0
+            },
+            zoomAmount = pinchDistance(e) / gestureState.prevDistance,
+            dist = pinchDistance(e);
+
+        center.left = getPoint(e, 'pinch').x - offset.left;
+        center.top = getPoint(e, 'pinch').y - offset.top;
+
+        // send the computed touched axis to the zoom function so that it only zooms on that one
+        plot.zoom({
+            center: center,
+            amount: zoomAmount,
+            axes: navigationState.touchedAxis
+        });
+        gestureState.prevDistance = dist;
+    }
+
+    function wasPinchEvent(e, gestureState) {
+        return (gestureState.zoomEnable && e.detail.touches.length === 1);
+    }
+
+    function getAxis(plot, e, gesture, navigationState) {
+        if (e.type === 'pinchstart') {
+            var axisTouch1 = plot.getTouchedAxis(e.detail.touches[0].pageX, e.detail.touches[0].pageY);
+            var axisTouch2 = plot.getTouchedAxis(e.detail.touches[1].pageX, e.detail.touches[1].pageY);
+
+            if (axisTouch1.length === axisTouch2.length && axisTouch1.toString() === axisTouch2.toString()) {
+                return axisTouch1;
+            }
+        } else if (e.type === 'panstart') {
+            return plot.getTouchedAxis(e.detail.touches[0].pageX, e.detail.touches[0].pageY);
+        } else if (e.type === 'pinchend') {
+            //update axis since instead on pinch, a pan event is made
+            return plot.getTouchedAxis(e.detail.touches[0].pageX, e.detail.touches[0].pageY);
+        } else {
+            return navigationState.touchedAxis;
+        }
+    }
+
+    function noAxisTouched(navigationState) {
+        return (!navigationState.touchedAxis || navigationState.touchedAxis.length === 0);
+    }
+
+    function setPrevDistance(e, gestureState) {
+        gestureState.prevDistance = pinchDistance(e);
+    }
+
+    function updateData(e, gesture, gestureState, navigationState) {
+        var axisDir,
+            point = getPoint(e, gesture);
+
+        switch (navigationState.navigationConstraint) {
+            case 'unconstrained':
+                navigationState.touchedAxis = null;
+                gestureState.prevTapPosition = {
+                    x: gestureState.prevPanPosition.x,
+                    y: gestureState.prevPanPosition.y
+                };
+                gestureState.prevPanPosition = {
+                    x: point.x,
+                    y: point.y
+                };
+                break;
+            case 'axisConstrained':
+                axisDir = navigationState.touchedAxis[0].direction;
+                navigationState.currentTouchedAxis = axisDir;
+                gestureState.prevTapPosition[axisDir] = gestureState.prevPanPosition[axisDir];
+                gestureState.prevPanPosition[axisDir] = point[axisDir];
+                break;
+            default:
+                break;
+        }
+    }
+
+    function distance(x1, y1, x2, y2) {
+        return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
+    }
+
+    function pinchDistance(e) {
+        var t1 = e.detail.touches[0],
+            t2 = e.detail.touches[1];
+        return distance(t1.pageX, t1.pageY, t2.pageX, t2.pageY);
+    }
+
+    function updatePrevPanPosition(e, gesture, gestureState, navigationState) {
+        var point = getPoint(e, gesture);
+
+        switch (navigationState.navigationConstraint) {
+            case 'unconstrained':
+                gestureState.prevPanPosition.x = point.x;
+                gestureState.prevPanPosition.y = point.y;
+                break;
+            case 'axisConstrained':
+                gestureState.prevPanPosition[navigationState.currentTouchedAxis] =
+                point[navigationState.currentTouchedAxis];
+                break;
+            default:
+                break;
+        }
+    }
+
+    function delta(e, gesture, gestureState) {
+        var point = getPoint(e, gesture);
+
+        return {
+            x: point.x - gestureState.prevPanPosition.x,
+            y: point.y - gestureState.prevPanPosition.y
+        }
+    }
+
+    function getPoint(e, gesture) {
+        if (gesture === 'pinch') {
+            return {
+                x: (e.detail.touches[0].pageX + e.detail.touches[1].pageX) / 2,
+                y: (e.detail.touches[0].pageY + e.detail.touches[1].pageY) / 2
+            }
+        } else {
+            return {
+                x: e.detail.touches[0].pageX,
+                y: e.detail.touches[0].pageY
+            }
+        }
+    }

package/source/jquery.flot.uiConstants.js

@@ -0,0 +1,9 @@
+'use strict';
+
+export var uiConstants = {
+    SNAPPING_CONSTANT: 20,
+    PANHINT_LENGTH_CONSTANT: 10,
+    MINOR_TICKS_COUNT_CONSTANT: 4,
+    TICK_LENGTH_CONSTANT: 10,
+    ZOOM_DISTANCE_MARGIN: 25
+};