From fd91ce3dcba50c1dbcb202eda9f54368a9b3398a Mon Sep 17 00:00:00 2001 From: Luis Fernando Molina Date: Sat, 18 Jan 2020 23:13:13 +0100 Subject: [PATCH] Working Again --- Animation.js | 2 +- Canvas.js | 6 +- ChartsSpace/ChartUtilities.js | 37 +++--- ChartsSpace/TimeMachine.js | 12 +- ChartsSpace/TimelineChart.js | 29 ++--- ChartsSpace/ViewPort.js | 209 ++++++++++++++++------------------ Globals.js | 4 +- Scales/RateScale.js | 7 +- Scales/TimeFrameScale.js | 3 +- Scales/TimeScale.js | 10 +- Spaces/ChartSpace.js | 6 +- Utilities.js | 14 +-- 12 files changed, 158 insertions(+), 181 deletions(-) diff --git a/Animation.js b/Animation.js index 4aff8d1e7..cd00a0fb7 100644 --- a/Animation.js +++ b/Animation.js @@ -62,7 +62,7 @@ function newAnimation () { browserCanvas.height = window.innerHeight - CURRENT_TOP_MARGIN /* First thing is to clear the actual canvas */ - clearBrowserCanvas() + // clearBrowserCanvas() /* We loop through the callback functions collections and execute them all. */ let performanceMap = new Map() diff --git a/Canvas.js b/Canvas.js index 97a0ccac0..450b94ee7 100644 --- a/Canvas.js +++ b/Canvas.js @@ -804,7 +804,7 @@ function newCanvas () { } if (container !== undefined) { - canvas.chartSpace.viewport.applyZoom(delta) + canvas.chartSpace.viewport.onMouseWheel(delta) return false } @@ -872,7 +872,7 @@ function newCanvas () { } let downNoZoom - downNoZoom = canvas.chartSpace.viewport.unzoomThisPoint(downCopy) + downNoZoom = canvas.chartSpace.viewport.unTransformThisPoint(downCopy) let upCopy = { x: dragVector.upX, @@ -880,7 +880,7 @@ function newCanvas () { } let upNoZoom - upNoZoom = canvas.chartSpace.viewport.unzoomThisPoint(upCopy) + upNoZoom = canvas.chartSpace.viewport.unTransformThisPoint(upCopy) displaceVector = { x: upNoZoom.x - downNoZoom.x, diff --git a/ChartsSpace/ChartUtilities.js b/ChartsSpace/ChartUtilities.js index 16f47e1d0..e3ddf4cd7 100644 --- a/ChartsSpace/ChartUtilities.js +++ b/ChartsSpace/ChartUtilities.js @@ -64,11 +64,11 @@ function getTransparenceFactor (timeFrame) { function recalculatePeriod (zoomLevel) { // console.log(" recalculatePeriod > " + zoomLevel); - if (zoomLevel > 200) { + if (zoomLevel > 90) { return _1_MINUTE_IN_MILISECONDS } - if (zoomLevel > 120) { + if (zoomLevel > 85) { return _2_MINUTES_IN_MILISECONDS } @@ -76,68 +76,65 @@ function recalculatePeriod (zoomLevel) { return _3_MINUTES_IN_MILISECONDS } - if (zoomLevel > 60) { + if (zoomLevel > 75) { return _4_MINUTES_IN_MILISECONDS } - if (zoomLevel > 15) { + if (zoomLevel > 70) { return _5_MINUTES_IN_MILISECONDS } - if (zoomLevel > -7) { + if (zoomLevel > 65) { return _10_MINUTES_IN_MILISECONDS } - if (zoomLevel > -10) { + if (zoomLevel > 60) { return _15_MINUTES_IN_MILISECONDS } - if (zoomLevel > -13) { + if (zoomLevel > 55) { return _20_MINUTES_IN_MILISECONDS } - if (zoomLevel > -15) { + if (zoomLevel > 50) { return _30_MINUTES_IN_MILISECONDS } - if (zoomLevel > -16) { + if (zoomLevel > 45) { return _40_MINUTES_IN_MILISECONDS } - if (zoomLevel > -17) { + if (zoomLevel > 50) { return _45_MINUTES_IN_MILISECONDS } - if (zoomLevel > -18) { + if (zoomLevel > 35) { return _1_HOUR_IN_MILISECONDS } - if (zoomLevel > -24) { + if (zoomLevel > 30) { return _2_HOURS_IN_MILISECONDS } - if (zoomLevel > -25) { + if (zoomLevel > 25) { return _3_HOURS_IN_MILISECONDS } - if (zoomLevel > -27) { + if (zoomLevel > 20) { return _4_HOURS_IN_MILISECONDS } - if (zoomLevel > -27.5) { + if (zoomLevel > 15) { return _6_HOURS_IN_MILISECONDS } - if (zoomLevel > -27.75) { + if (zoomLevel > 10) { return _8_HOURS_IN_MILISECONDS } - if (zoomLevel > -28) { + if (zoomLevel > 5) { return _12_HOURS_IN_MILISECONDS } - if (zoomLevel <= -28) { - return ONE_DAY_IN_MILISECONDS - } return ONE_DAY_IN_MILISECONDS } diff --git a/ChartsSpace/TimeMachine.js b/ChartsSpace/TimeMachine.js index 943f70bf7..186bbe0bf 100644 --- a/ChartsSpace/TimeMachine.js +++ b/ChartsSpace/TimeMachine.js @@ -132,7 +132,7 @@ function newTimeMachine () { function initialize (callBackFunction) { timeFrame = INITIAL_TIME_PERIOD - loadFrame(thisObject.payload, thisObject.container.frame) + // loadFrame(thisObject.payload, thisObject.container.frame) recalculateCoordinateSystem() @@ -180,10 +180,10 @@ function newTimeMachine () { thisObject.timeScale.payload = thisObject.payload.node.timeScale.payload timeScaleEventSuscriptionId = thisObject.timeScale.container.eventHandler.listenToEvent('Lenght Percentage Changed', function (event) { - thisObject.container.frame.width = TIME_MACHINE_WIDTH * event.value / 100 + thisObject.container.frame.width = TIME_MACHINE_WIDTH * event.value recalculateCoordinateSystem() if (event.isUserAction === true) { - moveToUserPosition(thisObject.container, timeMachineCoordinateSystem, false, true, event.mousePosition, false, true) + moveToUserPosition(thisObject.container, timeMachineCoordinateSystem, false, true, event.mousePosition, true) } thisObject.container.eventHandler.raiseEvent('Dimmensions Changed', event) }) @@ -203,10 +203,10 @@ function newTimeMachine () { thisObject.rateScale.payload = thisObject.payload.node.rateScale.payload rateScaleEventSuscriptionId = thisObject.rateScale.container.eventHandler.listenToEvent('Height Percentage Changed', function (event) { - thisObject.container.frame.height = TIME_MACHINE_HEIGHT * event.value / 100 + thisObject.container.frame.height = TIME_MACHINE_HEIGHT * event.value recalculateCoordinateSystem() if (event.isUserAction === true) { - moveToUserPosition(thisObject.container, timeMachineCoordinateSystem, true, false, event.mousePosition, false, true) + moveToUserPosition(thisObject.container, timeMachineCoordinateSystem, true, false, event.mousePosition, true) } thisObject.container.eventHandler.raiseEvent('Dimmensions Changed', event) }) @@ -411,7 +411,7 @@ function newTimeMachine () { timelineChart.container.fitFunction = thisObject.container.fitFunction timelineChart.fitFunction = thisObject.fitFunction timelineChart.container.frame.height = thisObject.container.frame.height - timelineChart.container.frame.position.x = thisObject.container.frame.width / 2 - timelineChart.container.frame.width / 2 + timelineChart.container.frame.position.x = 0 timelineChart.container.frame.position.y = 0 timelineChart.initialize(timeMachineCoordinateSystem) diff --git a/ChartsSpace/TimelineChart.js b/ChartsSpace/TimelineChart.js index b368f2f96..b4c073f61 100644 --- a/ChartsSpace/TimelineChart.js +++ b/ChartsSpace/TimelineChart.js @@ -57,6 +57,9 @@ function newTimelineChart () { thisObject.container = newContainer() thisObject.container.initialize(MODULE_NAME) thisObject.container.detectMouseOver = true + + thisObject.container.frame.width = TIME_MACHINE_WIDTH + thisObject.container.frame.height = TIME_MACHINE_HEIGHT } function finalize () { @@ -119,8 +122,10 @@ function newTimelineChart () { thisObject.rateScale = undefined /* Resets the local container with the dimessions of its parent, the Time Machine */ + thisObject.container.frame.position.position.x = 0 thisObject.container.frame.position.position.y = 0 - thisObject.container.frame.position.height = thisObject.container.parentContainer.frame.height + thisObject.container.frame.height = TIME_MACHINE_HEIGHT + thisObject.container.frame.width = TIME_MACHINE_WIDTH } function initialize (pTimeMachineCoordinateSystem) { @@ -166,10 +171,10 @@ function newTimelineChart () { thisObject.rateScale.payload = thisObject.payload.node.rateScale.payload rateScaleEventSuscriptionId = thisObject.rateScale.container.eventHandler.listenToEvent('Height Percentage Changed', function (event) { - thisObject.container.frame.height = TIME_MACHINE_HEIGHT * event.value / 100 + thisObject.container.frame.height = TIME_MACHINE_HEIGHT * event.value recalculateCoordinateSystem() if (event.isUserAction === true) { - moveToUserPosition(thisObject.container, timelineChartCoordinateSystem, true, false, event.mousePosition, false, true) + moveToUserPosition(thisObject.container, timelineChartCoordinateSystem, true, false, event.mousePosition, true) } thisObject.container.eventHandler.raiseEvent('Dimmensions Changed', event) }) @@ -279,7 +284,7 @@ function newTimelineChart () { } let newDate = new Date(0) - newDate.setUTCSeconds(center.x / 1000) + newDate.setUTCSeconds(center.x) datetime = newDate @@ -366,22 +371,6 @@ function newTimelineChart () { } } - function tooTiny () { - if (canvas.chartSpace.viewport.zoomLevel < Math.trunc(-28.25 * 100) / 100) { - return true - } else { - return false - } - } - - function tooSmall () { - if (canvas.chartSpace.viewport.zoomLevel < Math.trunc(-27.25 * 100) / 100) { - return true - } else { - return false - } - } - function drawBackground () { if (thisObject.container.frame.isInViewPort()) { drawChartsBackground() diff --git a/ChartsSpace/ViewPort.js b/ChartsSpace/ViewPort.js index cf0e5430c..0d0f65e2c 100644 --- a/ChartsSpace/ViewPort.js +++ b/ChartsSpace/ViewPort.js @@ -1,17 +1,12 @@ function newViewport () { const MODULE_NAME = 'Viewport' - const INFO_LOG = false - const INTENSIVE_LOG = false - const ERROR_LOG = true - const logger = newWebDebugLog() - logger.fileName = MODULE_NAME - const CONSOLE_LOG = true - const MIN_ZOOM_LEVEL = -28.25 - const MAX_ZOOM_LEVEL = 1000 + const MIN_ZOOM_LEVEL = 1 + const MAX_ZOOM_LEVEL = 100 let ANIMATION_INCREMENT = 0.25 + let ANIMATION_STEPS = 5 let TOP_MARGIN = 40 + TOP_SPACE_HEIGHT let BOTTOM_MARGIN = 42 + COCKPIT_SPACE_HEIGHT @@ -34,10 +29,10 @@ function newViewport () { mousePosition: undefined, margins: MARGINS, payload: undefined, - newZoomLevel: newZoomLevel, - applyZoom: applyZoom, - zoomThisPoint: zoomThisPoint, - unzoomThisPoint: unzoomThisPoint, + changeZoom: changeZoom, + onMouseWheel: onMouseWheel, + transformThisPoint: transformThisPoint, + unTransformThisPoint: unTransformThisPoint, isThisPointVisible: isThisPointVisible, fitIntoVisibleArea: fitIntoVisibleArea, displace: displace, @@ -74,7 +69,6 @@ function newViewport () { return thisObject function finalize () { - logger = undefined thisObject.eventHandler.finalize() thisObject.payload = undefined thisObject = undefined @@ -83,6 +77,7 @@ function newViewport () { function initialize () { if (thisObject.payload !== undefined) { /* Read the position from the frame structure */ + let frame = { position: { x: 0, @@ -91,15 +86,15 @@ function newViewport () { } loadFrame(thisObject.payload, frame) if (!isNaN(frame.position.x)) { - position.x = frame.position.x + // position.x = frame.position.x } if (!isNaN(frame.position.y)) { - position.y = frame.position.y + // position.y = frame.position.y } } resize() - readObjectState() + // readObjectState() } function resize () { @@ -123,6 +118,11 @@ function newViewport () { thisObject.width = thisObject.visibleArea.topRight.x - thisObject.visibleArea.topLeft.x thisObject.height = thisObject.visibleArea.bottomRight.y - thisObject.visibleArea.topLeft.y + + thisObject.center = { + x: LEFT_MARGIN + thisObject.width / 2, + y: TOP_MARGIN + thisObject.height / 2 + } } function raiseEvents () { @@ -136,7 +136,7 @@ function newViewport () { function physics () { animationPhysics() positioningphysics() - readObjectState() + // readObjectState() } function positioningphysics () { @@ -175,57 +175,19 @@ function newViewport () { } } - function displace (displaceVector, recalculate) { - position.x = position.x + displaceVector.x - position.y = position.y + displaceVector.y - - saveObjectState() - - let event = { - newPosition: position, - recalculate: recalculate - } - - thisObject.eventHandler.raiseEvent('Position Changed', event) - - // console.log("displace produced new Position x = " + position.x + " y = " + position.y); - } - - function newZoomLevel (level) { - thisObject.zoomTargetLevel = level - thisObject.zoomLevel = level - - saveObjectState() - - ANIMATION_INCREMENT = Math.abs(thisObject.zoomTargetLevel - thisObject.zoomLevel) / 3 - - let event = { - newLevel: thisObject.zoomTargetLevel, - newPosition: position, - type: undefined - } - - thisObject.eventHandler.raiseEvent('Zoom Changed', event) - - return true - } - - function applyZoom (amount) { - // console.log("applyZoom amount: " + amount); - + function onMouseWheel (amount) { /* We adjust the sensitivity for Mac Users */ let isMac = navigator.platform.toUpperCase().indexOf('MAC') >= 0 if (isMac) { amount = amount / 5 } +/* if (amount > 0) { if (thisObject.zoomTargetLevel > -5) { amount = amount * 2 } - if (thisObject.zoomTargetLevel > 10) { amount = amount * 3 } - if (thisObject.zoomTargetLevel > 15) { amount = amount * 4 } @@ -235,35 +197,31 @@ function newViewport () { if (thisObject.zoomTargetLevel > -4) { amount = amount * 2 } - if (thisObject.zoomTargetLevel > 13) { amount = amount * 3 } - if (thisObject.zoomTargetLevel > 19) { amount = amount * 4 } } - if (thisObject.zoomTargetLevel + amount > MAX_ZOOM_LEVEL) { - return false - } - if (thisObject.zoomTargetLevel <= -27 && amount < 0) { amount = amount / 4 } - if (thisObject.zoomTargetLevel < -27 && amount > 0) { amount = amount / 4 } +*/ + if (thisObject.zoomTargetLevel + amount > MAX_ZOOM_LEVEL) { + return false + } if (thisObject.zoomTargetLevel + amount < MIN_ZOOM_LEVEL) { return false } - thisObject.zoomTargetLevel = thisObject.zoomTargetLevel + amount - ANIMATION_INCREMENT = Math.abs(thisObject.zoomTargetLevel - thisObject.zoomLevel) / 3 + ANIMATION_INCREMENT = Math.abs(thisObject.zoomTargetLevel - thisObject.zoomLevel) / ANIMATION_STEPS let event = { newLevel: thisObject.zoomTargetLevel, @@ -278,30 +236,9 @@ function newViewport () { } thisObject.eventHandler.raiseEvent('Zoom Changed', event) - return true } - function changeZoom (oldLevel, newLevel) { - let mouseNoZoom = unzoomThisPoint(thisObject.mousePosition, oldLevel) - let newMouse = zoomThisPoint(mouseNoZoom, newLevel) - - position.x = position.x - newMouse.x + thisObject.mousePosition.x - position.y = position.y - newMouse.y + thisObject.mousePosition.y - - saveObjectState() - - targetPosition.x = position.x - targetPosition.y = position.y - - positionIncrement = { - x: 0, - y: 0 - } - - thisObject.eventHandler.raiseEvent('Zoom Changed') - } - function fitIntoVisibleArea (point) { /* Here we check the boundaries of the resulting points, so they dont go out of the visible area. */ @@ -324,35 +261,74 @@ function newViewport () { return point } - function zoomThisPoint (point, level) { - let zoomFactor = increment // + increment * thisObject.zoomLevel / 100; + function displace (displaceVector, recalculate) { + position.x = position.x + displaceVector.x + position.y = position.y + displaceVector.y - if (level === undefined) { - point.x = point.x * (1 + zoomFactor * thisObject.zoomLevel) + position.x - point.y = point.y * (1 + zoomFactor * thisObject.zoomLevel) + position.y - } else { - point.x = point.x * (1 + zoomFactor * level) + position.x - point.y = point.y * (1 + zoomFactor * level) + position.y + saveObjectState() + + let event = { + newPosition: position, + recalculate: recalculate } - return point + thisObject.eventHandler.raiseEvent('Position Changed', event) + + // console.log("displace produced new Position x = " + position.x + " y = " + position.y); } - function unzoomThisPoint (pointWithZoom, level) { - let pointWithoutZoom - let zoomFactor = increment // + increment * thisObject.zoomLevel / 100; + function changeZoom (oldLevel, newLevel) { + let oldMouse = unTransformThisPoint(thisObject.mousePosition, oldLevel) + let newMouse = transformThisPoint(oldMouse, newLevel) + + position.x = position.x - newMouse.x + thisObject.mousePosition.x + position.y = position.y - newMouse.y + thisObject.mousePosition.y + + let testPoint = unTransformThisPoint(thisObject.mousePosition, newLevel) + + saveObjectState() + + targetPosition.x = position.x + targetPosition.y = position.y + + positionIncrement = { + x: 0, + y: 0 + } + + thisObject.eventHandler.raiseEvent('Zoom Changed') + } + + function transformThisPoint (point, level) { + let transformedPoint = { + x: 0, + y: 0 + } if (level === undefined) { - pointWithoutZoom = { - x: (pointWithZoom.x - position.x) / (1 + zoomFactor * thisObject.zoomLevel), - y: (pointWithZoom.y - position.y) / (1 + zoomFactor * thisObject.zoomLevel) - } + transformedPoint.x = point.x * (1 + thisObject.zoomLevel) + position.x + transformedPoint.y = point.y * (1 + thisObject.zoomLevel) + position.y } else { - pointWithoutZoom = { - x: (pointWithZoom.x - position.x) / (1 + zoomFactor * level), - y: (pointWithZoom.y - position.y) / (1 + zoomFactor * level) - } + transformedPoint.x = point.x * (1 + level) + position.x + transformedPoint.y = point.y * (1 + level) + position.y } + + return transformedPoint + } + + function unTransformThisPoint (point, level) { + let pointWithoutZoom = { + x: 0, + y: 0 + } + if (level === undefined) { + pointWithoutZoom.x = (point.x - position.x) / (1 + thisObject.zoomLevel) + pointWithoutZoom.y = (point.y - position.y) / (1 + thisObject.zoomLevel) + } else { + pointWithoutZoom.x = (point.x - position.x) / (1 + level) + pointWithoutZoom.y = (point.y - position.y) / (1 + level) + } + return pointWithoutZoom } @@ -374,7 +350,7 @@ function newViewport () { /* Save the zoom at the node config, so that the user can change it if he wishes to. */ try { let code = JSON.parse(thisObject.payload.node.code) - code.zoom = (thisObject.zoomLevel - MIN_ZOOM_LEVEL) / (MAX_ZOOM_LEVEL - MIN_ZOOM_LEVEL) * 100 + code.zoom = (thisObject.zoomTargetLevel - MIN_ZOOM_LEVEL) / (MAX_ZOOM_LEVEL - MIN_ZOOM_LEVEL) * 100 code.zoom = code.zoom.toFixed(2) thisObject.payload.node.code = JSON.stringify(code) } catch (err) { @@ -397,7 +373,7 @@ function newViewport () { if (code.zoom < MIN_ZOOM_LEVEL) { code.zoom = MIN_ZOOM_LEVEL } if (code.zoom > MAX_ZOOM_LEVEL) { code.zoom = MAX_ZOOM_LEVEL } - if (code.zoom !== thisObject.zoomLevel) { + if (code.zoom !== thisObject.zoomTargetLevel) { newZoomLevel(code.zoom) } else { saveObjectState() @@ -405,5 +381,20 @@ function newViewport () { } catch (err) { // we ignore errors here since most likely they will be parsing errors. } + + function newZoomLevel (level) { + thisObject.level = level + thisObject.zoomTargetLevel = level + saveObjectState() + ANIMATION_INCREMENT = 0 + + let event = { + newLevel: thisObject.zoomTargetLevel, + newPosition: position, + type: undefined + } + thisObject.eventHandler.raiseEvent('Zoom Changed', event) + return true + } } } diff --git a/Globals.js b/Globals.js index de949a28c..9e3c41edb 100644 --- a/Globals.js +++ b/Globals.js @@ -188,8 +188,8 @@ const PERIOD_01_MIN = "01-min"; We define here the size of the chartSpace. It has to bee enough big in order to accomodate all the charts we expect to display in this space. */ -const TIME_MACHINE_WIDTH = browserCanvas.width * 1000; -const TIME_MACHINE_HEIGHT = browserCanvas.height * 100; +const TIME_MACHINE_WIDTH = 500; +const TIME_MACHINE_HEIGHT = 100; function toRadians(angle) { return angle * (Math.PI / 180); diff --git a/Scales/RateScale.js b/Scales/RateScale.js index f1f49481b..934a70714 100644 --- a/Scales/RateScale.js +++ b/Scales/RateScale.js @@ -16,10 +16,10 @@ function newRateScale () { finalize: finalize } - const DEFAULT_VALUE = 50 - const STEP_SIZE = 2 + const DEFAULT_VALUE = 1 + const STEP_SIZE = 1 const MIN_WIDTH = 50 - const MAX_VALUE = 150 + const MAX_VALUE = 100 thisObject.container = newContainer() thisObject.container.initialize(MODULE_NAME) @@ -148,6 +148,7 @@ function newRateScale () { } function readObjectState () { + return try { let code = JSON.parse(thisObject.payload.node.code) diff --git a/Scales/TimeFrameScale.js b/Scales/TimeFrameScale.js index fb09442fc..ae8523fb5 100644 --- a/Scales/TimeFrameScale.js +++ b/Scales/TimeFrameScale.js @@ -180,7 +180,7 @@ function newTimeFrameScale () { function onViewportZoomChanged (event) { if (event !== undefined) { // it is undefined when the level is just being animated. let currentTimeFrame = thisObject.timeFrame - let timeFrame = recalculatePeriod(event.newLevel) + let timeFrame = currentTimeFrame // recalculatePeriod(event.newLevel) if (timeFrame !== currentTimeFrame) { for (let i = 0; i < timeFramesMasterArray.length; i++) { let timeFrameArray = timeFramesMasterArray[i] @@ -245,6 +245,7 @@ function newTimeFrameScale () { } function readObjectState () { + return try { let code = JSON.parse(thisObject.payload.node.code) if (code.value !== timeFrameLabel) { diff --git a/Scales/TimeScale.js b/Scales/TimeScale.js index f22047e79..f9f9cc71f 100644 --- a/Scales/TimeScale.js +++ b/Scales/TimeScale.js @@ -16,8 +16,9 @@ function newTimeScale () { finalize: finalize } - const DEFAULT_VALUE = 5 - const STEP_SIZE = 2.5 + const DEFAULT_VALUE = 1 + const STEP_SIZE = 1 + const MIN_VALUE = 1 const MAX_VALUE = 400 thisObject.container = newContainer() @@ -117,7 +118,7 @@ function newTimeScale () { delta = event.wheelDelta if (delta < 0) { thisObject.value = thisObject.value - STEP_SIZE * morePower - if (thisObject.value < STEP_SIZE) { thisObject.value = STEP_SIZE } + if (thisObject.value < MIN_VALUE) { thisObject.value = STEP_SIZE } } else { thisObject.value = thisObject.value + STEP_SIZE * morePower if (thisObject.value > MAX_VALUE) { thisObject.value = MAX_VALUE } @@ -148,6 +149,7 @@ function newTimeScale () { } function readObjectState () { + return try { let code = JSON.parse(thisObject.payload.node.code) @@ -156,7 +158,7 @@ function newTimeScale () { return } code.value = code.value / 100 * MAX_VALUE - if (code.value < STEP_SIZE) { code.value = STEP_SIZE } + if (code.value < MIN_VALUE) { code.value = STEP_SIZE } if (code.value > MAX_VALUE) { code.value = MAX_VALUE } if (code.value !== thisObject.value) { diff --git a/Spaces/ChartSpace.js b/Spaces/ChartSpace.js index 538bb912c..25d105712 100644 --- a/Spaces/ChartSpace.js +++ b/Spaces/ChartSpace.js @@ -151,7 +151,7 @@ function newChartSpace () { function oneScreenUp () { let displaceVector = { x: 0, - y: +browserCanvas.height * PERCENTAGE_OF_SCREEN_FOR_DISPLACEMENT / 100 + y: browserCanvas.height * PERCENTAGE_OF_SCREEN_FOR_DISPLACEMENT / 100 } canvas.chartSpace.viewport.displace(displaceVector) @@ -290,8 +290,8 @@ function newChartSpace () { timeMachine.payload.uiObject.setValue('Loading...') /* Setting up the new time machine. */ - timeMachine.container.frame.position.x = thisObject.container.frame.width / 2 - timeMachine.container.frame.width / 2 - timeMachine.container.frame.position.y = thisObject.container.frame.height / 2 - timeMachine.container.frame.height / 2 + timeMachine.container.frame.position.x = browserCanvas.width / 2 - TIME_MACHINE_WIDTH / 2 + timeMachine.container.frame.position.y = browserCanvas.height / 2 - TIME_MACHINE_HEIGHT / 2 timeMachine.initialize(onTimeMachineInitialized) function onTimeMachineInitialized (err) { diff --git a/Utilities.js b/Utilities.js index b192039b3..5ec3e13b4 100644 --- a/Utilities.js +++ b/Utilities.js @@ -57,13 +57,13 @@ function transformThisPoint (point, container) { /* We pass this point through the canvas.chartSpace.viewport lends, meaning we apply the canvas.chartSpace.viewport zoom and displacement. */ - point = canvas.chartSpace.viewport.zoomThisPoint(point) + point = canvas.chartSpace.viewport.transformThisPoint(point) return point } function unTransformThisPoint (point, container) { - point = canvas.chartSpace.viewport.unzoomThisPoint(point) + point = canvas.chartSpace.viewport.unTransformThisPoint(point) point = container.frame.unframeThisPoint(point) return point @@ -146,13 +146,9 @@ function getUserPosition (timeLineCoordinateSystem) { return userPosition } -function moveToUserPosition (container, timeLineCoordinateSystem, ignoreX, ignoreY, center, considerZoom, moveContainer) { +function moveToUserPosition (container, timeLineCoordinateSystem, ignoreX, ignoreY, center, moveContainer) { let userPosition = getUserPosition(timeLineCoordinateSystem) - if (considerZoom === true) { - canvas.chartSpace.viewport.newZoomLevel(userPosition.zoom) - } - INITIAL_TIME_PERIOD = recalculatePeriod(userPosition.zoom) NEW_SESSION_INITIAL_DATE = new Date(userPosition.date) @@ -190,7 +186,7 @@ function moveToUserPosition (container, timeLineCoordinateSystem, ignoreX, ignor } let targetNoZoom - targetNoZoom = canvas.chartSpace.viewport.unzoomThisPoint(targetCopy) + targetNoZoom = canvas.chartSpace.viewport.unTransformThisPoint(targetCopy) let centerCopy = { x: centerPoint.x, @@ -198,7 +194,7 @@ function moveToUserPosition (container, timeLineCoordinateSystem, ignoreX, ignor } let centerNoZoom - centerNoZoom = canvas.chartSpace.viewport.unzoomThisPoint(centerCopy) + centerNoZoom = canvas.chartSpace.viewport.unTransformThisPoint(centerCopy) displaceVector = { x: centerNoZoom.x - targetNoZoom.x,