diff --git a/.vs/AAWeb/v15/.suo b/.vs/AAWeb/v15/.suo index 363efc75f..d69fdfb98 100644 Binary files a/.vs/AAWeb/v15/.suo and b/.vs/AAWeb/v15/.suo differ diff --git a/Animation.js b/Animation.js index de5aa8683..03b35df4a 100644 --- a/Animation.js +++ b/Animation.js @@ -1,18 +1,24 @@ -/* - -Essentially, what the animation object does, is to call several functions in order to draw the content of each frame. -To do that, it has an array of functions that need to be called, and it just goes one by one through them. His parent object -is responsible for providing more functions to call, or removing functions from its list when they are not longer needed. - -*/ - + function newAnimation() { - var animationLoopHandle; // This is the handle to the animation loop. With this handle we can cancel the loop, for instance. - var callBackFunctions = new Map(); - var clearCanvasFunction; + const MODULE_NAME = "Animation"; + const INFO_LOG = false; + const ERROR_LOG = true; + const logger = newDebugLog(); + logger.fileName = MODULE_NAME; - var animation = { + /* + + Essentially, what the animation object does, is to call several functions in order to draw the content of each frame. + To do that, it has an array of functions that need to be called, and it just goes one by one through them. His parent object + is responsible for providing more functions to call, or removing functions from its list when they are not longer needed. + + */ + + let animationLoopHandle; // This is the handle to the animation loop. With this handle we can cancel the loop, for instance. + let callBackFunctions = new Map(); + + let thisObject = { start: start, stop: stop, addCallBackFunction: addCallBackFunction, @@ -20,61 +26,122 @@ function newAnimation() { initialize: initialize }; - return animation; + return thisObject; function initialize(callBackFunction) { - /* We store the function to be called each time we need to draw a new animation frame. */ + try { - clearCanvasFunction = callBackFunction; + if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); } + + /* Nothing to do here yet. */ + callBackFunction(GLOBAL.CUSTOM_OK_RESPONSE); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err = " + err); } + callBackFunction(GLOBAL.CUSTOM_FAIL_RESPONSE); + } } - function start() { + function start(callBackFunction) { - animationLoop(); // Inside this function the animation process is started, and at the same time it creates a loop. + try { + if (INFO_LOG === true) { logger.write("[INFO] start -> Entering function."); } + + animationLoop(); // Inside this function the animation process is started, and at the same time it creates a loop. + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] start -> err = " + err); } + callBackFunction(GLOBAL.CUSTOM_FAIL_RESPONSE); + } } - function stop() { + function stop(callBackFunction) { - window.cancelAnimationFrame(animationLoopHandle); + try { + if (INFO_LOG === true) { logger.write("[INFO] stop -> Entering function."); } + + window.cancelAnimationFrame(animationLoopHandle); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] stop -> err = " + err); } + callBackFunction(GLOBAL.CUSTOM_FAIL_RESPONSE); + } } - function addCallBackFunction(key, callBackFunction) { + function addCallBackFunction(key, callBack, callBackFunction) { - callBackFunctions.set(key, callBackFunction); + try { + + if (INFO_LOG === true) { logger.write("[INFO] addCallBackFunction -> Entering function."); } + + callBackFunctions.set(key, callBack); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] addCallBackFunction -> err = " + err); } + callBackFunction(GLOBAL.CUSTOM_FAIL_RESPONSE); + } } function removeCallBackFunction(key, callBackFunction) { - callBackFunctions.delete(key); + try { + + if (INFO_LOG === true) { logger.write("[INFO] removeCallBackFunction -> Entering function."); } + + callBackFunctions.delete(key); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] removeCallBackFunction -> err = " + err); } + callBackFunction(GLOBAL.CUSTOM_FAIL_RESPONSE); + } } - function animationLoop() { + function animationLoop(callBackFunction) { - /* First thing is to clear the actual canvas */ + try { - clearCanvasFunction(); + if (INFO_LOG === true) { logger.write("[INFO] animationLoop -> Entering function."); } - /* We loop through the callback functions collections and execute them all. */ + /* First thing is to clear the actual canvas */ - callBackFunctions.forEach(function (callBackFunction) { + clearBrowserCanvas(); - callBackFunction(); + /* We loop through the callback functions collections and execute them all. */ - }); + callBackFunctions.forEach(function (callBackFunction) { + callBackFunction(); - /* We animate the zoom of the viewPort */ + }); - viewPort.animate(); - viewPort.draw(); + /* We request the next frame to be drawn, and stablishing a loop */ - /* We request the next frame to be drawn, and stablishing a loop */ + animationLoopHandle = window.requestAnimationFrame(animationLoop); - animationLoopHandle = window.requestAnimationFrame(animationLoop); + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] animationLoop -> err = " + err); } + + if (callBackFunction !== undefined) { // When the loop is called by the browser there will be no callBackFunction. + callBackFunction(GLOBAL.CUSTOM_FAIL_RESPONSE); + } + } + } + + function clearBrowserCanvas() { + + if (INFO_LOG === true) { logger.write("[INFO] clearBrowserCanvas -> Entering function."); } + + browserCanvasContext.clearRect(0, 0, browserCanvas.width, browserCanvas.height); } } diff --git a/Canvas.js b/Canvas.js index 6ec8c9138..2478b2a94 100644 --- a/Canvas.js +++ b/Canvas.js @@ -38,6 +38,7 @@ function newCanvas() { const MODULE_NAME = "Canvas"; const INFO_LOG = false; + const ERROR_LOG = true; const logger = newDebugLog(); logger.fileName = MODULE_NAME; @@ -73,7 +74,7 @@ function newCanvas() { return thisObject; - function initialize() { + function initialize(callBackFunction) { if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); } @@ -104,18 +105,60 @@ function newCanvas() { splashScreen.initialize(); let animation = newAnimation(); - animation.initialize(clearBrowserCanvas); + animation.initialize(onAnimationInitialized); - this.animation = animation; + function onAnimationInitialized(err) { - /* Here we add all the functions that will be called during the animation cycle. */ + this.animation = animation; - animation.addCallBackFunction("Chart Space", thisObject.chartSpace.draw); - animation.addCallBackFunction("Floating Space", thisObject.floatingSpace.physicsLoop); - animation.addCallBackFunction("Panels Space", thisObject.panelsSpace.draw); - animation.addCallBackFunction("Splash Screen", splashScreen.draw); - animation.start(); + /* Here we add all the functions that will be called during the animation cycle. */ + animation.addCallBackFunction("Chart Space", thisObject.chartSpace.draw, onFunctionAdded); + animation.addCallBackFunction("Floating Space", thisObject.floatingSpace.physicsLoop, onFunctionAdded); + animation.addCallBackFunction("Panels Space", thisObject.panelsSpace.draw, onFunctionAdded); + animation.addCallBackFunction("Splash Screen", splashScreen.draw, onFunctionAdded); + animation.addCallBackFunction("ViewPort Animate", viewPort.animate, onFunctionAdded); + animation.addCallBackFunction("ViewPort Draw", viewPort.draw, onFunctionAdded); + animation.start(onStart); + + function onFunctionAdded(err) { + + if (err.result === GLOBAL.CUSTOM_FAIL_RESPONSE.result) { + + animation.stop(); + + if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onAnimationInitialized -> onFunctionAdded -> Animation Stopped since a vital funtion could not be added."); } + + /* Display some Error Page here. */ + } + } + + function onStart(err) { + + switch (err.result) { + case GLOBAL.DEFAULT_OK_RESPONSE.result: { + + if (INFO_LOG === true) { logger.write("[INFO] initialize -> onAnimationInitialized -> onStart -> Received OK Response."); } + callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE); + return; + } + + case GLOBAL.DEFAULT_FAIL_RESPONSE.result: { + + if (INFO_LOG === true) { logger.write("[INFO] initialize -> onAnimationInitialized -> onStart -> Received FAIL Response."); } + callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE); + return; + } + + default: { + + if (INFO_LOG === true) { logger.write("[INFO] initialize -> onAnimationInitialized -> onStart -> Received Unexpected Response."); } + callBackFunction(err); + return; + } + } + } + } } function initializeBrowserCanvas() { @@ -134,14 +177,6 @@ function newCanvas() { viewPort.initialize(); } - function clearBrowserCanvas() { - - if (INFO_LOG === true) { logger.write("[INFO] clearBrowserCanvas -> Entering function."); } - - browserCanvasContext.clearRect(0, 0, browserCanvas.width, browserCanvas.height); - - } - function addCanvasEvents() { if (INFO_LOG === true) { logger.write("[INFO] addCanvasEvents -> Entering function."); }