mirror of https://github.com/ColorlibHQ/gentelella
1253 lines
54 KiB
JavaScript
1253 lines
54 KiB
JavaScript
/* eslint-disable */
|
|
/* global $, describe, it, xit, xdescribe, after, afterEach, expect*/
|
|
|
|
describe("flot touch navigate plugin", function () {
|
|
var placeholder, plot, options;
|
|
var minFrameDuration = 1 / 60 * 1000;
|
|
|
|
beforeEach(function () {
|
|
placeholder = setFixtures('<div id="test-container" style="width: 600px;height: 400px">')
|
|
.find('#test-container');
|
|
options = {
|
|
xaxes: [{ autoScale: 'exact' }],
|
|
yaxes: [{ autoScale: 'exact' }],
|
|
zoom: { interactive: true, active: true, amount: 10, enableTouch: true },
|
|
pan: { interactive: true, active: true, frameRate: -1, enableTouch: true }
|
|
};
|
|
jasmine.clock().install();
|
|
});
|
|
|
|
afterEach(function() {
|
|
jasmine.clock().uninstall();
|
|
});
|
|
|
|
it('shows that the eventHolder is cleared through shutdown when the plot is replaced', function() {
|
|
plot = $.plot(placeholder, [[]], options);
|
|
|
|
var eventPlaceholder = plot.getEventHolder(),
|
|
spy = spyOn(eventPlaceholder, 'removeEventListener').and.callThrough();
|
|
|
|
plot = $.plot(placeholder, [[]], options);
|
|
|
|
expect(spy).toHaveBeenCalledWith('panstart', jasmine.any(Function))
|
|
expect(spy).toHaveBeenCalledWith('pandrag', jasmine.any(Function));
|
|
expect(spy).toHaveBeenCalledWith('panend', jasmine.any(Function));
|
|
});
|
|
|
|
var simulateTouchEvent = function (coords, eventHolder, eventName) {
|
|
simulate.sendTouchEvents(coords, eventHolder, eventName);
|
|
jasmine.clock().tick(minFrameDuration);
|
|
}
|
|
|
|
describe('touchZoom', function() {
|
|
it('should zoom the plot',function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-1, 2],
|
|
[11, 12]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
initialCoords = [
|
|
getPairOfCoords(xaxis, yaxis, 3, 5),
|
|
getPairOfCoords(xaxis, yaxis, 7, 9)
|
|
],
|
|
finalCoords = [
|
|
getPairOfCoords(xaxis, yaxis, 2, 4),
|
|
getPairOfCoords(xaxis, yaxis, 8, 10)
|
|
],
|
|
midPointCoords = {
|
|
x: (xaxis.c2p(finalCoords[0].x - plot.offset().left) + xaxis.c2p(finalCoords[1].x - plot.offset().left)) / 2,
|
|
y: (yaxis.c2p(finalCoords[0].y - plot.offset().top) + yaxis.c2p(finalCoords[1].y - plot.offset().top)) / 2
|
|
},
|
|
amount = getDistance(finalCoords) / getDistance(initialCoords);
|
|
|
|
simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchend');
|
|
|
|
expect(xaxis.min).toBeCloseTo((midPointCoords.x - initialXmin) * (1 - 1/amount) + initialXmin, 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax - (initialXmax - midPointCoords.x) * (1 - 1/amount), 6);
|
|
expect(yaxis.min).toBeCloseTo((midPointCoords.y - initialYmin) * (1 - 1/amount) + initialYmin, 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax - (initialYmax - midPointCoords.y) * (1 - 1/amount), 6);
|
|
});
|
|
|
|
it('should pan the plot for two fingers with constant distance',function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-1, 2],
|
|
[11, 12]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 3, y : 5 }, { x : 7, y : 9 }, { x : 2, y : 4 }, { x : 6, y : 8 }],
|
|
initialCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
],
|
|
finalCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[2].x, canvasCoords[2].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[3].x, canvasCoords[3].y)
|
|
];
|
|
|
|
simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchend');
|
|
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[2].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[2].x), 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[2].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[2].y), 6);
|
|
});
|
|
|
|
it('should not zoom the plot for two fingers with small distance variation',function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-1, 2],
|
|
[11, 12]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 3, y : 5 }, { x : 7, y : 8.999 }, { x : 2, y : 4 }, { x : 6.001, y : 8 }],
|
|
initialCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
],
|
|
finalCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[2].x, canvasCoords[2].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[3].x, canvasCoords[3].y)
|
|
];
|
|
|
|
var spy = spyOn(plot, 'zoom').and.callThrough();
|
|
|
|
simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchend');
|
|
|
|
expect(spy).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should zoom the plot correctly using pageXY when the canvas is placed in the bottom scrollable area of the page', function () {
|
|
var largeDiv = $('<div style="height: 800px"> </div>');
|
|
$(largeDiv).insertBefore(placeholder);
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-1, 2],
|
|
[11, 12]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
initialCoords = [
|
|
getPairOfCoords(xaxis, yaxis, 3, 5),
|
|
getPairOfCoords(xaxis, yaxis, 7, 9)
|
|
],
|
|
finalCoords = [
|
|
getPairOfCoords(xaxis, yaxis, 2, 4),
|
|
getPairOfCoords(xaxis, yaxis, 8, 10)
|
|
],
|
|
midPointCoords = {
|
|
x: (xaxis.c2p(finalCoords[0].x - plot.offset().left) + xaxis.c2p(finalCoords[1].x - plot.offset().left)) / 2,
|
|
y: (yaxis.c2p(finalCoords[0].y - plot.offset().top) + yaxis.c2p(finalCoords[1].y - plot.offset().top)) / 2
|
|
},
|
|
amount = getDistance(finalCoords) / getDistance(initialCoords);
|
|
|
|
simulateTouchEvent(initialCoords, plot.getEventHolder(), 'touchstart');
|
|
simulateTouchEvent(finalCoords, plot.getEventHolder(), 'touchmove');
|
|
simulateTouchEvent(finalCoords, plot.getEventHolder(), 'touchend');
|
|
|
|
expect(xaxis.min).toBeCloseTo((midPointCoords.x - initialXmin) * (1 - 1/amount) + initialXmin, 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax - (initialXmax - midPointCoords.x) * (1 - 1/amount), 6);
|
|
expect(yaxis.min).toBeCloseTo((midPointCoords.y - initialYmin) * (1 - 1/amount) + initialYmin, 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax - (initialYmax - midPointCoords.y) * (1 - 1/amount), 6);
|
|
});
|
|
|
|
it('should zoom the entire plot for touches not on the same axis',function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-1, 2],
|
|
[11, 12]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
initialCoords = [
|
|
{ x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 },
|
|
{ x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top - 10 }
|
|
],
|
|
finalCoords = [
|
|
getPairOfCoords(xaxis, yaxis, 2, 4),
|
|
getPairOfCoords(xaxis, yaxis, 6, 6)
|
|
],
|
|
midPointCoords = {
|
|
x: (xaxis.c2p(finalCoords[0].x - plot.offset().left) + xaxis.c2p(finalCoords[1].x - plot.offset().left)) / 2,
|
|
y: (yaxis.c2p(finalCoords[0].y - plot.offset().top) + yaxis.c2p(finalCoords[1].y - plot.offset().top)) / 2
|
|
},
|
|
amount = getDistance(finalCoords) / getDistance(initialCoords);
|
|
|
|
simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchend');
|
|
|
|
expect(xaxis.min).not.toBeCloseTo(initialYmin, 6);
|
|
expect(xaxis.max).not.toBeCloseTo(initialYmax, 6);
|
|
expect(yaxis.min).not.toBeCloseTo(initialYmin, 6);
|
|
expect(yaxis.max).not.toBeCloseTo(initialYmax, 6);
|
|
});
|
|
|
|
it('should zoom the plot on axis x',function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-1, 2],
|
|
[11, 12]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
initialCoords = [
|
|
{ x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 },
|
|
{ x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top + 10 }
|
|
],
|
|
finalCoords = [
|
|
getPairOfCoords(xaxis, yaxis, 2, 4),
|
|
getPairOfCoords(xaxis, yaxis, 6, 6)
|
|
],
|
|
midPointCoords = {
|
|
x: (xaxis.c2p(finalCoords[0].x - plot.offset().left) + xaxis.c2p(finalCoords[1].x - plot.offset().left)) / 2,
|
|
y: (yaxis.c2p(finalCoords[0].y - plot.offset().top) + yaxis.c2p(finalCoords[1].y - plot.offset().top)) / 2
|
|
},
|
|
amount = getDistance(finalCoords) / getDistance(initialCoords);
|
|
|
|
simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchend');
|
|
|
|
expect(Math.abs(xaxis.min - ((midPointCoords.x - initialXmin) * (1 - 1/amount) + initialXmin))).toBeLessThan(1);
|
|
expect(Math.abs(xaxis.max - (initialXmax - (initialXmax - midPointCoords.x) * (1 - 1/amount)))).toBeLessThan(1);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin, 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax, 6);
|
|
});
|
|
|
|
it('should zoom the plot on axis y',function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-1, 2],
|
|
[11, 12]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
initialCoords = [
|
|
{ x: xaxis.box.left - 10, y: yaxis.p2c(4) + plot.offset().top},
|
|
{ x: xaxis.box.left - 11, y: yaxis.p2c(5) + plot.offset().top}
|
|
],
|
|
finalCoords = [
|
|
getPairOfCoords(xaxis, yaxis, 2, 4),
|
|
getPairOfCoords(xaxis, yaxis, 6, 6)
|
|
],
|
|
midPointCoords = {
|
|
x: (xaxis.c2p(finalCoords[0].x - plot.offset().left) + xaxis.c2p(finalCoords[1].x - plot.offset().left)) / 2,
|
|
y: (yaxis.c2p(finalCoords[0].y - plot.offset().top) + yaxis.c2p(finalCoords[1].y - plot.offset().top)) / 2
|
|
},
|
|
amount = getDistance(finalCoords) / getDistance(initialCoords);
|
|
|
|
simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchend');
|
|
|
|
expect(xaxis.min).toBeCloseTo(initialXmin, 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax, 6);
|
|
expect(Math.abs(yaxis.min - ((midPointCoords.y - initialYmin) * (1 - 1/amount) + initialYmin))).toBeLessThan(1);
|
|
expect(Math.abs(yaxis.max - (initialYmax - (initialYmax - midPointCoords.x) * (1 - 1/amount)))).toBeLessThan(1);
|
|
});
|
|
|
|
it('should not zoom the plot on axis for axis zoom not enabled',function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[0, 0],
|
|
[10, 10]
|
|
]
|
|
], {
|
|
xaxes: [{ autoScale: 'exact', axisZoom: false, axisPan: false }],
|
|
yaxes: [{ autoScale: 'exact' }],
|
|
zoom: { interactive: true, active: true, amount: 10 },
|
|
pan: { interactive: true, active: true, frameRate: -1, enableTouch: true }
|
|
});
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialCoords = [
|
|
{ x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 },
|
|
{ x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top + 10 }
|
|
],
|
|
finalCoords = [
|
|
getPairOfCoords(xaxis, yaxis, 2, 4),
|
|
getPairOfCoords(xaxis, yaxis, 6, 6)
|
|
],
|
|
amount = getDistance(finalCoords) / getDistance(initialCoords);
|
|
|
|
simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchend');
|
|
|
|
expect(xaxis.min).toBe(0);
|
|
expect(xaxis.max).toBe(10);
|
|
expect(yaxis.min).toBe(0);
|
|
expect(yaxis.max).toBe(10);
|
|
});
|
|
|
|
it('should not zoom the axis for plot zoom not enabled',function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[0, 0],
|
|
[10, 10]
|
|
]
|
|
], {
|
|
xaxes: [{ autoScale: 'exact', plotZoom: false, plotPan: false }],
|
|
yaxes: [{ autoScale: 'exact' }],
|
|
zoom: { interactive: true, active: true, amount: 10, enableTouch: true },
|
|
pan: { interactive: true, active: true, frameRate: -1, enableTouch: true }
|
|
});
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialCoords = [
|
|
{ x: 0, y: 10 },
|
|
{ x: 1, y: 50 }
|
|
],
|
|
finalCoords = [
|
|
getPairOfCoords(xaxis, yaxis, 2, 4),
|
|
getPairOfCoords(xaxis, yaxis, 6, 6)
|
|
],
|
|
amount = getDistance(finalCoords) / getDistance(initialCoords);
|
|
|
|
simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
|
|
simulateTouchEvent(finalCoords, eventHolder, 'touchend');
|
|
|
|
expect(xaxis.min).toBe(0);
|
|
expect(xaxis.max).toBe(10);
|
|
expect(yaxis.min).not.toBe(0);
|
|
expect(yaxis.max).not.toBe(10);
|
|
});
|
|
|
|
function getDistance(coords) {
|
|
return Math.sqrt((coords[0].x - coords[1].x) * (coords[0].x - coords[1].x) + ((coords[0].y - coords[1].y) * (coords[0].y - coords[1].y)));
|
|
}
|
|
});
|
|
|
|
describe('touchDrag', function() {
|
|
it('should drag the plot',function() {
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 100 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
];
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.
|
|
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
});
|
|
|
|
it('should snap horizontal drag to x direction in smart pan mode', function() {
|
|
var oldTouchMode = options.pan.touchMode;
|
|
options.pan.touchMode = 'smart';
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0];
|
|
|
|
var initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 2 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.
|
|
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBe(initialYmin);
|
|
expect(yaxis.max).toBe(initialYmax);
|
|
|
|
options.pan.touchMode = oldTouchMode;
|
|
});
|
|
|
|
it('should snap vertical drag to x direction in smart pan mode', function() {
|
|
var oldTouchMode = options.pan.touchMode;
|
|
options.pan.touchMode = 'smart';
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0];
|
|
|
|
var initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 1 }, { x : 2, y : 100 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.
|
|
|
|
expect(xaxis.min).toBe(initialXmin);
|
|
expect(xaxis.max).toBe(initialXmax);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
|
|
options.pan.touchMode = oldTouchMode;
|
|
});
|
|
|
|
it('should no snap diagonal drag in smart pan mode', function() {
|
|
var oldTouchMode = options.pan.touchMode;
|
|
options.pan.touchMode = 'smart';
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0];
|
|
|
|
var initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 100 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.
|
|
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
|
|
options.pan.touchMode = oldTouchMode;
|
|
});
|
|
|
|
it('should snap horizontally-start-drag to x direction in smartLock pan mode', function() {
|
|
var oldTouchMode = options.pan.touchMode;
|
|
options.pan.touchMode = 'smartLock';
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0];
|
|
|
|
var initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 2 }, { x: 100, y: 100 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[2].x, canvasCoords[2].y)
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchmove(eventHolder, pointCoords[2].x, pointCoords[2].y);
|
|
simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.
|
|
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBe(initialYmin);
|
|
expect(yaxis.max).toBe(initialYmax);
|
|
|
|
options.pan.touchMode = oldTouchMode;
|
|
});
|
|
|
|
it('should snap vertically-start-drag to y direction in smartLock pan mode', function() {
|
|
var oldTouchMode = options.pan.touchMode;
|
|
options.pan.touchMode = 'smartLock';
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0];
|
|
|
|
var initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 1 }, { x : 2, y : 100 }, { x: 100, y: 100 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[2].x, canvasCoords[2].y)
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchmove(eventHolder, pointCoords[2].x, pointCoords[2].y);
|
|
simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.
|
|
|
|
expect(xaxis.min).toBe(initialXmin);
|
|
expect(xaxis.max).toBe(initialXmax);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
|
|
options.pan.touchMode = oldTouchMode;
|
|
});
|
|
|
|
it('should not drag if pan mode is invalid', function () {
|
|
var oldTouchMode = options.pan.touchMode;
|
|
options.pan.touchMode = '';
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 100 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
];
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.
|
|
|
|
expect(xaxis.min).toBe(initialXmin);
|
|
expect(xaxis.max).toBe(initialXmax);
|
|
expect(yaxis.min).toBe(initialYmin);
|
|
expect(yaxis.max).toBe(initialYmax);
|
|
|
|
options.pan.touchMode = oldTouchMode;
|
|
});
|
|
|
|
it('should drag the logarithmic plot', function() {
|
|
var d1 = [];
|
|
for (var i = 0; i < 14; i += 0.2) {
|
|
d1.push([i, 1.01 + Math.sin(i)]);
|
|
}
|
|
|
|
var plot = $.plot(placeholder, [d1], {
|
|
series: {
|
|
lines: { show: true },
|
|
points: { show: true }
|
|
},
|
|
xaxis: { autoScale: 'exact' },
|
|
yaxis: { mode: 'log', showTickLabels: "all", autoScale: 'exact' },
|
|
zoom: { interactive: true, active: true },
|
|
pan: { interactive: true, active: true, enableTouch: true }
|
|
});
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 4, y : 0.7 }, { x : 2, y : 10 } ],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBeCloseTo((yaxis.c2p(yaxis.p2c(initialYmin) + (pointCoords[0].y - pointCoords[1].y))), 6);
|
|
expect(yaxis.max).toBeCloseTo((yaxis.c2p(yaxis.p2c(initialYmax) + (pointCoords[0].y - pointCoords[1].y))), 6);
|
|
|
|
});
|
|
|
|
it('should drag the point in the same way for many sequential moves as for one long move',function() {
|
|
|
|
//deactivate ticks for precision
|
|
options.yaxes[0].showTickLabels = 'none';
|
|
options.xaxes[0].showTickLabels = 'all';
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
limit = 5,
|
|
canvasCoords = [],
|
|
pointCoords = [];
|
|
|
|
for (var i = 1; i <= limit; i++) {
|
|
canvasCoords[i] = { x: i, y: i };
|
|
pointCoords[i] = getPairOfCoords(xaxis, yaxis, canvasCoords[i].x, canvasCoords[i].y);
|
|
}
|
|
|
|
//simulate drag from (1, 1) to (100, 100) sequentially
|
|
simulate.touchstart(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
for (var i = 2; i <= limit; i++) {
|
|
simulate.touchmove(eventHolder, pointCoords[i].x, pointCoords[i].y);
|
|
}
|
|
|
|
simulate.touchend(eventHolder, pointCoords[limit].x, pointCoords[limit].y);
|
|
|
|
// compare axes after sequential drag with axes after direct drag
|
|
expect(Math.abs(xaxis.min - (initialXmin + (canvasCoords[1].x - canvasCoords[limit].x)))).toBeLessThan(1);
|
|
expect(Math.abs(xaxis.max - (initialXmax + (canvasCoords[1].x - canvasCoords[limit].x)))).toBeLessThan(1);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[1].y - canvasCoords[limit].y), 0);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[1].y - canvasCoords[limit].y), 0);
|
|
});
|
|
|
|
it('should not pan the plot for a finger outside canvas',function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, 120],
|
|
[-10, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 20, y : 20 }, { x : 120, y : 120 }],
|
|
plotRight = plot.width() + plot.offset().left + plot.offset().right,
|
|
plotBottom = plot.height() + plot.offset().top + plot.offset().bottom,
|
|
pointCoords = [
|
|
{x: plotRight + canvasCoords[0].x, y: plotBottom + canvasCoords[0].y},
|
|
{x: plotRight + canvasCoords[1].x, y: plotBottom + canvasCoords[1].y}
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
expect(xaxis.min).toBeCloseTo(initialXmin, 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax, 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin, 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax, 6);
|
|
});
|
|
|
|
it('should not pan the plot for a finger which comes from outside canvas',function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, 120],
|
|
[-10, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 20, y : 20 }, { x : 120, y : 120 }],
|
|
plotRight = plot.width() + plot.offset().left + plot.offset().right,
|
|
plotBottom = plot.height() + plot.offset().top + plot.offset().bottom,
|
|
pointCoords = [
|
|
{x: plotRight + canvasCoords[0].x, y: plotBottom + canvasCoords[0].y},
|
|
{x: canvasCoords[1].x, y: canvasCoords[1].y}
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
expect(xaxis.min).toBeCloseTo(initialXmin, 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax, 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin, 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax, 6);
|
|
});
|
|
|
|
it('should drag the plot on the yaxis only', function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[0, 0],
|
|
[10, 10]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
pointCoords = [
|
|
{ x: xaxis.box.left - 10, y: yaxis.p2c(4) },
|
|
{ x: xaxis.box.left - 20, y: yaxis.p2c(5) }
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
expect(xaxis.min).toBe(0);
|
|
expect(xaxis.max).toBe(10);
|
|
expect(yaxis.min).toBeCloseTo(yaxis.c2p(yaxis.p2c(initialYmin) + (pointCoords[0].y - pointCoords[1].y)), 6);
|
|
expect(yaxis.max).toBeCloseTo(yaxis.c2p(yaxis.p2c(initialYmax) + (pointCoords[0].y - pointCoords[1].y)), 6);
|
|
});
|
|
|
|
it('should drag the plot on the xaxis only', function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[0, 0],
|
|
[10, 10]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
pointCoords = [
|
|
{ x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 },
|
|
{ x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top + 15 }
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
expect(xaxis.min).toBeCloseTo(xaxis.c2p(xaxis.p2c(initialXmin) + (pointCoords[0].x - pointCoords[1].x)), 6);
|
|
expect(xaxis.max).toBeCloseTo(xaxis.c2p(xaxis.p2c(initialXmax) + (pointCoords[0].x - pointCoords[1].x)), 6);
|
|
expect(yaxis.min).toBe(0);
|
|
expect(yaxis.max).toBe(10);
|
|
});
|
|
|
|
it('should not drag the plot on axis for axis pan not enabled', function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[0, 0],
|
|
[10, 10]
|
|
]
|
|
], {
|
|
xaxes: [{ autoScale: 'exact', axisPan: false }],
|
|
yaxes: [{ autoScale: 'exact' }],
|
|
zoom: { interactive: true, active: true, amount: 10 },
|
|
pan: { interactive: true, active: true, frameRate: -1, enableTouch: true }
|
|
});
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
pointCoords = [
|
|
{ x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 },
|
|
{ x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top + 15 }
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
expect(xaxis.min).toBe(0);
|
|
expect(yaxis.max).toBe(10);
|
|
expect(yaxis.min).toBe(0);
|
|
expect(yaxis.max).toBe(10);
|
|
});
|
|
|
|
it('should not drag the axis for plot pan not enabled', function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[0, 0],
|
|
[10, 10]
|
|
]
|
|
], {
|
|
xaxes: [{ autoScale: 'exact', plotPan: false }],
|
|
yaxes: [{ autoScale: 'exact', plotPan: false }],
|
|
zoom: { interactive: true, active: true, amount: 10 },
|
|
pan: { interactive: true, active: true, frameRate: -1, enableTouch: true }
|
|
});
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
pointCoords = [
|
|
{ x: 0, y: 50 },
|
|
{ x: 50, y: 100 }
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
expect(xaxis.min).toBe(0);
|
|
expect(xaxis.max).toBe(10);
|
|
expect(yaxis.min).toBe(0);
|
|
expect(yaxis.max).toBe(10);
|
|
});
|
|
|
|
it('should recompute the axis to drag after a pinch event ended',function() {
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-1, 2],
|
|
[11, 12]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
previousXmin, previousXmax, previousYmin, previousYmax,
|
|
initialCoords = [
|
|
getPairOfCoords(xaxis, yaxis, 1, 3),
|
|
getPairOfCoords(xaxis, yaxis, 2, 4),
|
|
],
|
|
midPointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, 3, 7),
|
|
{ x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 }
|
|
],
|
|
finalCoordsPinch = [
|
|
{ x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 }
|
|
],
|
|
finalCoordsPan = [
|
|
{ x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top + 15 }
|
|
];
|
|
|
|
//simulate pinch
|
|
simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
|
|
simulateTouchEvent(midPointCoords, eventHolder, 'touchmove');
|
|
simulateTouchEvent(finalCoordsPinch, eventHolder, 'touchend');
|
|
|
|
previousXmin = xaxis.min;
|
|
previousXmax = xaxis.max;
|
|
previousYmin = yaxis.min;
|
|
previousYmax = yaxis.max;
|
|
|
|
expect(previousXmin).not.toBeCloseTo(initialXmin, 6);
|
|
expect(previousXmax).not.toBeCloseTo(initialXmax, 6);
|
|
expect(previousYmin).not.toBeCloseTo(initialYmin, 6);
|
|
expect(previousYmax).not.toBeCloseTo(initialYmax, 6);
|
|
|
|
//simulate pan after pinch event
|
|
simulateTouchEvent(finalCoordsPan, eventHolder, 'touchmove');
|
|
simulateTouchEvent(finalCoordsPan, eventHolder, 'touchend');
|
|
|
|
expect(xaxis.min).toBeCloseTo(xaxis.c2p(xaxis.p2c(previousXmin) + (finalCoordsPinch[0].x - finalCoordsPan[0].x)), 6);
|
|
expect(xaxis.max).toBeCloseTo(xaxis.c2p(xaxis.p2c(previousXmax) + (finalCoordsPinch[0].x - finalCoordsPan[0].x)), 6);
|
|
expect(yaxis.min).toBe(previousYmin);
|
|
expect(yaxis.max).toBe(previousYmax);
|
|
});
|
|
|
|
it('can disable pinch', function() {
|
|
var oldTouchZoom = options.zoom.enableTouch;
|
|
options.zoom.enableTouch = false;
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0];
|
|
|
|
var initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 5 }],
|
|
initialCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x + 1, canvasCoords[0].y + 1),
|
|
],
|
|
finalCoordsPinch = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x + 1, canvasCoords[1].y + 1),
|
|
];
|
|
|
|
//simulate pinch
|
|
simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
|
|
simulateTouchEvent(finalCoordsPinch, eventHolder, 'touchmove');
|
|
simulateTouchEvent(finalCoordsPinch, eventHolder, 'touchend');
|
|
|
|
expect(xaxis.min).toBe(initialXmin);
|
|
expect(xaxis.max).toBe(initialXmax);
|
|
expect(yaxis.min).toBe(initialYmin);
|
|
expect(yaxis.max).toBe(initialYmax);
|
|
|
|
options.zoom.enableTouch = oldTouchZoom;
|
|
})
|
|
});
|
|
|
|
describe('doubleTap', function() {
|
|
it('should recenter the plot',function() {
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, 120],
|
|
[-10, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 2 }, { x : 3, y : 5 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
//check if the drag modified the plot correctly
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
|
|
//simulate double tap
|
|
simulate.touchstart(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchstart(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
//check if axis values returned to initial coordinates
|
|
expect(xaxis.min).toBeCloseTo(initialXmin, 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax, 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin, 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax, 6);
|
|
|
|
});
|
|
|
|
it('should not recenter for doubletap event triggered by touchmove', function() {
|
|
//when touchmove to somewhere close to last doubletap point, another doubletap will be triggered
|
|
//this doubletap event should not do recenter
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, 120],
|
|
[-10, 120]
|
|
]
|
|
], options);
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 2 }, { x : 3, y : 5 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
];
|
|
|
|
//simulate double tap
|
|
simulate.touchstart(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchstart(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
//drag the plot
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
//check if the drag modified the plot correctly
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
});
|
|
|
|
it('should recenter the plot on axis x',function() {
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 2 }, { x : 3, y : 5 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
//check if the drag modified the plot correctly
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
|
|
//simulate double tap
|
|
simulate.touchstart(eventHolder, xaxis.p2c(5), xaxis.box.top + plot.offset().top + 15);
|
|
simulate.touchend(eventHolder, xaxis.p2c(5), xaxis.box.top + plot.offset().top + 15);
|
|
simulate.touchstart(eventHolder, xaxis.p2c(5), xaxis.box.top + plot.offset().top + 15);
|
|
simulate.touchend(eventHolder, xaxis.p2c(5), xaxis.box.top + plot.offset().top + 15);
|
|
|
|
//check if axis values returned to initial coordinates
|
|
expect(xaxis.min).toBeCloseTo(initialXmin, 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax, 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
});
|
|
|
|
it('should recenter the plot on axis y',function() {
|
|
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 2 }, { x : 3, y : 5 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
//check if the drag modified the plot correctly
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
|
|
//simulate double tap
|
|
simulate.touchstart(eventHolder, xaxis.box.left - 20, yaxis.p2c(5));
|
|
simulate.touchend(eventHolder, xaxis.box.left - 20, yaxis.p2c(5));
|
|
simulate.touchstart(eventHolder, xaxis.box.left - 20, yaxis.p2c(5));
|
|
simulate.touchend(eventHolder, xaxis.box.left - 20, yaxis.p2c(5));
|
|
|
|
//check if axis values returned to initial coordinates
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin, 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax, 6);
|
|
});
|
|
|
|
it('should not recenter the plot for one touch inside axis box and one inside plot area', function(){
|
|
plot = $.plot(placeholder, [
|
|
[
|
|
[-10, -10],
|
|
[120, 120]
|
|
]
|
|
], options);
|
|
|
|
var eventHolder = plot.getEventHolder(),
|
|
xaxis = plot.getXAxes()[0],
|
|
yaxis = plot.getYAxes()[0],
|
|
initialXmin = xaxis.min,
|
|
initialXmax = xaxis.max,
|
|
initialYmin = yaxis.min,
|
|
initialYmax = yaxis.max,
|
|
canvasCoords = [ { x : 1, y : 2 }, { x : 3, y : 5 }],
|
|
pointCoords = [
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
|
|
getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
|
|
];
|
|
|
|
simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
|
|
simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
|
|
|
|
//check if the drag modified the plot correctly
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
|
|
//simulate double tap
|
|
simulate.touchstart(eventHolder, xaxis.box.left - 20, yaxis.p2c(5));
|
|
simulate.touchend(eventHolder, xaxis.box.left - 20, yaxis.p2c(5));
|
|
simulate.touchstart(eventHolder, 10, 20);
|
|
simulate.touchend(eventHolder, 10, 20);
|
|
|
|
//check if axis values remained the same
|
|
expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
|
|
expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
|
|
});
|
|
});
|
|
|
|
function getPairOfCoords(xaxis, yaxis, x, y) {
|
|
return {
|
|
x : xaxis.p2c(x) + plot.offset().left,
|
|
y : yaxis.p2c(y) + plot.offset().top
|
|
}
|
|
}
|
|
});
|