fez5587/Superalgos
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #16 from AAMasters/develop

Browse Source 
Finalize() function implemented on needed places to avoid bots duplications on competitions.
This commit is contained in:
nikolabjelo authored and GitHub committed 2019-03-02 18:23:22 +01:00
2 parents cbc292415a e8b6952805
commit 9e14bfb021
52 files changed
+8154 -9521
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Animation.js
+91 -121
View File
@@ -1,11 +1,10 @@
function newAnimation() {
const MODULE_NAME = "Animation";
const INFO_LOG = false;
const ERROR_LOG = true;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
function newAnimation () {
const MODULE_NAME = 'Animation'
const INFO_LOG = false
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
/*
@@ -15,157 +14,128 @@ function newAnimation() {
*/
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 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,
removeCallBackFunction: removeCallBackFunction,
initialize: initialize
};
let thisObject = {
start: start,
stop: stop,
addCallBackFunction: addCallBackFunction,
removeCallBackFunction: removeCallBackFunction,
initialize: initialize,
finalize: finalize
}
return thisObject;
return thisObject
function initialize(callBackFunction) {
function finalize () {
try {
if (INFO_LOG === true) { logger.write('[INFO] finalize -> Entering function.') }
try {
thisObject.stop()
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] finalize -> err = ' + err) }
}s
}
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
function initialize (callBackFunction) {
try {
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.DEFAULT_FAIL_RESPONSE);
}
callBackFunction(GLOBAL.CUSTOM_OK_RESPONSE)
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function start (callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] start -> Entering function.') }
function start(callBackFunction) {
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.DEFAULT_FAIL_RESPONSE);
}
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.DEFAULT_FAIL_RESPONSE)
}
}
function stop(callBackFunction) {
function stop (callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] stop -> Entering function.') }
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.DEFAULT_FAIL_RESPONSE);
}
window.cancelAnimationFrame(animationLoopHandle)
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] stop -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function addCallBackFunction(key, callBack, callBackFunction) {
function addCallBackFunction (key, callBack, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] addCallBackFunction -> Entering function.') }
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.DEFAULT_FAIL_RESPONSE);
}
callBackFunctions.set(key, callBack)
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] addCallBackFunction -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function removeCallBackFunction(key, callBackFunction) {
function removeCallBackFunction (key, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] removeCallBackFunction -> Entering function.') }
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.DEFAULT_FAIL_RESPONSE);
}
callBackFunctions.delete(key)
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] removeCallBackFunction -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function animationLoop() {
try {
if (INFO_LOG === true) { logger.write("[INFO] animationLoop -> Entering function."); }
if (window.canvasApp.visible === true) {
function animationLoop () {
try {
if (INFO_LOG === true) { logger.write('[INFO] animationLoop -> Entering function.') }
if (window.canvasApp.visible === true) {
/* We set the canvas to its normal width and height */
browserCanvas.width = window.innerWidth;
browserCanvas.height = window.innerHeight - window.canvasApp.topMargin;
browserCanvas.width = window.innerWidth
browserCanvas.height = window.innerHeight - window.canvasApp.topMargin
/* First thing is to clear the actual canvas */
clearBrowserCanvas();
clearBrowserCanvas()
/* We loop through the callback functions collections and execute them all. */
callBackFunctions.forEach(function (callBackFunction) {
callBackFunction();
});
} else {
browserCanvas.width = 1;
browserCanvas.height = 1;
}
callBackFunctions.forEach(function (callBackFunction) {
callBackFunction()
})
} else {
browserCanvas.width = 1
browserCanvas.height = 1
}
/* We request the next frame to be drawn, and stablishing a loop */
animationLoopHandle = window.requestAnimationFrame(animationLoop);
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] animationLoop -> err = " + err); }
}
animationLoopHandle = window.requestAnimationFrame(animationLoop)
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] animationLoop -> err = ' + err) }
}
}
function clearBrowserCanvas() {
function clearBrowserCanvas () {
if (INFO_LOG === true) { logger.write('[INFO] clearBrowserCanvas -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] clearBrowserCanvas -> Entering function."); }
browserCanvasContext.beginPath()
browserCanvasContext.beginPath();
browserCanvasContext.rect(0, 0, browserCanvas.width, browserCanvas.height)
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 1)'
browserCanvasContext.rect(0, 0, browserCanvas.width, browserCanvas.height);
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 1)';
browserCanvasContext.closePath();
browserCanvasContext.fill();
}
browserCanvasContext.closePath()
browserCanvasContext.fill()
}
}
BottomSpace/ChartAspectRatio.js
+78 -95
View File
@@ -1,130 +1,113 @@
function newChartAspectRatio() {
function newChartAspectRatio () {
let thisObject = {
aspectRatio: undefined,
draw: draw,
getContainer: getContainer,
initialize: initialize
}
let thisObject = {
aspectRatio: undefined,
draw: draw,
getContainer: getContainer,
initialize: initialize
};
let container = newContainer()
container.initialize()
thisObject.container = container
let container = newContainer();
container.initialize();
thisObject.container = container;
thisObject.container.frame.width = 50
thisObject.container.frame.height = BOTTOM_SPACE_HEIGHT
thisObject.container.frame.width = 50;
thisObject.container.frame.height = BOTTOM_SPACE_HEIGHT;
resize()
resize();
container.isDraggeable = false
container.isClickeable = false
container.isWheeleable = true
container.isDraggeable = false;
container.isClickeable = false;
container.isWheeleable = true;
thisObject.aspectRatio = {}
thisObject.aspectRatio = {};
const INITIAL_Y_ASPECT_RATIO = 5 / 10
const MIN_Y_ASPECT_RATIO = 1 / 10
const MAX_Y_ASPECT_RATIO = 10 / 10
const INITIAL_Y_ASPECT_RATIO = 5 / 10;
const MIN_Y_ASPECT_RATIO = 1 / 10;
const MAX_Y_ASPECT_RATIO = 10 / 10;
thisObject.aspectRatio.x = 1
thisObject.aspectRatio.y = INITIAL_Y_ASPECT_RATIO
thisObject.aspectRatio.x = 1;
thisObject.aspectRatio.y = INITIAL_Y_ASPECT_RATIO;
canDrawIcon = false
canDrawIcon = false;
return thisObject
return thisObject;
function initialize () {
icon = new Image()
function initialize() {
icon.onload = onImageLoad
icon = new Image();
function onImageLoad () {
canDrawIcon = true
}
icon.onload = onImageLoad;
icon.src = window.canvasApp.urlPrefix + 'Images/Icons/chart-scale.png'
function onImageLoad() {
canDrawIcon = true;
}
thisObject.container.eventHandler.listenToEvent('Mouse Wheel', onMouseWheel)
icon.src = window.canvasApp.urlPrefix + "Images/Icons/chart-scale.png";
window.canvasApp.eventHandler.listenToEvent('Browser Resized', resize)
}
thisObject.container.eventHandler.listenToEvent('Mouse Wheel', onMouseWheel);
function resize () {
container.frame.position.x = viewPort.visibleArea.topRight.x - thisObject.container.frame.width
container.frame.position.y = viewPort.visibleArea.bottomLeft.y
}
window.canvasApp.eventHandler.listenToEvent("Browser Resized", resize);
function onMouseWheel (pDelta) {
if (viewPort.isMinZoom() === false) { return } // We only make this button to work at the min zoom level.
}
if (pDelta < 0) {
pDelta = -0.1
} else {
pDelta = 0.1
}
function resize() {
thisObject.aspectRatio.y = thisObject.aspectRatio.y + pDelta
thisObject.aspectRatio.y = Math.round(thisObject.aspectRatio.y * 100) / 100
container.frame.position.x = viewPort.visibleArea.topRight.x - thisObject.container.frame.width;
container.frame.position.y = viewPort.visibleArea.bottomLeft.y;
if (thisObject.aspectRatio.y < MIN_Y_ASPECT_RATIO) {
thisObject.aspectRatio.y = MIN_Y_ASPECT_RATIO
}
}
if (thisObject.aspectRatio.y > MAX_Y_ASPECT_RATIO) {
thisObject.aspectRatio.y = MAX_Y_ASPECT_RATIO
}
function onMouseWheel(pDelta) {
thisObject.container.eventHandler.raiseEvent('Chart Aspect Ratio Changed', thisObject.aspectRatio)
}
if (viewPort.isMinZoom() === false) { return; } // We only make this button to work at the min zoom level.
if (pDelta < 0) {
pDelta = -0.1;
} else {
pDelta = 0.1;
}
thisObject.aspectRatio.y = thisObject.aspectRatio.y + pDelta;
thisObject.aspectRatio.y = Math.round(thisObject.aspectRatio.y * 100) / 100;
if (thisObject.aspectRatio.y < MIN_Y_ASPECT_RATIO) {
thisObject.aspectRatio.y = MIN_Y_ASPECT_RATIO;
}
if (thisObject.aspectRatio.y > MAX_Y_ASPECT_RATIO) {
thisObject.aspectRatio.y = MAX_Y_ASPECT_RATIO;
}
thisObject.container.eventHandler.raiseEvent("Chart Aspect Ratio Changed", thisObject.aspectRatio);
}
function getContainer(point) {
let container;
function getContainer (point) {
let container
/* First we check if this point is inside this object UI. */
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container;
} else {
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container
} else {
/* This point does not belong to this space. */
return undefined;
}
}
return undefined
}
}
function draw() {
function draw () {
thisObject.container.frame.draw(false, false)
thisObject.container.frame.draw(false, false);
if (canDrawIcon === false) { return }
if (viewPort.isMinZoom() === false) { return } // We only show this button at the min zoom level.
if (canDrawIcon === false) { return; }
if (viewPort.isMinZoom() === false) { return; } // We only show this button at the min zoom level.
let breakpointsHeight = 15
let breakpointsHeight = 15;
let imageHeight = 15
let imageWidth = 15
let imageHeight = 15;
let imageWidth = 15;
let imagePoint = {
x: 10,
y: thisObject.container.frame.height / 2 - imageHeight / 2 + breakpointsHeight
}
let imagePoint = {
x: 10,
y: thisObject.container.frame.height / 2 - imageHeight / 2 + breakpointsHeight
};
imagePoint = thisObject.container.frame.frameThisPoint(imagePoint)
imagePoint = thisObject.container.frame.frameThisPoint(imagePoint);
browserCanvasContext.drawImage(icon, imagePoint.x, imagePoint.y, imageWidth, imageHeight);
}
}
browserCanvasContext.drawImage(icon, imagePoint.x, imagePoint.y, imageWidth, imageHeight)
}
}
BottomSpace/DeleteTradingHistory.js
+177 -230
View File
@@ -1,86 +1,75 @@
function newDeleteTradingHistory() {

function newDeleteTradingHistory () {
const MODULE_NAME = 'Delete Trading History'
const INFO_LOG = false
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
const MODULE_NAME = "Delete Trading History";
const INFO_LOG = false;
const ERROR_LOG = true;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
var thisObject = {
container: undefined,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
}
var thisObject = {
container: undefined,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
};
var container = newContainer()
container.initialize()
thisObject.container = container
var container = newContainer();
container.initialize();
thisObject.container = container;
thisObject.container.frame.width = 50
thisObject.container.frame.height = BOTTOM_SPACE_HEIGHT
thisObject.container.frame.width = 50;
thisObject.container.frame.height = BOTTOM_SPACE_HEIGHT;
resize()
resize();
container.isDraggeable = false
container.isClickeable = true
container.isDraggeable = false;
container.isClickeable = true;
let icon
let canDrawIcon = false
let icon;
let canDrawIcon = false;
return thisObject
return thisObject;
function initialize (callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
function initialize(callBackFunction) {
icon = new Image()
try {
icon.onload = onImageLoad
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
function onImageLoad () {
canDrawIcon = true
}
icon = new Image();
icon.src = window.canvasApp.urlPrefix + 'Images/Icons/trash.png'
icon.onload = onImageLoad;
thisObject.container.eventHandler.listenToEvent('onMouseClick', onClick)
function onImageLoad() {
canDrawIcon = true;
}
icon.src = window.canvasApp.urlPrefix + "Images/Icons/trash.png";
thisObject.container.eventHandler.listenToEvent("onMouseClick", onClick);
window.canvasApp.eventHandler.listenToEvent("Browser Resized", resize);
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE); }
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err.message = " + err.message); }
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE); }
}
window.canvasApp.eventHandler.listenToEvent('Browser Resized', resize)
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE) }
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> err.message = ' + err.message) }
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE) }
}
}
function resize() {
function resize () {
container.frame.position.x = viewPort.visibleArea.topRight.x
container.frame.position.y = viewPort.visibleArea.bottomLeft.y
}
container.frame.position.x = viewPort.visibleArea.topRight.x;
container.frame.position.y = viewPort.visibleArea.bottomLeft.y;
function onClick () {
try {
if (INFO_LOG === true) { logger.write('[INFO] onClick -> Entering function.') }
}
let sessionToken = window.localStorage.getItem('sessionToken')
function onClick() {
try {
if (INFO_LOG === true) { logger.write("[INFO] onClick -> Entering function."); }
let sessionToken = window.localStorage.getItem('sessionToken');
if (sessionToken === null || sessionToken === "") {
if (sessionToken === null || sessionToken === '') {
/* not logged in */
return;
}
return
}
/*
@@ -94,243 +83,201 @@ function newDeleteTradingHistory() {
6. Delete every execution context file found.
7. Delete the execution history file after finishing the interation.
8. Delete the Sequence file belonging to the received Start Mode.
9. Save the Status Report without the records of this Start Mode.
9. Save the Status Report without the records of this Start Mode.
*/
let storage = AzureStorage.Blob;
let storage = AzureStorage.Blob
let readOnlyBlobService;
let writeOnlyBlobService;
let deleteOnlyBlobService;
let readOnlyBlobService
let writeOnlyBlobService
let deleteOnlyBlobService
let readConnectionString = window.USER_PROFILE.storagePermissions.get(window.DEV_TEAM + "." + "READ");
let readConnectionString = window.USER_PROFILE.storagePermissions.get(window.DEV_TEAM + '.' + 'READ')
if (readConnectionString !== undefined) {
readOnlyBlobService = storage.createBlobService(readConnectionString);
}
if (readConnectionString !== undefined) {
readOnlyBlobService = storage.createBlobService(readConnectionString)
}
let writeConnectionString = window.USER_PROFILE.storagePermissions.get(window.DEV_TEAM + "." + "WRITE");
let writeConnectionString = window.USER_PROFILE.storagePermissions.get(window.DEV_TEAM + '.' + 'WRITE')
if (writeConnectionString !== undefined) {
writeOnlyBlobService = storage.createBlobService(writeConnectionString);
}
if (writeConnectionString !== undefined) {
writeOnlyBlobService = storage.createBlobService(writeConnectionString)
}
let deleteConnectionString = window.USER_PROFILE.storagePermissions.get(window.DEV_TEAM + "." + "DELETE");
let deleteConnectionString = window.USER_PROFILE.storagePermissions.get(window.DEV_TEAM + '.' + 'DELETE')
if (deleteConnectionString !== undefined) {
deleteOnlyBlobService = storage.createBlobService(deleteConnectionString);
}
if (deleteConnectionString !== undefined) {
deleteOnlyBlobService = storage.createBlobService(deleteConnectionString)
}
let containerName = window.DEV_TEAM.toLowerCase();
let containerName = window.DEV_TEAM.toLowerCase()
let statusReportFilePath = window.DEV_TEAM + "/" + window.CURRENT_BOT_CODE_NAME + ".1.0" + "/" + "AACloud.1.1" + "/" + "Poloniex" + "/" + "dataSet.V1" + "/" + "Reports" + "/" + "Trading-Process";
let statusReportFileName = window.CURRENT_START_MODE + "." + "Status.Report.USDT_BTC.json";
let statusReportFilePath = window.DEV_TEAM + '/' + window.CURRENT_BOT_CODE_NAME + '.1.0' + '/' + 'AACloud.1.1' + '/' + 'Poloniex' + '/' + 'dataSet.V1' + '/' + 'Reports' + '/' + 'Trading-Process'
let statusReportFileName = window.CURRENT_START_MODE + '.' + 'Status.Report.USDT_BTC.json'
readOnlyBlobService.getBlobToText(containerName, statusReportFilePath + "/" + statusReportFileName, onStatusReport);
readOnlyBlobService.getBlobToText(containerName, statusReportFilePath + '/' + statusReportFileName, onStatusReport)
function onStatusReport(err, text, response) {
function onStatusReport (err, text, response) {
try {
if (INFO_LOG === true) { logger.write('[INFO] onClick -> onStatusReport -> Entering function.') }
try {
if (err && err.code === 'BlobNotFound') {
console.log(statusReportFilePath + '/' + statusReportFileName + ' not found. No history detected for this start mode.')
return
}
if (INFO_LOG === true) { logger.write("[INFO] onClick -> onStatusReport -> Entering function."); }
let statusReport = JSON.parse(text)
if (err && err.code === 'BlobNotFound') {
console.log(statusReportFilePath + "/" + statusReportFileName + " not found. No history detected for this start mode.");
return;
}
let statusReport = JSON.parse(text);
let toBeDeleted = 0;
let deleted = 0;
for (let i = 0; i < statusReport.runs.length; i++) {
let toBeDeleted = 0
let deleted = 0
for (let i = 0; i < statusReport.runs.length; i++) {
/* For each record, we will get the execution history file. */
let filePath = window.DEV_TEAM + "/" + window.CURRENT_BOT_CODE_NAME + ".1.0" + "/" + "AACloud.1.1" + "/" + "Poloniex" + "/" + "dataSet.V1" + "/" + "Output" + "/" + "Trading-Process";
let fileName = "Execution.History." + window.CURRENT_START_MODE + "." + i + ".json";
let filePath = window.DEV_TEAM + '/' + window.CURRENT_BOT_CODE_NAME + '.1.0' + '/' + 'AACloud.1.1' + '/' + 'Poloniex' + '/' + 'dataSet.V1' + '/' + 'Output' + '/' + 'Trading-Process'
let fileName = 'Execution.History.' + window.CURRENT_START_MODE + '.' + i + '.json'
readOnlyBlobService.getBlobToText(containerName, filePath + "/" + fileName, onExecutionHistory);
readOnlyBlobService.getBlobToText(containerName, filePath + '/' + fileName, onExecutionHistory)
function onExecutionHistory(err, text, response) {
function onExecutionHistory (err, text, response) {
let executionHistory = JSON.parse(text)
let executionHistory = JSON.parse(text);
for (let j = 0; j < executionHistory.length; j++) {
let dateTime = new Date(executionHistory[j][0])
for (let j = 0; j < executionHistory.length; j++) {
let datePath = dateTime.getUTCFullYear() + '/' + pad(dateTime.getUTCMonth() + 1, 2) + '/' + pad(dateTime.getUTCDate(), 2) + '/' + pad(dateTime.getUTCHours(), 2) + '/' + pad(dateTime.getUTCMinutes(), 2)
let dateTime = new Date(executionHistory[j][0]);
let filePath = window.DEV_TEAM + '/' + window.CURRENT_BOT_CODE_NAME + '.1.0' + '/' + 'AACloud.1.1' + '/' + 'Poloniex' + '/' + 'dataSet.V1' + '/' + 'Output' + '/' + 'Trading-Process' + '/' + datePath
let fileName = 'Execution.Context.' + window.CURRENT_START_MODE + '.' + i + '.json'
let datePath = dateTime.getUTCFullYear() + "/" + pad(dateTime.getUTCMonth() + 1, 2) + "/" + pad(dateTime.getUTCDate(), 2) + "/" + pad(dateTime.getUTCHours(), 2) + "/" + pad(dateTime.getUTCMinutes(), 2);
deleteOnlyBlobService.deleteBlob(containerName, filePath + '/' + fileName, onDeleted)
let filePath = window.DEV_TEAM + "/" + window.CURRENT_BOT_CODE_NAME + ".1.0" + "/" + "AACloud.1.1" + "/" + "Poloniex" + "/" + "dataSet.V1" + "/" + "Output" + "/" + "Trading-Process" + "/" + datePath;
let fileName = "Execution.Context." + window.CURRENT_START_MODE + "." + i + ".json";
toBeDeleted++
deleteOnlyBlobService.deleteBlob(containerName, filePath + "/" + fileName, onDeleted);
function onDeleted (err, text, response) {
if (err) {
toBeDeleted++;
console.log(filePath + '/' + fileName + ' NOT deleted.')
console.log('err.message = ' + err.message)
} else {
function onDeleted(err, text, response) {
console.log(filePath + '/' + fileName + ' deleted.')
}
if (err) {
deleted++
console.log(filePath + "/" + fileName + " NOT deleted.");
console.log("err.message = " + err.message);
} else {
if (toBeDeleted === deleted) {
console.log(filePath + "/" + fileName + " deleted.");
}
deleted++;
if (toBeDeleted === deleted) {
updateStatusReport();
}
}
}
updateStatusReport()
}
}
}
/* Now we delete the execution history file. */
deleteOnlyBlobService.deleteBlob(containerName, filePath + "/" + fileName, onExecutionHistoryDeleted);
deleteOnlyBlobService.deleteBlob(containerName, filePath + '/' + fileName, onExecutionHistoryDeleted)
function onExecutionHistoryDeleted(err, text, response) {
function onExecutionHistoryDeleted (err, text, response) {
console.log(filePath + '/' + fileName + ' deleted.')
}
}
}
console.log(filePath + "/" + fileName + " deleted.");
function updateStatusReport () {
try {
if (INFO_LOG === true) { logger.write('[INFO] onClick -> onStatusReport -> updateStatusReport -> Entering function.') }
}
}
}
function updateStatusReport() {
try {
if (INFO_LOG === true) { logger.write("[INFO] onClick -> onStatusReport -> updateStatusReport -> Entering function."); }
statusReport.runs = [];
statusReport.runs = []
/* Here is where we update the current Status Report file with the new version without records for the current Start Mode. */
let fileContent = JSON.stringify(statusReport);
let fileContent = JSON.stringify(statusReport)
writeOnlyBlobService.createBlockBlobFromText(containerName, statusReportFilePath + "/" + statusReportFileName, fileContent, onStatusReportUpdated);
writeOnlyBlobService.createBlockBlobFromText(containerName, statusReportFilePath + '/' + statusReportFileName, fileContent, onStatusReportUpdated)
function onStatusReportUpdated(err, text, response) {
console.log(statusReportFilePath + "/" + statusReportFileName + " updated.");
}
function onStatusReportUpdated (err, text, response) {
console.log(statusReportFilePath + '/' + statusReportFileName + ' updated.')
}
/* Finally we delete the sequence file. */
let filePath = window.DEV_TEAM + "/" + window.CURRENT_BOT_CODE_NAME + ".1.0" + "/" + "AACloud.1.1" + "/" + "Poloniex" + "/" + "dataSet.V1" + "/" + "Output" + "/" + "Trading-Process";
let fileName = "Execution.History." + window.CURRENT_START_MODE + "." + "Sequence" + ".json";
let filePath = window.DEV_TEAM + '/' + window.CURRENT_BOT_CODE_NAME + '.1.0' + '/' + 'AACloud.1.1' + '/' + 'Poloniex' + '/' + 'dataSet.V1' + '/' + 'Output' + '/' + 'Trading-Process'
let fileName = 'Execution.History.' + window.CURRENT_START_MODE + '.' + 'Sequence' + '.json'
deleteOnlyBlobService.deleteBlob(containerName, filePath + "/" + fileName, onDeleted);
deleteOnlyBlobService.deleteBlob(containerName, filePath + '/' + fileName, onDeleted)
function onDeleted(err, text, response) {
console.log(filePath + "/" + fileName + " deleted.");
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] onClick -> onStatusReport -> updateStatusReport -> err.message = " + err.message); }
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] onClick -> onStatusReport -> err.message = " + err.message); }
}
function onDeleted (err, text, response) {
console.log(filePath + '/' + fileName + ' deleted.')
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] onClick -> onStatusReport -> updateStatusReport -> err.message = ' + err.message) }
}
function pad(str, max) {
str = str.toString();
return str.length < max ? pad("0" + str, max) : str;
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] onClick -> err.message = " + err.message); }
if (ERROR_LOG === true) { logger.write('[ERROR] onClick -> onStatusReport -> err.message = ' + err.message) }
}
}
function pad (str, max) {
str = str.toString()
return str.length < max ? pad('0' + str, max) : str
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] onClick -> err.message = ' + err.message) }
}
}
function getContainer(point) {
function getContainer (point) {
try {
if (INFO_LOG === true) { logger.write('[INFO] getContainer -> Entering function.') }
try {
if (INFO_LOG === true) { logger.write("[INFO] getContainer -> Entering function."); }
let container;
let container
/* First we check if this point is inside this object UI. */
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container;
} else {
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container
} else {
/* This point does not belong to this space. */
return undefined;
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] getContainer -> err.message = " + err.message); }
}
return undefined
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] getContainer -> err.message = ' + err.message) }
}
}
function draw() {
function draw () {
try {
if (INFO_LOG === true) { logger.write('[INFO] draw -> Entering function.') }
try {
let sessionToken = window.localStorage.getItem('sessionToken')
if (INFO_LOG === true) { logger.write("[INFO] draw -> Entering function."); }
let sessionToken = window.localStorage.getItem('sessionToken');
if (sessionToken === null || sessionToken === "") {
if (sessionToken === null || sessionToken === '') {
/* not logged in */
return;
}
return
}
thisObject.container.frame.draw(false, false);
thisObject.container.frame.draw(false, false)
if (canDrawIcon === false) { return; }
if (canDrawIcon === false) { return }
let breakpointsHeight = 14;
let breakpointsHeight = 14
let imageHeight = 15;
let imageWidth = 15;
let imageHeight = 15
let imageWidth = 15
let imagePoint = {
x: 10,
y: thisObject.container.frame.height / 2 - imageHeight / 2 + breakpointsHeight
};
let imagePoint = {
x: 10,
y: thisObject.container.frame.height / 2 - imageHeight / 2 + breakpointsHeight
}
imagePoint = thisObject.container.frame.frameThisPoint(imagePoint);
imagePoint = thisObject.container.frame.frameThisPoint(imagePoint)
browserCanvasContext.drawImage(icon, imagePoint.x, imagePoint.y, imageWidth, imageHeight);
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] draw -> err.message = " + err.message); }
}
browserCanvasContext.drawImage(icon, imagePoint.x, imagePoint.y, imageWidth, imageHeight)
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] draw -> err.message = ' + err.message) }
}
}
}
}
BreakpointsBar.js
+131 -155
View File
@@ -1,219 +1,195 @@
function newBreakpointsBar() {
var thisObject = {
setDatetime: setDatetime,
container: undefined,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
};
function newBreakpointsBar () {
var thisObject = {
setDatetime: setDatetime,
container: undefined,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
}
var container = newContainer();
container.initialize();
thisObject.container = container;
var container = newContainer()
container.initialize()
thisObject.container = container
thisObject.container.frame.width = browserCanvasContext.width;
thisObject.container.frame.height = 15;
thisObject.container.frame.width = browserCanvasContext.width
thisObject.container.frame.height = 15
container.frame.position.x = 0;
container.frame.position.y = viewPort.visibleArea.bottomRight.y;
container.frame.position.x = 0
container.frame.position.y = viewPort.visibleArea.bottomRight.y
container.isDraggeable = false;
container.isClickeable = true;
container.isDraggeable = false
container.isClickeable = true
let logo;
let canDrawLogo = false;
let logo
let canDrawLogo = false
let datetime;
let timePeriod;
let timeLineCoordinateSystem;
let chartContainer;
let datetime
let timePeriod
let timeLineCoordinateSystem
let chartContainer
let breakpointsByTimePeriod = new Map();
let breakpointsByTimePeriod = new Map()
return thisObject;
return thisObject
function initialize(pChartContainer, pTimeLineCoordinateSystem) {
function initialize (pChartContainer, pTimeLineCoordinateSystem) {
timeLineCoordinateSystem = pTimeLineCoordinateSystem
chartContainer = pChartContainer
timeLineCoordinateSystem = pTimeLineCoordinateSystem;
chartContainer = pChartContainer;
viewPort.eventHandler.listenToEvent('Zoom Changed', onZoomChanged)
timePeriod = INITIAL_TIME_PERIOD
viewPort.eventHandler.listenToEvent("Zoom Changed", onZoomChanged);
timePeriod = INITIAL_TIME_PERIOD;
thisObject.container.eventHandler.listenToEvent('onMouseClick', onClick)
thisObject.container.eventHandler.listenToEvent("onMouseClick", onClick);
for (let i = 0; i < marketFilesPeriods.length; i++) {
let breakpointsMap = new Map();
breakpointsByTimePeriod.set(marketFilesPeriods[i][0], breakpointsMap);
}
for (let i = 0; i < dailyFilePeriods.length; i++) {
let breakpointsMap = new Map();
breakpointsByTimePeriod.set(dailyFilePeriods[i][0], breakpointsMap);
}
for (let i = 0; i < marketFilesPeriods.length; i++) {
let breakpointsMap = new Map()
breakpointsByTimePeriod.set(marketFilesPeriods[i][0], breakpointsMap)
}
function onClick(pPoint) {
for (let i = 0; i < dailyFilePeriods.length; i++) {
let breakpointsMap = new Map()
breakpointsByTimePeriod.set(dailyFilePeriods[i][0], breakpointsMap)
}
}
let point = {
x: pPoint.x,
y: pPoint.y
};
function onClick (pPoint) {
let point = {
x: pPoint.x,
y: pPoint.y
}
let miliSeconds = getMilisecondsFromPoint(point, chartContainer, timeLineCoordinateSystem);
let miliSeconds = getMilisecondsFromPoint(point, chartContainer, timeLineCoordinateSystem)
miliSeconds = normalizeX(miliSeconds); // We are now exactly at the middle of the "candle" correspondind to the point clicked.
miliSeconds = normalizeX(miliSeconds) // We are now exactly at the middle of the "candle" correspondind to the point clicked.
let breakpointsMap = breakpointsByTimePeriod.get(timePeriod);
let breakpoint = breakpointsMap.get(miliSeconds);
if (breakpoint === undefined) {
let breakpointsMap = breakpointsByTimePeriod.get(timePeriod)
let breakpoint = breakpointsMap.get(miliSeconds)
if (breakpoint === undefined) {
/* The breakpoint didnt exist, then we create one. */
breakpointsMap.set(miliSeconds, 1);
} else {
breakpointsMap.set(miliSeconds, 1)
} else {
/* The breakpoint existed, so we remove it. */
breakpointsMap.set(miliSeconds, undefined);
}
breakpointsMap.set(miliSeconds, undefined)
}
}
function normalizeX(pX) {
function normalizeX (pX) {
return Math.trunc(pX / timePeriod) * timePeriod + timePeriod / 2
}
return Math.trunc(pX / timePeriod) * timePeriod + timePeriod / 2;
function onZoomChanged (event) {
timePeriod = recalculatePeriod(event.newLevel)
}
}
function setDatetime (pDatetime) {
datetime = new Date(pDatetime)
}
function onZoomChanged(event) {
timePeriod = recalculatePeriod(event.newLevel);
}
function setDatetime(pDatetime) {
datetime = new Date(pDatetime);
}
function getContainer(point) {
let container;
function getContainer (point) {
let container
/* First we check if this point is inside this object UI. */
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container;
} else {
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container
} else {
/* This point does not belong to this space. */
return undefined;
}
return undefined
}
}
function draw() {
function draw () {
/*
To draw the breakpoints, we will calculate the miliseconds for the first x pixel of the breakpoint bar, and for the last x pixel. Once we have that
we can create an array with all the possible points for breack points. Finally we can see if brealpoints exists at those points. We plot only the ones
that exists.
*/
let breakpointsMap = breakpointsByTimePeriod.get(timePeriod);
let breakpointsMap = breakpointsByTimePeriod.get(timePeriod)
let beginX = {
x: viewPort.visibleArea.bottomLeft.x,
y: 0
};
let beginX = {
x: viewPort.visibleArea.bottomLeft.x,
y: 0
}
let endX = {
x: viewPort.visibleArea.bottomRight.x,
y: 0
};
let endX = {
x: viewPort.visibleArea.bottomRight.x,
y: 0
}
let beginMiliseconds = getMilisecondsFromPoint(beginX, chartContainer, timeLineCoordinateSystem);
let endMiliseconds = getMilisecondsFromPoint(endX, chartContainer, timeLineCoordinateSystem);
let beginMiliseconds = getMilisecondsFromPoint(beginX, chartContainer, timeLineCoordinateSystem)
let endMiliseconds = getMilisecondsFromPoint(endX, chartContainer, timeLineCoordinateSystem)
beginMiliseconds = normalizeX(beginMiliseconds);
endMiliseconds = normalizeX(endMiliseconds);
beginMiliseconds = normalizeX(beginMiliseconds)
endMiliseconds = normalizeX(endMiliseconds)
window.AT_BREAKPOINT = false;
window.AT_BREAKPOINT = false
for (let miliSeconds = beginMiliseconds; miliSeconds < endMiliseconds; miliSeconds = miliSeconds + timePeriod) {
for (let miliSeconds = beginMiliseconds; miliSeconds < endMiliseconds; miliSeconds = miliSeconds + timePeriod) {
let breakpoint = breakpointsMap.get(miliSeconds)
let breakpoint = breakpointsMap.get(miliSeconds);
if (breakpoint !== undefined) {
let point1 = {
x: miliSeconds,
y: 0
}
if (breakpoint !== undefined) {
point1 = timeLineCoordinateSystem.transformThisPoint(point1)
point1 = transformThisPoint(point1, chartContainer)
let point1 = {
x: miliSeconds,
y: 0
}
let point2 = {
x: miliSeconds,
y: thisObject.container.frame.height / 2 + 1
}
point1 = timeLineCoordinateSystem.transformThisPoint(point1);
point1 = transformThisPoint(point1, chartContainer);
point2 = thisObject.container.frame.frameThisPoint(point2)
let point2 = {
x: miliSeconds,
y: thisObject.container.frame.height / 2 + 1
}
let point = {
x: point1.x,
y: point2.y
}
point2 = thisObject.container.frame.frameThisPoint(point2);
let isCurrentRecord = false
let point = {
x: point1.x,
y: point2.y
}
if (datetime !== undefined) {
let dateValue = datetime.valueOf()
if (dateValue >= miliSeconds - timePeriod / 2 && dateValue <= miliSeconds + timePeriod / 2 - 1) {
isCurrentRecord = true
}
}
let isCurrentRecord = false;
let radius = 5
if (datetime !== undefined) {
let dateValue = datetime.valueOf();
if (dateValue >= miliSeconds - timePeriod / 2 && dateValue <= miliSeconds + timePeriod / 2 - 1) {
isCurrentRecord = true;
}
}
let opacity = '0.5'
let radius = 5;
let opacity = '0.5';
browserCanvasContext.lineWidth = 1;
browserCanvasContext.lineWidth = 1
/* Outer Circle */
browserCanvasContext.beginPath();
browserCanvasContext.beginPath()
browserCanvasContext.strokeStyle = 'rgba(123, 50, 40, ' + opacity + ')';
browserCanvasContext.strokeStyle = 'rgba(123, 50, 40, ' + opacity + ')'
if (isCurrentRecord === false) {
browserCanvasContext.fillStyle = 'rgba(223, 70, 60, ' + opacity + ')';
} else {
browserCanvasContext.fillStyle = 'rgba(255, 233, 31, ' + opacity + ')'; /* highlight the current record */
if (isCurrentRecord === false) {
browserCanvasContext.fillStyle = 'rgba(223, 70, 60, ' + opacity + ')'
} else {
browserCanvasContext.fillStyle = 'rgba(255, 233, 31, ' + opacity + ')' /* highlight the current record */
window.AT_BREAKPOINT = true; // We are hitting a breakpoint!
}
browserCanvasContext.arc(point.x, point.y, radius, 0, Math.PI * 2, true);
browserCanvasContext.closePath();
if (point.x < viewPort.visibleArea.topLeft.x + 50 || point.x > viewPort.visibleArea.bottomRight.x - 50) {/*we leave this history without fill. */ } else {
browserCanvasContext.fill();
}
browserCanvasContext.stroke();
}
window.AT_BREAKPOINT = true // We are hitting a breakpoint!
}
browserCanvasContext.arc(point.x, point.y, radius, 0, Math.PI * 2, true)
browserCanvasContext.closePath()
if (point.x < viewPort.visibleArea.topLeft.x + 50 || point.x > viewPort.visibleArea.bottomRight.x - 50) { /* we leave this history without fill. */ } else {
browserCanvasContext.fill()
}
browserCanvasContext.stroke()
}
}
}
}
}
Candle.js
+14 -16
View File
@@ -1,17 +1,15 @@
function newCandle() {
function newCandle () {
var candle = {
open: undefined,
close: undefined,
min: 10000000000000,
max: 0,
begin: undefined,
end: undefined,
direction: undefined,
beginId: undefined,
endId: undefined
}
var candle = {
open: undefined,
close: undefined,
min: 10000000000000,
max: 0,
begin: undefined,
end: undefined,
direction: undefined,
beginId: undefined,
endId: undefined
};
return candle;
}
return candle
}
Canvas.js
+456 -538
View File
File diff suppressed because it is too large. Load diff
ChartUtilities.js
+105 -113
View File
@@ -1,150 +1,142 @@
function getSideDays(timePeriod) {
function getSideDays (timePeriod) {
let daysOnSides
let daysOnSides;
if (timePeriod < _1_HOUR_IN_MILISECONDS) {
daysOnSides = 1
}
if (timePeriod < _1_HOUR_IN_MILISECONDS) {
daysOnSides = 1;
}
if (timePeriod === _1_HOUR_IN_MILISECONDS) {
daysOnSides = 9
}
if (timePeriod === _1_HOUR_IN_MILISECONDS) {
daysOnSides = 9;
}
if (timePeriod === _2_HOURS_IN_MILISECONDS) {
daysOnSides = 10
}
if (timePeriod === _2_HOURS_IN_MILISECONDS) {
daysOnSides = 10;
}
if (timePeriod === _3_HOURS_IN_MILISECONDS) {
daysOnSides = 12
}
if (timePeriod === _3_HOURS_IN_MILISECONDS) {
daysOnSides = 12;
}
if (timePeriod === _4_HOURS_IN_MILISECONDS) {
daysOnSides = 20
}
if (timePeriod === _4_HOURS_IN_MILISECONDS) {
daysOnSides = 20;
}
if (timePeriod === _6_HOURS_IN_MILISECONDS) {
daysOnSides = 35
}
if (timePeriod === _6_HOURS_IN_MILISECONDS) {
daysOnSides = 35;
}
if (timePeriod === _8_HOURS_IN_MILISECONDS) {
daysOnSides = 44
}
if (timePeriod === _8_HOURS_IN_MILISECONDS) {
daysOnSides = 44;
}
if (timePeriod === _12_HOURS_IN_MILISECONDS) {
daysOnSides = 56
}
if (timePeriod === _12_HOURS_IN_MILISECONDS) {
daysOnSides = 56;
}
if (timePeriod === ONE_DAY_IN_MILISECONDS) {
daysOnSides = 154
}
if (timePeriod === ONE_DAY_IN_MILISECONDS) {
daysOnSides = 154;
}
return daysOnSides;
return daysOnSides
}
function getCondenseFactor(timePeriod) {
switch (timePeriod) {
case _1_MINUTE_IN_MILISECONDS: return 1;
case _5_MINUTES_IN_MILISECONDS: return 5;
case _10_MINUTES_IN_MILISECONDS: return 10;
case _30_MINUTES_IN_MILISECONDS: return 50;
case _1_HOUR_IN_MILISECONDS: return 100;
}
function getCondenseFactor (timePeriod) {
switch (timePeriod) {
case _1_MINUTE_IN_MILISECONDS: return 1
case _5_MINUTES_IN_MILISECONDS: return 5
case _10_MINUTES_IN_MILISECONDS: return 10
case _30_MINUTES_IN_MILISECONDS: return 50
case _1_HOUR_IN_MILISECONDS: return 100
}
}
function getTransparenceFactor(timePeriod) {
switch (timePeriod) {
case _1_MINUTE_IN_MILISECONDS: return "0.12";
case _5_MINUTES_IN_MILISECONDS: return "0.10";
case _10_MINUTES_IN_MILISECONDS: return "0.08";
case _30_MINUTES_IN_MILISECONDS: return "0.06";
case _1_HOUR_IN_MILISECONDS: return "0.04";
}
function getTransparenceFactor (timePeriod) {
switch (timePeriod) {
case _1_MINUTE_IN_MILISECONDS: return '0.12'
case _5_MINUTES_IN_MILISECONDS: return '0.10'
case _10_MINUTES_IN_MILISECONDS: return '0.08'
case _30_MINUTES_IN_MILISECONDS: return '0.06'
case _1_HOUR_IN_MILISECONDS: return '0.04'
}
}
function recalculatePeriod (zoomLevel) {
// console.log(" recalculatePeriod > " + zoomLevel);
function recalculatePeriod(zoomLevel) {
if (zoomLevel > 200) {
return _1_MINUTE_IN_MILISECONDS
}
//console.log(" recalculatePeriod > " + zoomLevel);
if (zoomLevel > 120) {
return _2_MINUTES_IN_MILISECONDS
}
if (zoomLevel > 200) {
return _1_MINUTE_IN_MILISECONDS;
}
if (zoomLevel > 80) {
return _3_MINUTES_IN_MILISECONDS
}
if (zoomLevel > 120) {
return _2_MINUTES_IN_MILISECONDS;
}
if (zoomLevel > 60) {
return _4_MINUTES_IN_MILISECONDS
}
if (zoomLevel > 80) {
return _3_MINUTES_IN_MILISECONDS;
}
if (zoomLevel > 15) {
return _5_MINUTES_IN_MILISECONDS
}
if (zoomLevel > 60) {
return _4_MINUTES_IN_MILISECONDS;
}
if (zoomLevel > -7) {
return _10_MINUTES_IN_MILISECONDS
}
if (zoomLevel > 15) {
return _5_MINUTES_IN_MILISECONDS;
}
if (zoomLevel > -10) {
return _15_MINUTES_IN_MILISECONDS
}
if (zoomLevel > - 7) {
return _10_MINUTES_IN_MILISECONDS;
}
if (zoomLevel > -13) {
return _20_MINUTES_IN_MILISECONDS
}
if (zoomLevel > - 10) {
return _15_MINUTES_IN_MILISECONDS;
}
if (zoomLevel > -15) {
return _30_MINUTES_IN_MILISECONDS
}
if (zoomLevel > - 13) {
return _20_MINUTES_IN_MILISECONDS;
}
if (zoomLevel > -16) {
return _40_MINUTES_IN_MILISECONDS
}
if (zoomLevel > - 15) {
return _30_MINUTES_IN_MILISECONDS;
}
if (zoomLevel > -17) {
return _45_MINUTES_IN_MILISECONDS
}
if (zoomLevel > - 16) {
return _40_MINUTES_IN_MILISECONDS;
}
if (zoomLevel > -18) {
return _1_HOUR_IN_MILISECONDS
}
if (zoomLevel > - 17) {
return _45_MINUTES_IN_MILISECONDS;
}
if (zoomLevel > -24) {
return _2_HOURS_IN_MILISECONDS
}
if (zoomLevel > - 18) {
return _1_HOUR_IN_MILISECONDS;
}
if (zoomLevel > -25) {
return _3_HOURS_IN_MILISECONDS
}
if (zoomLevel > - 24) {
return _2_HOURS_IN_MILISECONDS;
}
if (zoomLevel > -27) {
return _4_HOURS_IN_MILISECONDS
}
if (zoomLevel > - 25) {
return _3_HOURS_IN_MILISECONDS;
}
if (zoomLevel > -27.5) {
return _6_HOURS_IN_MILISECONDS
}
if (zoomLevel > - 27) {
return _4_HOURS_IN_MILISECONDS;
}
if (zoomLevel > -27.75) {
return _8_HOURS_IN_MILISECONDS
}
if (zoomLevel > - 27.5) {
return _6_HOURS_IN_MILISECONDS;
}
if (zoomLevel > -28) {
return _12_HOURS_IN_MILISECONDS
}
if (zoomLevel > - 27.75) {
return _8_HOURS_IN_MILISECONDS;
}
if (zoomLevel > - 28) {
return _12_HOURS_IN_MILISECONDS;
}
if (zoomLevel <= - 28) {
return ONE_DAY_IN_MILISECONDS;
}
if (zoomLevel <= -28) {
return ONE_DAY_IN_MILISECONDS
}
}
CloudVM/CloudRequire.js
+38 -50
View File
@@ -1,61 +1,49 @@
function newCloudRequire(bot, logger) {
function newCloudRequire (bot, logger) {
const INFO_LOG = true
const LOG_FILE_CONTENT = false
const INFO_LOG = true;
const LOG_FILE_CONTENT = false;
const MODULE_NAME = 'Cloud Require'
const MODULE_NAME = "Cloud Require";
let thisObject = {
downloadBot: downloadBot,
downloadCommons: downloadCommons
}
let thisObject = {
downloadBot: downloadBot,
downloadCommons: downloadCommons
};
return thisObject
return thisObject;
function downloadBot (pCloudStorage, pFilePath, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write(MODULE_NAME, '[INFO] downloadBot -> Entering function.') }
function downloadBot(pCloudStorage, pFilePath, callBackFunction) {
let filePath = window.canvasApp.urlPrefix + 'Bots' + '/' + pFilePath + '/' + 'User.Bot.js'
try {
downloadModule(filePath, onDownloaded)
if (INFO_LOG === true) { logger.write(MODULE_NAME, "[INFO] downloadBot -> Entering function."); }
function onDownloaded (pModule) {
callBackFunction(window.DEFAULT_OK_RESPONSE, pModule)
return
}
} catch (err) {
logger.write(MODULE_NAME, '[ERROR] downloadBot -> err = ' + err.message)
callBackFunction(window.DEFAULT_FAIL_RESPONSE)
}
}
let filePath = window.canvasApp.urlPrefix + "Bots" + "/" + pFilePath + "/" + "User.Bot.js";
function downloadCommons (pCloudStorage, pFilePath, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write(MODULE_NAME, '[INFO] downloadCommons -> Entering function.') }
downloadModule(filePath, onDownloaded)
let filePath = window.canvasApp.urlPrefix + 'Bots' + '/' + pFilePath + '/' + 'Commons.js'
function onDownloaded(pModule) {
downloadModule(filePath, onDownloaded)
callBackFunction(window.DEFAULT_OK_RESPONSE, pModule);
return;
}
} catch (err) {
logger.write(MODULE_NAME, "[ERROR] downloadBot -> err = " + err.message);
callBackFunction(window.DEFAULT_FAIL_RESPONSE);
}
}
function downloadCommons(pCloudStorage, pFilePath, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write(MODULE_NAME, "[INFO] downloadCommons -> Entering function."); }
let filePath = window.canvasApp.urlPrefix + "Bots" + "/" + pFilePath + "/" + "Commons.js";
downloadModule(filePath, onDownloaded)
function onDownloaded(pModule) {
callBackFunction(window.DEFAULT_OK_RESPONSE, pModule);
return;
}
} catch (err) {
logger.write(MODULE_NAME, "[ERROR] downloadCommons -> err = " + err.message);
callBackFunction(window.DEFAULT_FAIL_RESPONSE);
}
}
};
function onDownloaded (pModule) {
callBackFunction(window.DEFAULT_OK_RESPONSE, pModule)
return
}
} catch (err) {
logger.write(MODULE_NAME, '[ERROR] downloadCommons -> err = ' + err.message)
callBackFunction(window.DEFAULT_FAIL_RESPONSE)
}
}
};
CloudVM/CloudSupport.js
+102 -124
View File
@@ -1,4 +1,4 @@

/*
This module is for enabling the AACloud to run at the browser.
@@ -7,137 +7,115 @@ When running at the clode on NodeJS some things work diffently that at the brows
*/
function webRequire(pModulePath) {
function webRequire (pModulePath) {
switch (pModulePath) {
switch (pModulePath) {
case './AzureStorage': {
let MODULE = {}
MODULE.newAzureStorage = newAzureStorage
return MODULE
case './AzureStorage': {
let MODULE = {};
MODULE.newAzureStorage = newAzureStorage;
return MODULE;
function newAzureStorage() {
return AzureStorage.Blob;
}
}
case './EventHandler': {
let MODULE = {};
MODULE.newEventHandler = newEventHandler;
return MODULE;
}
case './BlobStorage': {
let MODULE = {};
MODULE.newBlobStorage = newBlobStorage;
return MODULE;
}
case './DebugLog': {
let MODULE = {};
MODULE.newDebugLog = newDebugLog;
return MODULE;
}
case './TradingBotProcessMainLoop': {
let MODULE = {};
MODULE.newTradingBotProcessMainLoop = newTradingBotProcessMainLoop;
return MODULE;
}
case './ExtractionBotProcessMainLoop': {
let MODULE = {};
MODULE.newExtractionBotProcessMainLoop = newExtractionBotProcessMainLoop;
return MODULE;
}
case './IndicatorBotProcessMainLoop': {
let MODULE = {};
MODULE.newIndicatorBotProcessMainLoop = newIndicatorBotProcessMainLoop;
return MODULE;
}
case './CloudUtilities': {
let MODULE = {};
MODULE.newCloudUtilities = newCloudUtilities;
return MODULE;
}
case './PoloniexAPIClient': {
let MODULE = {};
MODULE.newPoloniexAPIClient = newPoloniexAPIClient;
return MODULE;
}
case './Exchange/ExchangeAPI': {
let MODULE = {};
MODULE.newExchangeAPI = newExchangeAPI;
return MODULE;
}
case './Context': {
let MODULE = {};
MODULE.newContext = newContext;
return MODULE;
}
case './Assistant': {
let MODULE = {};
MODULE.newAssistant = newAssistant;
return MODULE;
}
case './StatusReport': {
let MODULE = {};
MODULE.newStatusReport = newStatusReport;
return MODULE;
}
case './DataSet': {
let MODULE = {};
MODULE.newDataSet = newDataSet;
return MODULE;
}
case './StatusDependencies': {
let MODULE = {};
MODULE.newStatusDependencies = newStatusDependencies;
return MODULE;
}
case './DataDependencies': {
let MODULE = {};
MODULE.newDataDependencies = newDataDependencies;
return MODULE;
}
case './CloudRequire': {
let MODULE = {};
MODULE.newCloudRequire = newCloudRequire;
return MODULE;
}
default: {
console.log(pModulePath + " not found. ");
}
function newAzureStorage () {
return AzureStorage.Blob
}
}
case './EventHandler': {
let MODULE = {}
MODULE.newEventHandler = newEventHandler
return MODULE
}
case './BlobStorage': {
let MODULE = {}
MODULE.newBlobStorage = newBlobStorage
return MODULE
}
case './DebugLog': {
let MODULE = {}
MODULE.newDebugLog = newDebugLog
return MODULE
}
case './TradingBotProcessMainLoop': {
let MODULE = {}
MODULE.newTradingBotProcessMainLoop = newTradingBotProcessMainLoop
return MODULE
}
case './ExtractionBotProcessMainLoop': {
let MODULE = {}
MODULE.newExtractionBotProcessMainLoop = newExtractionBotProcessMainLoop
return MODULE
}
case './IndicatorBotProcessMainLoop': {
let MODULE = {}
MODULE.newIndicatorBotProcessMainLoop = newIndicatorBotProcessMainLoop
return MODULE
}
case './CloudUtilities': {
let MODULE = {}
MODULE.newCloudUtilities = newCloudUtilities
return MODULE
}
case './PoloniexAPIClient': {
let MODULE = {}
MODULE.newPoloniexAPIClient = newPoloniexAPIClient
return MODULE
}
case './Exchange/ExchangeAPI': {
let MODULE = {}
MODULE.newExchangeAPI = newExchangeAPI
return MODULE
}
case './Context': {
let MODULE = {}
MODULE.newContext = newContext
return MODULE
}
case './Assistant': {
let MODULE = {}
MODULE.newAssistant = newAssistant
return MODULE
}
case './StatusReport': {
let MODULE = {}
MODULE.newStatusReport = newStatusReport
return MODULE
}
case './DataSet': {
let MODULE = {}
MODULE.newDataSet = newDataSet
return MODULE
}
case './StatusDependencies': {
let MODULE = {}
MODULE.newStatusDependencies = newStatusDependencies
return MODULE
}
case './DataDependencies': {
let MODULE = {}
MODULE.newDataDependencies = newDataDependencies
return MODULE
}
case './CloudRequire': {
let MODULE = {}
MODULE.newCloudRequire = newCloudRequire
return MODULE
}
default: {
console.log(pModulePath + ' not found. ')
}
}
}
function downloadModule(pPath, callBackFunction) {
function downloadModule (pPath, callBackFunction) {
/* We will need this to load individual bots modules. */
REQUIREJS([pPath], onRequired);
REQUIREJS([pPath], onRequired)
function onRequired(pModule) {
function onRequired (pModule) {
console.log('CloudVM ' + pPath + ' downloaded.')
console.log("CloudVM " + pPath + " downloaded.");
let MODULE = {};
MODULE.newUserBot = newUserBot;
callBackFunction(MODULE);
}
let MODULE = {}
MODULE.newUserBot = newUserBot
callBackFunction(MODULE)
}
}
CloudVM/CloudVM.js
+107 -130
View File
@@ -1,152 +1,129 @@
function newCloudVM() {

function newCloudVM () {
const MODULE_NAME = 'CloudVM'
const INFO_LOG = false
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
const MODULE_NAME = "CloudVM";
const INFO_LOG = false;
const ERROR_LOG = true;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
var thisObject = {
onBotPlayPressed: onBotPlayPressed,
onBotStopPressed: onBotStopPressed
}
var thisObject = {
onBotPlayPressed: onBotPlayPressed,
onBotStopPressed: onBotStopPressed
};
let root = newRoot()
let intervalHandler
let previousBotCode = ''
let errorsCheckingForBotCodeChanges = 0
let root = newRoot();
let intervalHandler;
let previousBotCode = "";
let errorsCheckingForBotCodeChanges = 0;
return thisObject
return thisObject;
function onBotPlayPressed (pUI_COMMANDS) {
try {
if (INFO_LOG === true) { logger.write('[INFO] onBotPlayPressed -> Entering function.') }
function onBotPlayPressed(pUI_COMMANDS) {
window.SHALL_BOT_STOP = false
errorsCheckingForBotCodeChanges = 0
try {
window.CURRENT_ENVIRONMENT = 'Develop'
window.CURRENT_EXECUTION_AT = 'Browser'
window.STORAGE_PERMISSIONS = ecosystem.getStoragePermissions()
if (INFO_LOG === true) { logger.write("[INFO] onBotPlayPressed -> Entering function."); }
window.SHALL_BOT_STOP = false;
errorsCheckingForBotCodeChanges = 0;
window.CURRENT_ENVIRONMENT = "Develop";
window.CURRENT_EXECUTION_AT = "Browser";
window.STORAGE_PERMISSIONS = ecosystem.getStoragePermissions();
window.EXCHANGE_NAME = "Poloniex";
window.MARKET = {
assetA: "USDT",
assetB: "BTC"
};
window.EXCHANGE_NAME = 'Poloniex'
window.MARKET = {
assetA: 'USDT',
assetB: 'BTC'
}
/*
When running at the browser, the AACloud VM will look for this data, in this case it does not contain any key or secret, since the browser only know the
session token the user received when he logged in.
*/
window.EXCHANGE_KEYS = {
Poloniex: {
Key: "",
Secret: ""
}
}
root.initialize(pUI_COMMANDS, onInitialized);
function onInitialized() {
try {
if (INFO_LOG === true) { logger.write("[INFO] onBotPlayPressed -> Entering function."); }
root.start();
intervalHandler = setInterval(checkForChangesInBotCode, 10000);
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] onBotPlayPressed -> onInitialized -> err.message = " + err.message); }
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] onBotPlayPressed -> err.message = " + err.message); }
window.EXCHANGE_KEYS = {
Poloniex: {
Key: '',
Secret: ''
}
}
}
function onBotStopPressed() {
if (INFO_LOG === true) { logger.write("[INFO] onBotStopPressed -> Entering function."); }
window.SHALL_BOT_STOP = true;
errorsCheckingForBotCodeChanges = 0;
}
function checkForChangesInBotCode() {
root.initialize(pUI_COMMANDS, onInitialized)
function onInitialized () {
try {
if (INFO_LOG === true) { logger.write('[INFO] onBotPlayPressed -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] checkForChangesInBotCode -> Entering function."); }
let botFunction = newUserBot;
if (botFunction !== undefined) {
let currentBotCode = botFunction.toString();
if (previousBotCode !== "") {
if (currentBotCode !== previousBotCode) {
console.log("CloudVM -> Bot code changes detected.");
let path = window.canvasApp.urlPrefix
+ "AABrowserAPI" + "/"
+ "saveBotCode" + "/"
+ window.DEV_TEAM + "/"
+ "members" + "/"
+ window.USER_LOGGED_IN + "/"
+ window.CURRENT_BOT_REPO + "/"
+ window.CURRENT_PROCESS + "/"
+ "User.Bot.js"
;
callServer(currentBotCode, path, onServerResponse);
function onServerResponse(err) {
err = JSON.parse(err);
if (INFO_LOG === true) { logger.write("[INFO] checkForChangesInBotCode -> onServerResponse -> Entering function."); }
if (err.result !== GLOBAL.DEFAULT_OK_RESPONSE.result) {
if (ERROR_LOG === true) { logger.write("[ERROR] checkForChangesInBotCode -> onServerResponse -> err.message = " + err.message); }
console.log("CloudVM -> Changes in code NOT saved. Plase check the error log and try again.");
return;
}
console.log("CloudVM -> Changes in code saved.");
}
}
}
previousBotCode = currentBotCode;
}
root.start()
intervalHandler = setInterval(checkForChangesInBotCode, 10000)
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] checkForChangesInBotCode -> err.message = " + err.message); }
errorsCheckingForBotCodeChanges++;
if (errorsCheckingForBotCodeChanges > 2) {
if (ERROR_LOG === true) { logger.write("[ERROR] checkForChangesInBotCode -> Giving up."); }
clearInterval(intervalHandler);
}
if (ERROR_LOG === true) { logger.write('[ERROR] onBotPlayPressed -> onInitialized -> err.message = ' + err.message) }
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] onBotPlayPressed -> err.message = ' + err.message) }
}
}
}
function onBotStopPressed () {
if (INFO_LOG === true) { logger.write('[INFO] onBotStopPressed -> Entering function.') }
window.SHALL_BOT_STOP = true
errorsCheckingForBotCodeChanges = 0
}
function checkForChangesInBotCode () {
try {
if (INFO_LOG === true) { logger.write('[INFO] checkForChangesInBotCode -> Entering function.') }
let botFunction = newUserBot
if (botFunction !== undefined) {
let currentBotCode = botFunction.toString()
if (previousBotCode !== '') {
if (currentBotCode !== previousBotCode) {
console.log('CloudVM -> Bot code changes detected.')
let path = window.canvasApp.urlPrefix
+ 'AABrowserAPI' + '/'
+ 'saveBotCode' + '/'
+ window.DEV_TEAM + '/'
+ 'members' + '/'
+ window.USER_LOGGED_IN + '/'
+ window.CURRENT_BOT_REPO + '/'
+ window.CURRENT_PROCESS + '/'
+ 'User.Bot.js'
callServer(currentBotCode, path, onServerResponse)
function onServerResponse (err) {
err = JSON.parse(err)
if (INFO_LOG === true) { logger.write('[INFO] checkForChangesInBotCode -> onServerResponse -> Entering function.') }
if (err.result !== GLOBAL.DEFAULT_OK_RESPONSE.result) {
if (ERROR_LOG === true) { logger.write('[ERROR] checkForChangesInBotCode -> onServerResponse -> err.message = ' + err.message) }
console.log('CloudVM -> Changes in code NOT saved. Plase check the error log and try again.')
return
}
console.log('CloudVM -> Changes in code saved.')
}
}
}
previousBotCode = currentBotCode
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] checkForChangesInBotCode -> err.message = ' + err.message) }
errorsCheckingForBotCodeChanges++
if (errorsCheckingForBotCodeChanges > 2) {
if (ERROR_LOG === true) { logger.write('[ERROR] checkForChangesInBotCode -> Giving up.') }
clearInterval(intervalHandler)
}
}
}
}
CloudVM/WebFS.js
+41 -48
View File
@@ -1,71 +1,64 @@
function newWebFS() {
const MODULE_NAME = "Web FS";
const INFO_LOG = false;
const ERROR_LOG = true;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
function newWebFS () {
const MODULE_NAME = 'Web FS'
const INFO_LOG = false
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
/*
This is the module emulates the NodeJS 'fs'.
This is the module emulates the NodeJS 'fs'.
*/
var thisObject = {
readFileSync: readFileSync,
appendFileSync: appendFileSync,
mkdirSync: mkdirSync,
statSync: statSync,
readdir: readdir,
readdirSync: readdirSync,
readFile: readFile
};
var thisObject = {
readFileSync: readFileSync,
appendFileSync: appendFileSync,
mkdirSync: mkdirSync,
statSync: statSync,
readdir: readdir,
readdirSync: readdirSync,
readFile: readFile
}
return thisObject
return thisObject;
function readFileSync (pPath, pEncoding) {
switch (pPath) {
function readFileSync(pPath, pEncoding) {
case '': {
break
}
}
}
switch (pPath) {
case '': {
break;
}
}
}
function appendFileSync(pPath, pText) {
function appendFileSync (pPath, pText) {
/* We will ignore this since we can not and dont want to really write something on disk while we are at the browser. */
}
function readdir(pPath, callBackFunction) {
}
function readdir (pPath, callBackFunction) {
/* We will return an empty array of files. */
callBackFunction([]);
}
callBackFunction([])
}
function readdirSync(pPath, callBackFunction) {
function readdirSync (pPath, callBackFunction) {
}
}
function mkdirSync(pPath) {
function mkdirSync (pPath) {
/* Again we do nothing. */
}
}
function readFile(pPath) {
function readFile (pPath) {
/* Again we do nothing. */
}
}
function statSync(pPath) {
let stats
stats.size = 0;
return stats
}
}
function statSync (pPath) {
let stats
stats.size = 0
return stats
}
}
CompetitionStorage.js
+19 -1
View File
@@ -10,7 +10,8 @@ function newCompetitionStorage (pName) {
competitorsSequences: [],
eventHandler: undefined,
initialize: initialize
initialize: initialize,
finalize: finalize
}
@@ -24,6 +25,23 @@ function newCompetitionStorage (pName) {
return thisObject
function finalize () {
try {
if (INFO_LOG === true) { logger.write('[INFO] finalize -> Entering function.') }
if (thisObject.fileSequences !== undefined) {
for (let i = 0; i < thisObject.fileSequences.length; i++) {
let fileSequence = thisObject.fileSequences[i]
fileSequence.finalize()
}
}
thisObject.fileSequences = undefined
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] finalize -> err = ' + err) }
}
}
function initialize (pHost, pCompetition, pExchange, pMarket, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
Container.js
+27 -31
View File
@@ -1,36 +1,32 @@
function newContainer() {
function newContainer () {
var container = {
frame: undefined,
displacement: undefined,
eventHandler: undefined,
parentContainer: undefined,
isDraggeable: true,
isClickeable: false,
isWheelable: false,
name: undefined,
initialize: initialize
}
var container = {
frame: undefined,
displacement: undefined,
eventHandler: undefined,
parentContainer: undefined,
isDraggeable: true,
isClickeable: false,
isWheelable: false,
name: undefined,
initialize: initialize
};
return container
return container;
function initialize () {
var frame = newFrame()
frame.initialize()
this.frame = frame
frame.container = container
function initialize() {
var eventHandler = newEventHandler()
eventHandler.initialize()
eventHandler.name = container.name
this.eventHandler = eventHandler
var frame = newFrame();
frame.initialize();
this.frame = frame;
frame.container = container;
var eventHandler = newEventHandler();
eventHandler.initialize();
eventHandler.name = container.name;
this.eventHandler = eventHandler;
var displacement = newDisplacement();
this.displacement = displacement;
displacement.container = container;
}
}
var displacement = newDisplacement()
this.displacement = displacement
displacement.container = container
}
}
Dashboard.js
+129 -165
View File
@@ -1,133 +1,109 @@
let canvas;
let markets;
let ecosystem = newEcosystem();
let cloudVM = newCloudVM();
let INITIAL_ZOOM_LEVEL = -26; // This is the zoom level at the view port in which the APP starts.
let INITIAL_TIME_PERIOD = recalculatePeriod(INITIAL_ZOOM_LEVEL); // This value will be overwritten at the viewPort.initialize if the user had a prevous session with this same browser.
let viewPort = newViewPort();

let canvas
let markets
let ecosystem = newEcosystem()
let cloudVM = newCloudVM()
let INITIAL_ZOOM_LEVEL = -26 // This is the zoom level at the view port in which the APP starts.
let INITIAL_TIME_PERIOD = recalculatePeriod(INITIAL_ZOOM_LEVEL) // This value will be overwritten at the viewPort.initialize if the user had a prevous session with this same browser.
let viewPort = newViewPort()
function newDashboard() {
function newDashboard () {
const MODULE_NAME = 'Dashboard'
const INFO_LOG = false
const ERROR_LOG = true
const INTENSIVE_LOG = false
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
const MODULE_NAME = "Dashboard";
const INFO_LOG = false;
const ERROR_LOG = true;
const INTENSIVE_LOG = false;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
let thisObject = {
start: start
}
let thisObject = {
start: start
};
const DEBUG_START_UP_DELAY = 0 // 3000; // This is a waiting time in case there is a need to debug the very first steps of initialization, to be able to hit F12 on time.
const DEBUG_START_UP_DELAY = 0; //3000; // This is a waiting time in case there is a need to debug the very first steps of initialization, to be able to hit F12 on time.
return thisObject
return thisObject;
function start () {
try {
if (INFO_LOG === true) { logger.write('[INFO] start -> Entering function.') }
function start() {
/* If this method is executed for a second time, it should finalize the current execution structure */
try {
if (canvas !== undefined) { canvas.finalize() }
if (INFO_LOG === true) { logger.write("[INFO] start -> Entering function."); }
/* Here we will setup the global eventHandler that will enable the Canvas App to react to events happening outside its execution scope. */
/* Here we will setup the global eventHandler that will enable the Canvas App to react to events happening outside its execution scope. */
window.canvasApp.eventHandler = newEventHandler()
window.canvasApp.eventHandler.listenToEvent('User Profile Changed', userProfileChanged)
window.canvasApp.eventHandler.listenToEvent('Browser Resized', browserResized)
window.canvasApp.eventHandler = newEventHandler();
window.canvasApp.eventHandler.listenToEvent("User Profile Changed", userProfileChanged);
window.canvasApp.eventHandler.listenToEvent("Browser Resized", browserResized);
loadImages(onImagesLoaded)
loadImages(onImagesLoaded);
function onImagesLoaded () {
if (INFO_LOG === true) { logger.write('[INFO] start -> onImagesLoaded -> Entering function.') }
function onImagesLoaded() {
/* Next we start the App */
if (INFO_LOG === true) { logger.write("[INFO] start -> onImagesLoaded -> Entering function."); }
/* Next we start the App*/
setTimeout(delayedStart, DEBUG_START_UP_DELAY);
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] start -> err = " + err); }
}
setTimeout(delayedStart, DEBUG_START_UP_DELAY)
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] start -> err = ' + err) }
}
}
function delayedStart() {
try {
if (INFO_LOG === true) { logger.write("[INFO] delayedStart -> Entering function."); }
function delayedStart () {
try {
if (INFO_LOG === true) { logger.write('[INFO] delayedStart -> Entering function.') }
/* For now, we are supporting only one market. */
let market = {
id: 2,
assetA: "USDT",
assetB: "BTC"
};
let market = {
id: 2,
assetA: 'USDT',
assetB: 'BTC'
}
markets = new Map();
markets = new Map()
markets.set(market.id, market);
markets.set(market.id, market)
canvas = newCanvas();
canvas.initialize();
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] delayedStart -> err = " + err); }
}
canvas = newCanvas()
canvas.initialize()
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] delayedStart -> err = ' + err) }
}
}
function userProfileChanged() {
try {
if (INFO_LOG === true) { logger.write("[INFO] userProfileChanged -> Entering function."); }
canvas.topSpace.initialize();
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] userProfileChanged -> err = " + err); }
}
function userProfileChanged () {
try {
if (INFO_LOG === true) { logger.write('[INFO] userProfileChanged -> Entering function.') }
canvas.topSpace.initialize()
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] userProfileChanged -> err = ' + err) }
}
}
function browserResized() {
function browserResized () {
try {
if (INFO_LOG === true) { logger.write('[INFO] browserResized -> Entering function.') }
try {
browserCanvas = document.getElementById('canvas')
if (INFO_LOG === true) { logger.write("[INFO] browserResized -> Entering function."); }
browserCanvas = document.getElementById('canvas');
browserCanvas.width = window.innerWidth;
browserCanvas.height = window.innerHeight - window.canvasApp.topMargin;
viewPort.initialize();
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] browserResized -> err = " + err); }
}
browserCanvas.width = window.innerWidth
browserCanvas.height = window.innerHeight - window.canvasApp.topMargin
viewPort.initialize()
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] browserResized -> err = ' + err) }
}
}
function loadImages(callBack) {
function loadImages (callBack) {
try {
if (INFO_LOG === true) { logger.write('[INFO] loadImages -> Entering function.') }
try {
if (INFO_LOG === true) { logger.write("[INFO] loadImages -> Entering function."); }
const accessToken = "";
const accessToken = ''
/*
Soon, we will need to get images from the Financial Beings Module. I live this core here as a sample for that:
@@ -187,25 +163,25 @@ function newDashboard() {
*/
const networkInterfaceTeams = Apollo.lib.createNetworkInterface({
uri: window.canvasApp.graphQL.masterAppApiUrl
});
const networkInterfaceTeams = Apollo.lib.createNetworkInterface({
uri: window.canvasApp.graphQL.masterAppApiUrl
})
networkInterfaceTeams.use([{
applyMiddleware(req, next) {
req.options.headers = {
authorization: `Bearer ${accessToken}`
};
next();
}
}]);
const apolloClientTeams = new Apollo.lib.ApolloClient({
networkInterface: networkInterfaceTeams,
connectToDevTools: true,
});
networkInterfaceTeams.use([{
applyMiddleware (req, next) {
req.options.headers = {
authorization: `Bearer ${accessToken}`
}
next()
}
}])
const ALL_TEAMS_QUERY = Apollo.gql`
const apolloClientTeams = new Apollo.lib.ApolloClient({
networkInterface: networkInterfaceTeams,
connectToDevTools: true
})
const ALL_TEAMS_QUERY = Apollo.gql`
{
teams_Teams{
edges{
@@ -238,70 +214,58 @@ function newDashboard() {
}
`
let teams;
let teams
const getTeams = () => {
return new Promise((resolve, reject) => {
apolloClientTeams.query({
query: ALL_TEAMS_QUERY
})
const getTeams = () => {
return new Promise((resolve, reject) => {
apolloClientTeams.query({
query: ALL_TEAMS_QUERY
})
.then(response => {
teams = response.data.teams_Teams;
window.localStorage.setItem('Teams', JSON.stringify(response.data.teams_Teams));
resolve({ teams: response.data.teams_Teams })
})
teams = response.data.teams_Teams
window.localStorage.setItem('Teams', JSON.stringify(response.data.teams_Teams))
resolve({ teams: response.data.teams_Teams })
})
.catch(err => {
if (ERROR_LOG === true) { logger.write("[ERROR] loadImages -> getTeams -> Error fetching data from Teams Module."); }
if (ERROR_LOG === true) { logger.write("[ERROR] loadImages -> getTeams -> err = " + err); }
reject(err)
});
})
}
if (ERROR_LOG === true) { logger.write('[ERROR] loadImages -> getTeams -> Error fetching data from Teams Module.') }
if (ERROR_LOG === true) { logger.write('[ERROR] loadImages -> getTeams -> err = ' + err) }
reject(err)
})
})
}
// To avoid race conditions, add asynchronous fetches to array
let fetchDataPromises = [];
let fetchDataPromises = []
fetchDataPromises.push(/*getUser(),*/ getTeams()); // <-- Here we must add the function calll to the Financial Beings module.
fetchDataPromises.push(/* getUser(), */ getTeams()) // <-- Here we must add the function calll to the Financial Beings module.
// When all asynchronous fetches resolve, authenticate user or throw error.
Promise.all(fetchDataPromises).then(result => {
Promise.all(fetchDataPromises).then(result => {
/* All good, we will go through the results creating a map with all the Images URLs */
let teamProfileImages = new Map();
let fbProfileImages = new Map();
let teamProfileImages = new Map()
let fbProfileImages = new Map()
for (let i = 0; i < teams.edges.length; i++) {
for (let i = 0; i < teams.edges.length; i++) {
let team = teams.edges[i].node
let team = teams.edges[i].node;
teamProfileImages.set(team.slug, team.profile.avatar);
if (team.fb.length > 0) {
fbProfileImages.set(team.slug + "-" + team.fb[0].slug, team.fb[0].avatar);
}
}
window.canvasApp.context.teamProfileImages = teamProfileImages;
window.canvasApp.context.fbProfileImages = fbProfileImages;
callBack();
}, err => {
if (ERROR_LOG === true) { logger.write("[ERROR] loadImages -> Error fetching data from Teams Module."); }
if (ERROR_LOG === true) { logger.write("[ERROR] loadImages -> err = " + err); }
});
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] loadImages -> err = " + err); }
teamProfileImages.set(team.slug, team.profile.avatar)
if (team.fb.length > 0) {
fbProfileImages.set(team.slug + '-' + team.fb[0].slug, team.fb[0].avatar)
}
}
window.canvasApp.context.teamProfileImages = teamProfileImages
window.canvasApp.context.fbProfileImages = fbProfileImages
callBack()
}, err => {
if (ERROR_LOG === true) { logger.write('[ERROR] loadImages -> Error fetching data from Teams Module.') }
if (ERROR_LOG === true) { logger.write('[ERROR] loadImages -> err = ' + err) }
})
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] loadImages -> err = ' + err) }
}
}
}
Displace.js
+42 -59
View File
@@ -1,81 +1,64 @@
/*

/*
We call displacement to the offset we can produce to the object which the displcement object is is a child from.
The displacement is a vector that displaces everything static drawn on on the context of the parent object.
We call displacement to the offset we can produce to the object which the displcement object is is a child from.
The displacement is a vector that displaces everything static drawn on on the context of the parent object.
*/
function newDisplacement() {
function newDisplacement () {
var displacement = {
containerName: '', // This is for debugging purposes only.
parentDisplacement: undefined, // Here we store the displacement object of the parent cointainer, if exists.
container: undefined,
x: 0, // This is the actual x displacement.
y: 0, // This is the actual y displacement.
displace: displace,
undisplaceThisPoint: undisplaceThisPoint,
displaceThisPoint: displaceThisPoint
}
var displacement = {
containerName: "", // This is for debugging purposes only.
parentDisplacement: undefined, // Here we store the displacement object of the parent cointainer, if exists.
container: undefined,
x: 0, // This is the actual x displacement.
y: 0, // This is the actual y displacement.
displace: displace,
undisplaceThisPoint: undisplaceThisPoint,
displaceThisPoint: displaceThisPoint
};
return displacement;
function displace(amountX, amountY) {
return displacement
function displace (amountX, amountY) {
/* First we check if by allowing this displacement we would produce the current frame to be beyond its limit. */
tempDisplacement = newDisplacement();
tempDisplacement.x = amountX;
tempDisplacement.y = amountY;
if (this.container.frame.canYouMoveHere(tempDisplacement)) {
tempDisplacement = newDisplacement()
tempDisplacement.x = amountX
tempDisplacement.y = amountY
if (this.container.frame.canYouMoveHere(tempDisplacement)) {
/* Now we displace */
displacement.x = displacement.x + amountX;
displacement.y = displacement.y + amountY;
displacement.x = displacement.x + amountX
displacement.y = displacement.y + amountY
return true;
}
return false;
return true
}
function displaceThisPoint(point) {
return false
}
if (this.parentDisplacement !== undefined) {
point = this.parentDisplacement.displaceThisPoint(point);
}
point.x = point.x + displacement.x;
point.y = point.y + displacement.y;
return point;
function displaceThisPoint (point) {
if (this.parentDisplacement !== undefined) {
point = this.parentDisplacement.displaceThisPoint(point)
}
function undisplaceThisPoint(point) {
point.x = point.x + displacement.x
point.y = point.y + displacement.y
if (this.parentDisplacement !== undefined) {
return point
}
point = this.parentDisplacement.undisplaceThisPoint(point);
}
point.x = point.x - displacement.x;
point.y = point.y - displacement.y;
return point;
function undisplaceThisPoint (point) {
if (this.parentDisplacement !== undefined) {
point = this.parentDisplacement.undisplaceThisPoint(point)
}
point.x = point.x - displacement.x
point.y = point.y - displacement.y
return point
}
}
EventHandler.js
+51 -72
View File
@@ -1,93 +1,72 @@
function newEventHandler() {

function newEventHandler () {
const CONSOLE_LOG = false
const CONSOLE_LOG = false;
let thisObject = {
name: undefined, // This is for debugging purposes only.
parentEventHandler: undefined, // Here we store the parent cointainer zoom object.
listenToEvent: listenToEvent,
stopListening: stopListening,
raiseEvent: raiseEvent,
initialize: initialize
}
let thisObject = {
name: undefined, // This is for debugging purposes only.
parentEventHandler: undefined, // Here we store the parent cointainer zoom object.
listenToEvent: listenToEvent,
stopListening: stopListening,
raiseEvent: raiseEvent,
initialize: initialize
};
var eventHandlers = [] // Here we store all the functions we will call when an event is comming.
var eventHandlers = []; // Here we store all the functions we will call when an event is comming.
return thisObject
return thisObject;
function initialize () {
function initialize() {
}
function listenToEvent (eventType, handler, extraData) {
eventHandlers.push([eventType, handler, extraData])
if (thisObject.name !== undefined && CONSOLE_LOG === true) {
console.log('Event Handler named ' + thisObject.name + ' received a request to listenToEvent ' + eventType + ' and call ' + (handler.toString()).substring(0, 50))
}
}
function stopListening (pEventType, pHandler) {
if (thisObject.name !== undefined && CONSOLE_LOG === true) {
console.log('Event Handler named ' + thisObject.name + ' received a request to stop listening to an the event ' + pEventType + ' with this handler: ' + pHandler)
}
function listenToEvent(eventType, handler, extraData) {
for (let i = 0; i < eventHandlers.length; i++) {
let record = eventHandlers[i]
let eventType = record[0]
let handler = record[1]
eventHandlers.push([eventType, handler, extraData]);
if (pEventType === eventType && pHandler.toString() === handler.toString()) {
eventHandlers.splice(i, 1)
if (thisObject.name !== undefined && CONSOLE_LOG === true) {
console.log("Event Handler named " + thisObject.name + " received a request to listenToEvent " + eventType + " and call " + (handler.toString()).substring(0, 50));
console.log('Evethandler found and deleted.')
}
return
}
}
}
function raiseEvent (eventType, event) {
if (thisObject.name !== undefined && CONSOLE_LOG === true) {
console.log('Event Handler named ' + thisObject.name + ' received a request to raiseEvent ' + eventType + ' with this data ' + (event.toString()).substring(0, 50))
}
function stopListening(pEventType, pHandler) {
if (thisObject.name !== undefined && CONSOLE_LOG === true) {
console.log("Event Handler named " + thisObject.name + " received a request to stop listening to an the event " + pEventType + " with this handler: " + pHandler);
}
for (let i = 0; i < eventHandlers.length; i++) {
let record = eventHandlers[i];
let eventType = record[0];
let handler = record[1];
if (pEventType === eventType && pHandler.toString() === handler.toString()) {
eventHandlers.splice(i, 1);
if (thisObject.name !== undefined && CONSOLE_LOG === true) {
console.log("Evethandler found and deleted.");
}
return;
}
}
}
function raiseEvent(eventType, event) {
if (thisObject.name !== undefined && CONSOLE_LOG === true) {
console.log("Event Handler named " + thisObject.name + " received a request to raiseEvent " + eventType + " with this data " + (event.toString()).substring(0, 50));
}
for (var i = 0; i < eventHandlers.length; i++) {
for (var i = 0; i < eventHandlers.length; i++) {
/* We will execute all the functions listening to this event type. */
if (eventHandlers[i][0] === eventType) {
if (eventHandlers[i][0] === eventType) {
var handler = eventHandlers[i][1]
var extraData = eventHandlers[i][2]
var handler = eventHandlers[i][1];
var extraData = eventHandlers[i][2];
if (thisObject.name !== undefined && CONSOLE_LOG === true) {
console.log("Event Handler named " + thisObject.name + " received a request to raiseEvent " + eventType + " and will call this handler: " + (handler.toString()).substring(0,50));
}
handler(event, extraData);
}
if (thisObject.name !== undefined && CONSOLE_LOG === true) {
console.log('Event Handler named ' + thisObject.name + ' received a request to raiseEvent ' + eventType + ' and will call this handler: ' + (handler.toString()).substring(0, 50))
}
handler(event, extraData)
}
}
}
}
Exchange/ExchangeAPI.js
+72 -61
View File
@@ -1,63 +1,57 @@
function newExchangeAPI() {
function newExchangeAPI () {
const INFO_LOG = true
const LOG_FILE_CONTENT = true
const INFO_LOG = true;
const LOG_FILE_CONTENT = true;
const MODULE_NAME = 'CloudVM -> Exchange API'
const MODULE_NAME = "CloudVM -> Exchange API";
const SERVER_URL = window.canvasApp.urlPrefix + 'ExchangeAPI/'
const SERVER_URL = window.canvasApp.urlPrefix + "ExchangeAPI/";
let thisObject = {
initialize: initialize,
getTicker: getTicker,
getOpenPositions: getOpenPositions,
getExecutedTrades: getExecutedTrades,
putPosition: putPosition,
movePosition: movePosition,
getPublicTradeHistory: getPublicTradeHistory
};
let thisObject = {
initialize: initialize,
getTicker: getTicker,
getOpenPositions: getOpenPositions,
getExecutedTrades: getExecutedTrades,
putPosition: putPosition,
movePosition: movePosition,
getPublicTradeHistory: getPublicTradeHistory
}
return thisObject;
function initialize(callBackFunction) {
return thisObject
function initialize (callBackFunction) {
/* When this initialized is called from the Browser, there is no need to send it to the server since the server will
anyways initialize this library at each method call. */
callBackFunction(window.DEFAULT_OK_RESPONSE);
}
callBackFunction(window.DEFAULT_OK_RESPONSE)
}
function getTicker(pMarket, callBackFunction) {
let authToken = window.localStorage.getItem('access_token');
function getTicker (pMarket, callBackFunction) {
let authToken = window.localStorage.getItem('access_token')
let path = SERVER_URL
+ "getTicker" + "/"
+ authToken
;
callServer(undefined, path + "/NO-LOG", onServerResponse);
callServer(undefined, path + '/NO-LOG', onServerResponse)
function onServerResponse(pServerResponse) {
let response = JSON.parse(pServerResponse);
if (response.result === window.DEFAULT_FAIL_RESPONSE.result)
callBackFunction(window.DEFAULT_FAIL_RESPONSE);
else
callBackFunction(window.DEFAULT_OK_RESPONSE, response);
}
}
function onServerResponse (pServerResponse) {
let response = JSON.parse(pServerResponse)
if (response.result === window.DEFAULT_FAIL_RESPONSE.result) {
callBackFunction(window.DEFAULT_FAIL_RESPONSE)
} else {
callBackFunction(window.DEFAULT_OK_RESPONSE, response)
}
}
}
function getOpenPositions(pMarket, callBackFunction) {
function getOpenPositions (pMarket, callBackFunction) {
let authToken = window.localStorage.getItem('access_token')
let authToken = window.localStorage.getItem('access_token');
let path = SERVER_URL
+ "getOpenPositions" + "/"
+ authToken
;
callServer(undefined, path + "/NO-LOG", onServerResponse);
function onServerResponse(pServerResponse) {
let response = JSON.parse(pServerResponse);
@@ -102,20 +96,29 @@
+ pAmountB
;
callServer(undefined, path + "/NO-LOG", onServerResponse);
callServer(undefined, path + '/NO-LOG', onServerResponse)
function onServerResponse(pServerResponse) {
let response = JSON.parse(pServerResponse);
if (response.result === window.DEFAULT_FAIL_RESPONSE.result)
callBackFunction(window.DEFAULT_FAIL_RESPONSE);
else
callBackFunction(window.DEFAULT_OK_RESPONSE, response);
}
}
function onServerResponse (pServerResponse) {
let response = JSON.parse(pServerResponse)
if (response.result === window.DEFAULT_FAIL_RESPONSE.result) {
callBackFunction(window.DEFAULT_FAIL_RESPONSE)
} else {
callBackFunction(window.DEFAULT_OK_RESPONSE, response)
}
}
}
function movePosition(pPositionId, pNewRate, pPositionAmountB, callBackFunction) {
function putPosition (pMarket, pType, pRate, pAmountA, pAmountB, callBackFunction) {
let authToken = window.localStorage.getItem('access_token')
let authToken = window.localStorage.getItem('access_token');
let path = SERVER_URL
+ CURRENT_BOT_CODE_NAME + '/'
+ 'putPosition' + '/'
+ authToken + '/'
+ pType + '/'
+ pRate + '/'
+ pAmountA + '/'
+ pAmountB
let path = SERVER_URL
+ "movePosition" + "/"
@@ -123,22 +126,30 @@
+ pPositionId + "/"
+ pNewRate + "/"
+ pPositionAmountB
;
callServer(undefined, path + "/NO-LOG", onServerResponse);
callServer(undefined, path + '/NO-LOG', onServerResponse)
function onServerResponse(pServerResponse) {
let response = JSON.parse(pServerResponse);
if (response.result === window.DEFAULT_FAIL_RESPONSE.result)
callBackFunction(window.DEFAULT_FAIL_RESPONSE);
else
callBackFunction(window.DEFAULT_OK_RESPONSE, response);
}
}
function onServerResponse (pServerResponse) {
let response = JSON.parse(pServerResponse)
if (response.result === window.DEFAULT_FAIL_RESPONSE.result) {
callBackFunction(window.DEFAULT_FAIL_RESPONSE)
} else {
callBackFunction(window.DEFAULT_OK_RESPONSE, response)
}
}
}
function getPublicTradeHistory(pMarket, startTime, endTime, callBackFunction) {
function getPublicTradeHistory (pMarket, startTime, endTime, callBackFunction) {
let authToken = window.localStorage.getItem('access_token')
let authToken = window.localStorage.getItem('access_token');
let path = SERVER_URL
+ CURRENT_BOT_CODE_NAME + '/'
+ 'getPublicTradeHistory' + '/'
+ authToken + '/'
+ startTime + '/'
+ endTime
callServer(undefined, path + '/NO-LOG', onServerResponse)
let path = SERVER_URL
+ "getPublicTradeHistory" + "/"
Files/DailyFiles.js
+256 -321
View File
@@ -1,392 +1,327 @@
function newDailyFiles() {

function newDailyFiles () {
const MODULE_NAME = 'Daily Files'
const INFO_LOG = false
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
const MODULE_NAME = "Daily Files";
const INFO_LOG = false;
const ERROR_LOG = true;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
let thisObject = {
getFileCursor: getFileCursor,
setDatetime: setDatetime,
setTimePeriod: setTimePeriod,
getExpectedFiles: getExpectedFiles,
getFilesLoaded: getFilesLoaded,
initialize: initialize,
finalize: finalize
}
let thisObject = {
getFileCursor: getFileCursor,
setDatetime: setDatetime,
setTimePeriod: setTimePeriod,
getExpectedFiles: getExpectedFiles,
getFilesLoaded: getFilesLoaded,
initialize: initialize,
finalize: finalize
let filesLoaded = 0
let expectedFiles = 0
let fileCloud
let fileCursors = new Map()
let callBackWhenFileReceived
return thisObject
function finalize () {
try {
if (INFO_LOG === true) { logger.write('[INFO] finalize -> Entering function.') }
filesLoaded = undefined
expectedFiles = undefined
fileCloud = undefined
fileCursors.forEach(finalizeEach)
function finalizeEach (item, key, mapObj) {
if (INFO_LOG === true) { logger.write('[INFO] finalize -> finalizeEach -> Entering function.') }
item.finalize()
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] finalize -> err = ' + err) }
}
}
let filesLoaded = 0;
let expectedFiles = 0;
function initialize (pDevTeam, pBot, pProduct, pSet, pExchange, pMarket, pDatetime, pTimePeriod, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
let fileCloud;
callBackWhenFileReceived = callBackFunction
let fileCursors = new Map;
let exchange = ecosystem.getExchange(pProduct, pExchange)
let callBackWhenFileReceived;
if (exchange === undefined) {
throw 'Exchange not supoorted by this product of the ecosystem! - pDevTeam.codeName = ' + pDevTeam.codeName + ', pBot.codeName = ' + pBot.codeName + ', pProduct.codeName = ' + pProduct.codeName + ', pExchange = ' + pExchange
}
return thisObject;
function finalize() {
try {
if (INFO_LOG === true) { logger.write("[INFO] finalize -> Entering function."); }
filesLoaded = undefined;
expectedFiles = undefined;
fileCloud = undefined;
fileCursors.forEach(finalizeEach);
function finalizeEach(item, key, mapObj) {
if (INFO_LOG === true) { logger.write("[INFO] finalize -> finalizeEach -> Entering function."); }
item.finalize();
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] finalize -> err = " + err); }
}
}
function initialize(pDevTeam, pBot, pProduct, pSet, pExchange, pMarket, pDatetime, pTimePeriod, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
callBackWhenFileReceived = callBackFunction;
let exchange = ecosystem.getExchange(pProduct, pExchange);
if (exchange === undefined) {
throw "Exchange not supoorted by this product of the ecosystem! - pDevTeam.codeName = " + pDevTeam.codeName + ", pBot.codeName = " + pBot.codeName + ", pProduct.codeName = " + pProduct.codeName + ", pExchange = " + pExchange;
}
fileCloud = newFileCloud();
fileCloud.initialize(pBot);
fileCloud = newFileCloud()
fileCloud.initialize(pBot)
/* First we will get the Data Range */
fileCloud.getFile(pDevTeam, pBot, pSet, exchange, pMarket, undefined, undefined, undefined, true, onDataRangeReceived);
fileCloud.getFile(pDevTeam, pBot, pSet, exchange, pMarket, undefined, undefined, undefined, true, onDataRangeReceived)
function onDataRangeReceived(err, pFile) {
function onDataRangeReceived (err, pFile) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Entering function.') }
try {
let beginDateRange
let endDateRange
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Entering function."); }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received OK Response.') }
let beginDateRange;
let endDateRange;
beginDateRange = new Date(pFile.begin)
endDateRange = new Date(pFile.end)
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
break
}
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received OK Response."); }
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received FAIL Response.') }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
return
}
beginDateRange = new Date(pFile.begin);
endDateRange = new Date(pFile.end);
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received CUSTOM FAIL Response.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> err.message = ' + err.message) }
break;
}
if (err.message === 'File does not exist.') {
if (INFO_LOG === true) { logger.write('[WARN] initialize -> onFileReceived -> No Date Range file found. maxDate will be set to current datetime. ') }
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
endDateRange = new Date()
break
}
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received FAIL Response."); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
return;
}
if (err.message === 'Missing Configuration.') {
if (ERROR_LOG === true) { logger.write('[WARN] initialize -> onFileReceived -> The needed configuration for the dateRange at the dataSet of the product was not found.') }
if (ERROR_LOG === true) { logger.write('[WARN] initialize -> onFileReceived -> maxDate will be set to current datetime.') }
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received CUSTOM FAIL Response."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> err.message = " + err.message); }
if (err.message === "File does not exist.") {
if (INFO_LOG === true) { logger.write("[WARN] initialize -> onFileReceived -> No Date Range file found. maxDate will be set to current datetime. "); }
endDateRange = new Date();
break;
}
if (err.message === "Missing Configuration.") {
if (ERROR_LOG === true) { logger.write("[WARN] initialize -> onFileReceived -> The needed configuration for the dateRange at the dataSet of the product was not found."); }
if (ERROR_LOG === true) { logger.write("[WARN] initialize -> onFileReceived -> maxDate will be set to current datetime."); }
endDateRange = new Date();
break;
}
endDateRange = new Date()
break
}
/* If none of the previous conditions are met, the we return the err to the caller. */
callBackFunction(err);
return;
}
callBackFunction(err)
return
}
default: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received Unexpected Response."); }
callBackFunction(err);
return;
}
}
default: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received Unexpected Response.') }
callBackFunction(err)
return
}
}
/* Now we will get the daily files */
for (i = 0; i < dailyFilePeriods.length; i++) {
for (i = 0; i < dailyFilePeriods.length; i++) {
let periodTime = dailyFilePeriods[i][0]
let periodName = dailyFilePeriods[i][1]
let periodTime = dailyFilePeriods[i][0];
let periodName = dailyFilePeriods[i][1];
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> periodTime = ' + periodTime) }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> periodName = ' + periodName) }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> periodTime = " + periodTime); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> periodName = " + periodName); }
if (pSet.validPeriods.includes(periodName) === true) {
let fileCursor = newFileCursor()
fileCursor.initialize(fileCloud, pDevTeam, pBot, pSet, exchange, pMarket, periodName, periodTime, pDatetime, pTimePeriod, beginDateRange, endDateRange, onInitialized)
if (pSet.validPeriods.includes(periodName) === true) {
function onInitialized (err) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> onInitialized -> Entering function.') }
let fileCursor = newFileCursor();
fileCursor.initialize(fileCloud, pDevTeam, pBot, pSet, exchange, pMarket, periodName, periodTime, pDatetime, pTimePeriod, beginDateRange, endDateRange, onInitialized);
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
function onInitialized(err) {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> onInitialized -> Received OK Response.') }
break
}
try {
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> onInitialized -> Entering function."); }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> onInitialized -> Received FAIL Response.') }
callBackWhenFileReceived(GLOBAL.DEFAULT_FAIL_RESPONSE)
return
}
default: {
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> onInitialized -> Received Unexpected Response.') }
callBackWhenFileReceived(err)
return
}
}
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> onInitialized -> Received OK Response."); }
break;
}
fileCursors.set(periodTime, fileCursor)
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> onInitialized -> expectedFiles = ' + expectedFiles) }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> onInitialized -> Received FAIL Response."); }
callBackWhenFileReceived(GLOBAL.DEFAULT_FAIL_RESPONSE);
return;
}
default: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> onInitialized -> Received Unexpected Response."); }
callBackWhenFileReceived(err);
return;
}
}
fileCursors.set(periodTime, fileCursor);
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> onInitialized -> expectedFiles = " + expectedFiles); }
expectedFiles = expectedFiles + fileCursor.getExpectedFiles();
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> onInitialized -> expectedFiles = " + expectedFiles); }
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onFileReceived -> onInitialized -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
}
}
}
loadThemAll();
function loadThemAll() {
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> loadThemAll -> Entering function."); }
for (i = 0; i < dailyFilePeriods.length; i++) {
let periodTime = dailyFilePeriods[i][0];
let periodName = dailyFilePeriods[i][1];
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> loadThemAll -> periodTime = " + periodTime); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> loadThemAll -> periodName = " + periodName); }
if (pSet.validPeriods.includes(periodName) === true) {
let fileCursor = fileCursors.get(periodTime);
fileCursor.reload(onFileReceived);
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onFileReceived -> loadThemAll -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
}
expectedFiles = expectedFiles + fileCursor.getExpectedFiles()
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> onInitialized -> expectedFiles = ' + expectedFiles) }
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onFileReceived -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> onFileReceived -> onInitialized -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
}
}
} catch (err) {
loadThemAll()
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
}
function loadThemAll () {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> loadThemAll -> Entering function.') }
function onFileReceived(err) {
for (i = 0; i < dailyFilePeriods.length; i++) {
let periodTime = dailyFilePeriods[i][0]
let periodName = dailyFilePeriods[i][1]
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> loadThemAll -> periodTime = ' + periodTime) }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> loadThemAll -> periodName = ' + periodName) }
if (INFO_LOG === true) { logger.write("[INFO] onFileReceived -> Entering function."); }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] onFileReceived -> Received OK Response."); }
break;
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] onFileReceived -> Received FAIL Response."); }
callBackWhenFileReceived(GLOBAL.DEFAULT_FAIL_RESPONSE);
return;
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] onFileReceived -> Received CUSTOM FAIL Response."); }
if (INFO_LOG === true) { logger.write("[INFO] onFileReceived -> err.message = " + err.message); }
callBackWhenFileReceived(err);
return;
}
default: {
if (INFO_LOG === true) { logger.write("[INFO] onFileReceived -> Received Unexpected Response."); }
callBackWhenFileReceived(err);
return;
if (pSet.validPeriods.includes(periodName) === true) {
let fileCursor = fileCursors.get(periodTime)
fileCursor.reload(onFileReceived)
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> onFileReceived -> loadThemAll -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
filesLoaded++;
if (INFO_LOG === true) { logger.write("[INFO] onFileReceived -> filesLoaded = " + filesLoaded); }
callBackWhenFileReceived(GLOBAL.DEFAULT_OK_RESPONSE, thisObject); // Note that the call back is called for every file loaded at each cursor.
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] onFileReceived -> err = " + err); }
callBackWhenFileReceived(GLOBAL.DEFAULT_FAIL_RESPONSE);
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> onFileReceived -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function getFileCursor(pPeriod) {
function onFileReceived (err) {
try {
if (INFO_LOG === true) { logger.write('[INFO] onFileReceived -> Entering function.') }
try {
if (INFO_LOG === true) { logger.write("[INFO] getFileCursor -> Entering function."); }
return fileCursors.get(pPeriod);
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] getFileCursor -> err = " + err); }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] onFileReceived -> Received OK Response.') }
break
}
}
function setDatetime(pDatetime) {
try {
if (INFO_LOG === true) { logger.write("[INFO] setDatetime -> Entering function."); }
filesLoaded = 0;
expectedFiles = 0;
fileCursors.forEach(setDatetimeToEach)
function setDatetimeToEach(fileCursor, key, map) {
fileCursor.setDatetime(pDatetime);
if (INFO_LOG === true) { logger.write("[INFO] setDatetime -> expectedFiles = " + expectedFiles); }
expectedFiles = expectedFiles + fileCursor.getExpectedFiles();
if (INFO_LOG === true) { logger.write("[INFO] setDatetime -> expectedFiles = " + expectedFiles); }
fileCursor.reload(onFileReceived);
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] setDatetime -> err = " + err); }
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] onFileReceived -> Received FAIL Response.') }
callBackWhenFileReceived(GLOBAL.DEFAULT_FAIL_RESPONSE)
return
}
}
function setTimePeriod(pTimePeriod, pDatetime) {
try {
if (INFO_LOG === true) { logger.write("[INFO] setTimePeriod -> Entering function."); }
filesLoaded = 0;
expectedFiles = 0;
fileCursors.forEach(setTimePeriodToEach)
function setTimePeriodToEach(fileCursor, key, map) {
fileCursor.setTimePeriod(pTimePeriod, pDatetime);
if (INFO_LOG === true) { logger.write("[INFO] setTimePeriod -> expectedFiles = " + expectedFiles); }
expectedFiles = expectedFiles + fileCursor.getExpectedFiles();
if (INFO_LOG === true) { logger.write("[INFO] setTimePeriod -> expectedFiles = " + expectedFiles); }
fileCursor.reload(onFileReceived);
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] setTimePeriod -> err = " + err); }
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] onFileReceived -> Received CUSTOM FAIL Response.') }
if (INFO_LOG === true) { logger.write('[INFO] onFileReceived -> err.message = ' + err.message) }
callBackWhenFileReceived(err)
return
}
default: {
if (INFO_LOG === true) { logger.write('[INFO] onFileReceived -> Received Unexpected Response.') }
callBackWhenFileReceived(err)
return
}
}
filesLoaded++
if (INFO_LOG === true) { logger.write('[INFO] onFileReceived -> filesLoaded = ' + filesLoaded) }
callBackWhenFileReceived(GLOBAL.DEFAULT_OK_RESPONSE, thisObject) // Note that the call back is called for every file loaded at each cursor.
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] onFileReceived -> err = ' + err) }
callBackWhenFileReceived(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function getExpectedFiles() {
if (INFO_LOG === true) { logger.write("[INFO] getExpectedFiles -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] getExpectedFiles -> expectedFiles = " + expectedFiles); }
return expectedFiles;
function getFileCursor (pPeriod) {
try {
if (INFO_LOG === true) { logger.write('[INFO] getFileCursor -> Entering function.') }
return fileCursors.get(pPeriod)
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] getFileCursor -> err = ' + err) }
}
}
function getFilesLoaded() {
function setDatetime (pDatetime) {
try {
if (INFO_LOG === true) { logger.write('[INFO] setDatetime -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] getFilesLoaded -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] getFilesLoaded -> filesLoaded = " + filesLoaded); }
filesLoaded = 0
expectedFiles = 0
return filesLoaded;
fileCursors.forEach(setDatetimeToEach)
function setDatetimeToEach (fileCursor, key, map) {
fileCursor.setDatetime(pDatetime)
if (INFO_LOG === true) { logger.write('[INFO] setDatetime -> expectedFiles = ' + expectedFiles) }
expectedFiles = expectedFiles + fileCursor.getExpectedFiles()
if (INFO_LOG === true) { logger.write('[INFO] setDatetime -> expectedFiles = ' + expectedFiles) }
fileCursor.reload(onFileReceived)
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] setDatetime -> err = ' + err) }
}
}
}
function setTimePeriod (pTimePeriod, pDatetime) {
try {
if (INFO_LOG === true) { logger.write('[INFO] setTimePeriod -> Entering function.') }
filesLoaded = 0
expectedFiles = 0
fileCursors.forEach(setTimePeriodToEach)
function setTimePeriodToEach (fileCursor, key, map) {
fileCursor.setTimePeriod(pTimePeriod, pDatetime)
if (INFO_LOG === true) { logger.write('[INFO] setTimePeriod -> expectedFiles = ' + expectedFiles) }
expectedFiles = expectedFiles + fileCursor.getExpectedFiles()
if (INFO_LOG === true) { logger.write('[INFO] setTimePeriod -> expectedFiles = ' + expectedFiles) }
fileCursor.reload(onFileReceived)
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] setTimePeriod -> err = ' + err) }
}
}
function getExpectedFiles () {
if (INFO_LOG === true) { logger.write('[INFO] getExpectedFiles -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] getExpectedFiles -> expectedFiles = ' + expectedFiles) }
return expectedFiles
}
function getFilesLoaded () {
if (INFO_LOG === true) { logger.write('[INFO] getFilesLoaded -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] getFilesLoaded -> filesLoaded = ' + filesLoaded) }
return filesLoaded
}
}
Files/FileCloud.js
-2
View File
@@ -161,7 +161,6 @@ function newFileCloud () {
if (err.message === 'XHR error') {
if (pRetryCounter < MAX_RETRIES) {
if (ERROR_LOG === true) { logger.write('[ERROR] getFile -> getFileRecursively -> onFileReceived -> Retrying to get this file. ') }
if (ERROR_LOG === true) { logger.write('[ERROR] getFile -> getFileRecursively -> onFileReceived -> MAX_RETRIES = ' + MAX_RETRIES) }
if (ERROR_LOG === true) { logger.write('[ERROR] getFile -> getFileRecursively -> onFileReceived -> pRetryCounter = ' + pRetryCounter) }
@@ -169,7 +168,6 @@ function newFileCloud () {
getFileRecursively(pRetryCounter + 1, pDevTeam, pBot, pSet, pExchange, pMarket, pPeriodName, pDatetime, pSequence, pDataRange, callBackFunction)
return
} else {
if (ERROR_LOG === true) { logger.write('[ERROR] getFile -> getFileRecursively -> onFileReceived -> Could not get this file from storage. ') }
if (ERROR_LOG === true) { logger.write('[ERROR] getFile -> getFileRecursively -> onFileReceived -> MAX_RETRIES = ' + MAX_RETRIES) }
if (ERROR_LOG === true) { logger.write('[ERROR] getFile -> getFileRecursively -> onFileReceived -> pRetryCounter = ' + pRetryCounter) }
Files/FileCursor.js
+479 -581
View File
File diff suppressed because it is too large. Load diff
Files/FileSequence.js
-8
View File
@@ -139,20 +139,17 @@ function newFileSequence () {
try {
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSequenceFileReceived -> onFileReceived -> Received OK Response.') }
break
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSequenceFileReceived -> onFileReceived -> Received FAIL Response.') }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
return
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSequenceFileReceived -> onFileReceived -> Received CUSTOM FAIL Response.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSequenceFileReceived -> onFileReceived -> err.message = ' + err.message) }
@@ -161,7 +158,6 @@ function newFileSequence () {
}
default: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSequenceFileReceived -> onFileReceived -> Received Unexpected Response.') }
callBackFunction(err)
return
@@ -274,26 +270,22 @@ function newFileSequence () {
try {
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onSequenceFileReceived -> onFileReceived -> Received OK Response.') }
break
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onSequenceFileReceived -> onFileReceived -> Received FAIL Response.') }
return
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onSequenceFileReceived -> onFileReceived -> Received CUSTOM FAIL Response.') }
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onSequenceFileReceived -> onFileReceived -> err.message = ' + err.message) }
return
}
default: {
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onSequenceFileReceived -> onFileReceived -> Received Unexpected Response.') }
return
}
Files/MarketFiles.js
+173 -216
View File
@@ -1,253 +1,210 @@
function newMarketFiles() {

function newMarketFiles () {
const MODULE_NAME = 'Market Files'
const INFO_LOG = false
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
const MODULE_NAME = "Market Files";
const INFO_LOG = false;
const ERROR_LOG = true;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
let thisObject = {
eventHandler: undefined,
getFile: getFile,
getExpectedFiles: getExpectedFiles,
getFilesLoaded: getFilesLoaded,
initialize: initialize,
finalize: finalize
}
let thisObject = {
eventHandler: undefined,
getFile: getFile,
getExpectedFiles: getExpectedFiles,
getFilesLoaded: getFilesLoaded,
initialize: initialize,
finalize: finalize
let filesLoaded = 0
let fileCloud
let files = new Map()
let market
let exchange
let devTeam
let bot
let thisSet
let periodName
thisObject.eventHandler = newEventHandler()
let intervalHandle
return thisObject
function finalize () {
try {
if (INFO_LOG === true) { logger.write('[INFO] finalize -> Entering function.') }
clearInterval(intervalHandle)
filesLoaded = undefined
files = undefined
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] finalize -> err = ' + err) }
}
}
let filesLoaded = 0;
function initialize (pDevTeam, pBot, pProduct, pSet, pExchange, pMarket, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
let fileCloud;
exchange = ecosystem.getExchange(pProduct, pExchange)
let files = new Map;
if (exchange === undefined) {
throw 'Exchange not supoorted by this pProduct of the ecosystem! - pDevTeam.codeName = ' + pDevTeam.codeName + ', pBot.codeName = ' + pBot.codeName + ', pProduct.codeName = ' + pProduct.codeName + ', pExchange = ' + pExchange
}
let market;
let exchange;
let devTeam;
let bot;
let thisSet;
let periodName;
intervalHandle = setInterval(updateFiles, _10_MINUTES_IN_MILISECONDS)
thisObject.eventHandler = newEventHandler();
market = pMarket
devTeam = pDevTeam
bot = pBot
thisSet = pSet
let intervalHandle;
return thisObject;
function finalize() {
try {
if (INFO_LOG === true) { logger.write("[INFO] finalize -> Entering function."); }
clearInterval(intervalHandle);
filesLoaded = undefined;
files = undefined;
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] finalize -> err = " + err); }
}
}
function initialize(pDevTeam, pBot, pProduct, pSet, pExchange, pMarket, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
exchange = ecosystem.getExchange(pProduct, pExchange);
if (exchange === undefined) {
throw "Exchange not supoorted by this pProduct of the ecosystem! - pDevTeam.codeName = " + pDevTeam.codeName + ", pBot.codeName = " + pBot.codeName + ", pProduct.codeName = " + pProduct.codeName + ", pExchange = " + pExchange;
}
intervalHandle = setInterval(updateFiles, _10_MINUTES_IN_MILISECONDS);
market = pMarket;
devTeam = pDevTeam;
bot = pBot;
thisSet = pSet;
fileCloud = newFileCloud();
fileCloud.initialize(pBot);
fileCloud = newFileCloud()
fileCloud.initialize(pBot)
/* Now we will get the market files */
for (let i = 0; i < marketFilesPeriods.length; i++) {
for (let i = 0; i < marketFilesPeriods.length; i++) {
let periodTime = marketFilesPeriods[i][0]
let periodName = marketFilesPeriods[i][1]
let periodTime = marketFilesPeriods[i][0];
let periodName = marketFilesPeriods[i][1];
if (thisSet.validPeriods.includes(periodName) === true) {
fileCloud.getFile(devTeam, bot, thisSet, exchange, market, periodName, undefined, undefined, undefined, onFileReceived)
if (thisSet.validPeriods.includes(periodName) === true) {
function onFileReceived (err, file) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Entering function.') }
fileCloud.getFile(devTeam, bot, thisSet, exchange, market, periodName, undefined, undefined, undefined, onFileReceived);
function onFileReceived(err, file) {
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Entering function."); }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received OK Response."); }
break;
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received FAIL Response."); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
return;
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received CUSTOM FAIL Response."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> err.message = " + err.message); }
callBackFunction(err);
return;
}
default: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received Unexpected Response."); }
callBackFunction(err);
return;
}
}
files.set(periodTime, file);
filesLoaded++;
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE, thisObject); // Note that the callback is called for every file loaded.
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onFileReceived -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
}
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received OK Response.') }
break
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received FAIL Response.') }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
return
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received CUSTOM FAIL Response.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> err.message = ' + err.message) }
callBackFunction(err)
return
}
default: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received Unexpected Response.') }
callBackFunction(err)
return
}
}
files.set(periodTime, file)
filesLoaded++
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE, thisObject) // Note that the callback is called for every file loaded.
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> onFileReceived -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function updateFiles() {
function updateFiles () {
try {
let updateFiles = 0
try {
let updateFiles = 0;
if (INFO_LOG === true) { logger.write("[INFO] updateFiles -> Entering function."); }
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> Entering function.') }
/* Now we will get the market files */
for (let i = 0; i < marketFilesPeriods.length; i++) {
for (let i = 0; i < marketFilesPeriods.length; i++) {
let periodTime = marketFilesPeriods[i][0]
let periodName = marketFilesPeriods[i][1]
let periodTime = marketFilesPeriods[i][0];
let periodName = marketFilesPeriods[i][1];
if (thisSet.validPeriods.includes(periodName) === true) {
fileCloud.getFile(devTeam, bot, thisSet, exchange, market, periodName, undefined, undefined, undefined, onFileReceived)
if (thisSet.validPeriods.includes(periodName) === true) {
function onFileReceived (err, file) {
try {
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onFileReceived -> Entering function.') }
fileCloud.getFile(devTeam, bot, thisSet, exchange, market, periodName, undefined, undefined, undefined, onFileReceived);
function onFileReceived(err, file) {
try {
if (INFO_LOG === true) { logger.write("[INFO] updateFiles -> onFileReceived -> Entering function."); }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] updateFiles -> onFileReceived -> Received OK Response."); }
break;
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] updateFiles -> onFileReceived -> Received FAIL Response."); }
return;
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] updateFiles -> onFileReceived -> Received CUSTOM FAIL Response."); }
if (INFO_LOG === true) { logger.write("[INFO] updateFiles -> onFileReceived -> err.message = " + err.message); }
return;
}
default: {
if (INFO_LOG === true) { logger.write("[INFO] updateFiles -> onFileReceived -> Received Unexpected Response."); }
return;
}
}
files.set(periodTime, file);
updateFiles++;
if (updateFiles === marketFilesPeriods.length) {
if (INFO_LOG === true) { logger.write("[INFO] updateFiles -> onFileReceived -> All files received. "); }
if (INFO_LOG === true) { logger.write("[INFO] updateFiles -> onFileReceived -> devTeam = " + devTeam.codeName); }
if (INFO_LOG === true) { logger.write("[INFO] updateFiles -> onFileReceived -> bot = " + bot.codeName); }
if (INFO_LOG === true) { logger.write("[INFO] updateFiles -> onFileReceived -> thisSet = " + thisSet.codeName); }
thisObject.eventHandler.raiseEvent("Files Updated", undefined);
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] updateFiles -> onFileReceived -> err = " + err); }
}
}
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onFileReceived -> Received OK Response.') }
break
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onFileReceived -> Received FAIL Response.') }
return
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onFileReceived -> Received CUSTOM FAIL Response.') }
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onFileReceived -> err.message = ' + err.message) }
return
}
default: {
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onFileReceived -> Received Unexpected Response.') }
return
}
}
files.set(periodTime, file)
updateFiles++
if (updateFiles === marketFilesPeriods.length) {
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onFileReceived -> All files received. ') }
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onFileReceived -> devTeam = ' + devTeam.codeName) }
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onFileReceived -> bot = ' + bot.codeName) }
if (INFO_LOG === true) { logger.write('[INFO] updateFiles -> onFileReceived -> thisSet = ' + thisSet.codeName) }
thisObject.eventHandler.raiseEvent('Files Updated', undefined)
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] updateFiles -> onFileReceived -> err = ' + err) }
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] updateFiles -> err = " + err); }
}
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] updateFiles -> err = ' + err) }
}
}
function getFile(pPeriod) {
function getFile (pPeriod) {
if (INFO_LOG === true) { logger.write('[INFO] getFile -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] getFile -> Entering function."); }
return files.get(pPeriod)
}
return files.get(pPeriod);
function getExpectedFiles () {
if (INFO_LOG === true) { logger.write('[INFO] getExpectedFiles -> Entering function.') }
}
return marketFilesPeriods.length
}
function getExpectedFiles() {
function getFilesLoaded () {
if (INFO_LOG === true) { logger.write('[INFO] getFilesLoaded -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] getExpectedFiles -> Entering function."); }
return marketFilesPeriods.length;
}
function getFilesLoaded() {
if (INFO_LOG === true) { logger.write("[INFO] getFilesLoaded -> Entering function."); }
return filesLoaded;
}
}
return filesLoaded
}
}
Files/SingleFile.js
+69 -85
View File
@@ -1,105 +1,89 @@
function newSingleFile() {

function newSingleFile () {
const MODULE_NAME = 'Single File'
const INFO_LOG = false
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
const MODULE_NAME = "Single File";
const INFO_LOG = false;
const ERROR_LOG = true;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
let thisObject = {
getFile: getFile,
initialize: initialize
}
let thisObject = {
getFile: getFile,
initialize: initialize
}
let fileCloud
let file
let fileCloud;
let file;
return thisObject
return thisObject;
function initialize (pDevTeam, pBot, pProduct, pSet, pExchange, pMarket, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
function initialize(pDevTeam, pBot, pProduct, pSet, pExchange, pMarket, callBackFunction) {
let exchange = ecosystem.getExchange(pProduct, pExchange)
try {
if (pExchange !== undefined && exchange === undefined) {
// We support no exchange as a parameter, but if provided, then it must be at the list of exchanges of that product.
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
throw 'Exchange not supoorted by this pProduct of the ecosystem! - pDevTeam.codeName = ' + pDevTeam.codeName + ', pBot.codeName = ' + pBot.codeName + ', pProduct.codeName = ' + pProduct.codeName + ', pExchange = ' + pExchange
}
let exchange = ecosystem.getExchange(pProduct, pExchange);
if (pExchange !== undefined && exchange === undefined) { // We support no exchange as a parameter, but if provided, then it must be at the list of exchanges of that product.
throw "Exchange not supoorted by this pProduct of the ecosystem! - pDevTeam.codeName = " + pDevTeam.codeName + ", pBot.codeName = " + pBot.codeName + ", pProduct.codeName = " + pProduct.codeName + ", pExchange = " + pExchange;
}
fileCloud = newFileCloud();
fileCloud.initialize(pBot);
fileCloud = newFileCloud()
fileCloud.initialize(pBot)
/* Now we will get the file */
fileCloud.getFile(pDevTeam, pBot, pSet, exchange, pMarket, undefined, undefined, undefined, undefined, onFileReceived);
fileCloud.getFile(pDevTeam, pBot, pSet, exchange, pMarket, undefined, undefined, undefined, undefined, onFileReceived)
function onFileReceived(err, pFile) {
function onFileReceived (err, pFile) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Entering function.') }
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Entering function."); }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received OK Response."); }
break;
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received FAIL Response."); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
return;
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received CUSTOM FAIL Response."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> err.message = " + err.message); }
callBackFunction(err);
return;
}
default: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileReceived -> Received Unexpected Response."); }
callBackFunction(err);
return;
}
}
file = pFile;
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE);
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onFileReceived -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received OK Response.') }
break
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received FAIL Response.') }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
return
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received CUSTOM FAIL Response.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> err.message = ' + err.message) }
callBackFunction(err)
return
}
default: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileReceived -> Received Unexpected Response.') }
callBackFunction(err)
return
}
}
file = pFile
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE)
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> onFileReceived -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function getFile() {
function getFile () {
if (INFO_LOG === true) { logger.write('[INFO] getFile -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] getFile -> Entering function."); }
return file;
}
}
return file
}
}
FloatingSpace/FloatingLayer.js
+660 -787
View File
File diff suppressed because it is too large. Load diff
FloatingSpace/FloatingObject.js
+185 -219
View File
@@ -1,274 +1,240 @@
function newFloatingObject() {

function newFloatingObject () {
const MODULE_NAME = 'Floating Object'
const INFO_LOG = false
const INTENSIVE_LOG = false
const ERROR_LOG = true
const MODULE_NAME = "Floating Object";
const INFO_LOG = false;
const INTENSIVE_LOG = false;
const ERROR_LOG = true;
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
var thisObject = {
var thisObject = {
physicsLoop: physicsLoop,
eventHandler: undefined,
physicsLoop: physicsLoop,
eventHandler: undefined,
payload: undefined, // This is a reference to an object controlled by a Plotter. The plotter can change its internal value and we will see them from here.
type: undefined, // Currently there are two types of Floating Objects: Profile Balls, and Notes.
payload: undefined, // This is a reference to an object controlled by a Plotter. The plotter can change its internal value and we will see them from here.
type: undefined, // Currently there are two types of Floating Objects: Profile Balls, and Notes.
physicsEnabled: false,
physicsEnabled: false,
initializeMass: initializeMass,
initializeRadius: initializeRadius,
initializeImageSize: initializeImageSize,
initializeFontSize: initializeFontSize,
initializeMass: initializeMass,
initializeRadius: initializeRadius,
initializeImageSize: initializeImageSize,
initializeFontSize: initializeFontSize,
imageId: undefined,
imageId: undefined,
currentPosition: 0, // Current x,y position of the floating object at the floating object's layer, where there is no displacement or zoom. This position is always changing towards the target position.
currentSpeed: 0, // This is the current speed of the floating object.
currentRadius: 0, // This is the current radius of the floating object, including its zoom applied.
currentMass: 0, // This is the current mass of the floating object, including its zoom applied.
currentPosition: 0, // Current x,y position of the floating object at the floating object's layer, where there is no displacement or zoom. This position is always changing towards the target position.
currentSpeed: 0, // This is the current speed of the floating object.
currentRadius: 0, // This is the current radius of the floating object, including its zoom applied.
currentMass: 0, // This is the current mass of the floating object, including its zoom applied.
friction: 0, // This is a factor that will ultimatelly desacelerate the floating object.
friction: 0, // This is a factor that will ultimatelly desacelerate the floating object.
rawMass: 0, // This is the mass value without zoom.
rawRadius: 0, // This is the radius of this floating object without zoom.
rawMass: 0, // This is the mass value without zoom.
rawRadius: 0, // This is the radius of this floating object without zoom.
targetRadius: 0, // This is the target radius of the floating object with zoom applied. It should be animated until reaching this value.
targetRadius: 0, // This is the target radius of the floating object with zoom applied. It should be animated until reaching this value.
fillStyle: '',
fillStyle: '',
labelStrokeStyle: '',
labelStrokeStyle: '',
radomizeCurrentPosition: radomizeCurrentPosition,
radomizeCurrentSpeed: radomizeCurrentSpeed,
radomizeCurrentPosition: radomizeCurrentPosition,
radomizeCurrentSpeed: radomizeCurrentSpeed,
drawBackground: drawBackground,
drawForeground: drawForeground,
drawBackground: drawBackground,
drawForeground: drawForeground,
updateMass: updateMass, // Function to update the mass when the zoom level changed.
updateRadius: updateRadius, // Function to update the radius when the zoom level changed.
updateMass: updateMass, // Function to update the mass when the zoom level changed.
updateRadius: updateRadius, // Function to update the radius when the zoom level changed.
linkedObject: undefined, // This is a reference to the object that this floating object is representing.
linkedObjectType: '', // Since there might be floating objects for different types of objects, here we store the type of object we are linking to.
linkedObject: undefined, // This is a reference to the object that this floating object is representing.
linkedObjectType: "", // Since there might be floating objects for different types of objects, here we store the type of object we are linking to.
container: undefined, // This is a pointer to the object where the floating object belongs to.
initialize: initialize
container: undefined, // This is a pointer to the object where the floating object belongs to.
initialize: initialize
}
};
let underlayingObject
let underlayingObject;
thisObject.eventHandler = newEventHandler()
thisObject.eventHandler = newEventHandler();
return thisObject
return thisObject;
function initialize (pType, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
function initialize(pType, callBackFunction) {
switch (pType) {
try {
case 'Profile Ball': {
underlayingObject = newProfileBall()
underlayingObject.initialize(onInitialized)
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
function onInitialized (err) {
switch (pType) {
}
case "Profile Ball": {
underlayingObject = newProfileBall();
underlayingObject.initialize(onInitialized);
function onInitialized(err) {
}
break;
}
case "Note": {
underlayingObject = newNote();
underlayingObject.initialize(onInitialized);
function onInitialized(err) {
}
break;
}
default: {
break;
}
}
thisObject.type = pType;
thisObject.eventHandler.listenToEvent("onMouseOver", onMouseOver);
canvas.eventHandler.listenToEvent("onMouseNotOver", onMouseNotOver);
thisObject.eventHandler.listenToEvent("onMouseClick", onMouseClick);
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE); }
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err.message = " + err.message); }
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE); }
break
}
}
case 'Note': {
underlayingObject = newNote()
underlayingObject.initialize(onInitialized)
function physicsLoop(callBackFunction) {
function onInitialized (err) {
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
underlayingObject.physicsLoop();
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE); }
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] physicsLoop -> err.message = " + err.message); }
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE); }
}
}
function onMouseOver() {
thisObject.targetRadius = thisObject.rawRadius * 1.5;
thisObject.targetImageSize = thisObject.rawImageSize * 1.5;
thisObject.targetFontSize = thisObject.rawFontSize * 1.5;
underlayingObject.onMouseOver();
}
function onMouseNotOver() {
thisObject.targetRadius = thisObject.rawRadius * 1;
thisObject.targetImageSize = thisObject.rawImageSize * 1;
thisObject.targetFontSize = thisObject.rawFontSize * 1;
underlayingObject.onMouseNotOver();
}
function onMouseClick(pPoint) {
underlayingObject.onMouseClick(pPoint, thisObject);
}
function drawBackground() {
underlayingObject.drawBackground(thisObject);
}
function drawForeground() {
underlayingObject.drawForeground(thisObject);
}
function initializeMass(suggestedValue) {
var mass = suggestedValue;
if (mass < 0.1) {
mass = 0.1;
}
break
}
thisObject.rawMass = mass;
thisObject.currentMass = mass;
}
function initializeRadius(suggestedValue) {
var radius = suggestedValue;
if (radius < 2) {
radius = 2;
default: {
break
}
}
thisObject.rawRadius = radius;
thisObject.targetRadius = radius;
thisObject.currentRadius = radius / 3;
thisObject.type = pType
thisObject.eventHandler.listenToEvent('onMouseOver', onMouseOver)
canvas.eventHandler.listenToEvent('onMouseNotOver', onMouseNotOver)
thisObject.eventHandler.listenToEvent('onMouseClick', onMouseClick)
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE) }
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> err.message = ' + err.message) }
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE) }
}
}
function physicsLoop (callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
underlayingObject.physicsLoop()
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE) }
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] physicsLoop -> err.message = ' + err.message) }
if (callBackFunction !== undefined) { callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE) }
}
}
function onMouseOver () {
thisObject.targetRadius = thisObject.rawRadius * 1.5
thisObject.targetImageSize = thisObject.rawImageSize * 1.5
thisObject.targetFontSize = thisObject.rawFontSize * 1.5
underlayingObject.onMouseOver()
}
function onMouseNotOver () {
thisObject.targetRadius = thisObject.rawRadius * 1
thisObject.targetImageSize = thisObject.rawImageSize * 1
thisObject.targetFontSize = thisObject.rawFontSize * 1
underlayingObject.onMouseNotOver()
}
function onMouseClick (pPoint) {
underlayingObject.onMouseClick(pPoint, thisObject)
}
function drawBackground () {
underlayingObject.drawBackground(thisObject)
}
function drawForeground () {
underlayingObject.drawForeground(thisObject)
}
function initializeMass (suggestedValue) {
var mass = suggestedValue
if (mass < 0.1) {
mass = 0.1
}
function initializeImageSize(suggestedValue) {
var size = suggestedValue;
if (size < 2) {
size = 2;
}
thisObject.rawImageSize = size;
thisObject.targetImageSize = size;
thisObject.currentImageSize = size / 3;
thisObject.rawMass = mass
thisObject.currentMass = mass
}
function initializeRadius (suggestedValue) {
var radius = suggestedValue
if (radius < 2) {
radius = 2
}
function initializeFontSize(suggestedValue) {
var size = suggestedValue;
if (size < 3) {
size = 3;
}
thisObject.rawFontSize = size;
thisObject.targetFontSize = size;
thisObject.currentFontSize = size / 3;
thisObject.rawRadius = radius
thisObject.targetRadius = radius
thisObject.currentRadius = radius / 3
}
function initializeImageSize (suggestedValue) {
var size = suggestedValue
if (size < 2) {
size = 2
}
function radomizeCurrentPosition(arroundPoint) {
thisObject.rawImageSize = size
thisObject.targetImageSize = size
thisObject.currentImageSize = size / 3
}
var position = {
x: Math.floor((Math.random() * (200) - 100)) + arroundPoint.x,
y: Math.floor((Math.random() * (200) - 100)) + arroundPoint.y
};
thisObject.currentPosition = position;
function initializeFontSize (suggestedValue) {
var size = suggestedValue
if (size < 3) {
size = 3
}
function radomizeCurrentSpeed() {
thisObject.rawFontSize = size
thisObject.targetFontSize = size
thisObject.currentFontSize = size / 3
}
var initialXDirection;
var randomX = Math.floor((Math.random() * 10) + 1);
if (randomX > 5) {
initialXDirection = 1;
} else {
initialXDirection = - 1;
}
var initialYDirection;
var randomY = Math.floor((Math.random() * 10) + 1);
if (randomY > 5) {
initialYDirection = 1;
} else {
initialYDirection = - 1;
}
var velocity = {
x: initialXDirection * Math.floor((Math.random() * 300) + 1) / 100,
y: initialYDirection * Math.floor((Math.random() * 300) + 1) / 100
};
thisObject.currentSpeed = velocity;
function radomizeCurrentPosition (arroundPoint) {
var position = {
x: Math.floor((Math.random() * (200) - 100)) + arroundPoint.x,
y: Math.floor((Math.random() * (200) - 100)) + arroundPoint.y
}
function updateMass() {
//thisObject.currentMass = thisObject.rawMass + thisObject.rawMass * thisObject.container.zoom.incrementM * thisObject.container.zoom.levelM;
thisObject.currentPosition = position
}
function radomizeCurrentSpeed () {
var initialXDirection
var randomX = Math.floor((Math.random() * 10) + 1)
if (randomX > 5) {
initialXDirection = 1
} else {
initialXDirection = -1
}
function updateRadius() {
//thisObject.targetRadius = thisObject.rawRadius + thisObject.rawRadius * thisObject.container.zoom.incrementR * thisObject.container.zoom.levelR;
var initialYDirection
var randomY = Math.floor((Math.random() * 10) + 1)
if (randomY > 5) {
initialYDirection = 1
} else {
initialYDirection = -1
}
var velocity = {
x: initialXDirection * Math.floor((Math.random() * 300) + 1) / 100,
y: initialYDirection * Math.floor((Math.random() * 300) + 1) / 100
}
thisObject.currentSpeed = velocity
}
function updateMass () {
// thisObject.currentMass = thisObject.rawMass + thisObject.rawMass * thisObject.container.zoom.incrementM * thisObject.container.zoom.levelM;
}
function updateRadius () {
// thisObject.targetRadius = thisObject.rawRadius + thisObject.rawRadius * thisObject.container.zoom.incrementR * thisObject.container.zoom.levelR;
}
}
FloatingSpace/Note.js
+212 -244
View File
@@ -1,336 +1,304 @@
function newNote() {

function newNote () {
var thisObject = {
var thisObject = {
physicsLoop: physicsLoop,
onMouseOver: onMouseOver,
onMouseClick: onMouseClick,
onMouseNotOver: onMouseNotOver,
drawBackground: drawBackground,
drawForeground: drawForeground,
initialize: initialize
physicsLoop: physicsLoop,
onMouseOver: onMouseOver,
onMouseClick: onMouseClick,
onMouseNotOver: onMouseNotOver,
drawBackground: drawBackground,
drawForeground: drawForeground,
initialize: initialize
}
};
return thisObject
return thisObject;
function initialize (callBackFunction) {
callBackFunction()
}
function initialize(callBackFunction) {
function physicsLoop () {
callBackFunction();
}
function onMouseOver () {
}
function onMouseNotOver () {
}
function onMouseClick (pPoint, pFloatingObject) {
}
function drawBackground (pFloatingObject) {
let point = {
x: pFloatingObject.payload.notes[pFloatingObject.payloadNoteIndex].position.x,
y: pFloatingObject.payload.notes[pFloatingObject.payloadNoteIndex].position.y
}
function physicsLoop() {
}
function onMouseOver() {
}
function onMouseNotOver() {
}
function onMouseClick(pPoint, pFloatingObject) {
}
function drawBackground(pFloatingObject) {
let point = {
x: pFloatingObject.payload.notes[pFloatingObject.payloadNoteIndex].position.x,
y: pFloatingObject.payload.notes[pFloatingObject.payloadNoteIndex].position.y
};
point = viewPort.fitIntoVisibleArea(point);
if (pFloatingObject.currentRadius > 1) {
point = viewPort.fitIntoVisibleArea(point)
if (pFloatingObject.currentRadius > 1) {
/* Target Line */
browserCanvasContext.beginPath();
browserCanvasContext.moveTo(pFloatingObject.currentPosition.x, pFloatingObject.currentPosition.y);
browserCanvasContext.lineTo(point.x, point.y);
browserCanvasContext.strokeStyle = 'rgba(204, 204, 204, 0.5)';
browserCanvasContext.setLineDash([4, 2]);
browserCanvasContext.lineWidth = 1;
browserCanvasContext.stroke();
browserCanvasContext.setLineDash([0, 0]);
}
if (pFloatingObject.currentRadius > 0.5) {
/* Target Spot */
var radius = 1;
browserCanvasContext.beginPath();
browserCanvasContext.arc(point.x, point.y, radius, 0, Math.PI * 2, true);
browserCanvasContext.closePath();
browserCanvasContext.fillStyle = 'rgba(30, 30, 30, 1)';
browserCanvasContext.fill();
}
browserCanvasContext.beginPath()
browserCanvasContext.moveTo(pFloatingObject.currentPosition.x, pFloatingObject.currentPosition.y)
browserCanvasContext.lineTo(point.x, point.y)
browserCanvasContext.strokeStyle = 'rgba(204, 204, 204, 0.5)'
browserCanvasContext.setLineDash([4, 2])
browserCanvasContext.lineWidth = 1
browserCanvasContext.stroke()
browserCanvasContext.setLineDash([0, 0])
}
function drawForeground(pFloatingObject) {
if (pFloatingObject.currentRadius > 0.5) {
/* Target Spot */
const BUBBLE_CORNERS_RADIOUS = 5;
const TITLE_BAR_HEIGHT = 14;
var radius = 1
const BUBBLE_WIDTH = BUBBLE_CORNERS_RADIOUS + pFloatingObject.currentRadius * 4;
const BUBBLE_HEIGHT = BUBBLE_CORNERS_RADIOUS + pFloatingObject.currentRadius * 2;
browserCanvasContext.beginPath()
browserCanvasContext.arc(point.x, point.y, radius, 0, Math.PI * 2, true)
browserCanvasContext.closePath()
browserCanvasContext.fillStyle = 'rgba(30, 30, 30, 1)'
browserCanvasContext.fill()
}
}
let borderPoint1;
let borderPoint2;
let borderPoint3;
let borderPoint4;
function drawForeground (pFloatingObject) {
const BUBBLE_CORNERS_RADIOUS = 5
const TITLE_BAR_HEIGHT = 14
let intialDisplace = {
x: pFloatingObject.currentPosition.x - BUBBLE_WIDTH / 2,
y: pFloatingObject.currentPosition.y - BUBBLE_HEIGHT / 2
}
const BUBBLE_WIDTH = BUBBLE_CORNERS_RADIOUS + pFloatingObject.currentRadius * 4
const BUBBLE_HEIGHT = BUBBLE_CORNERS_RADIOUS + pFloatingObject.currentRadius * 2
if (pFloatingObject.currentRadius > 5) {
let borderPoint1
let borderPoint2
let borderPoint3
let borderPoint4
let intialDisplace = {
x: pFloatingObject.currentPosition.x - BUBBLE_WIDTH / 2,
y: pFloatingObject.currentPosition.y - BUBBLE_HEIGHT / 2
}
if (pFloatingObject.currentRadius > 5) {
/* Rounded Background */
borderPoint1 = {
x: intialDisplace.x + BUBBLE_CORNERS_RADIOUS,
y: intialDisplace.y + BUBBLE_CORNERS_RADIOUS
};
borderPoint1 = {
x: intialDisplace.x + BUBBLE_CORNERS_RADIOUS,
y: intialDisplace.y + BUBBLE_CORNERS_RADIOUS
}
borderPoint2 = {
x: intialDisplace.x + BUBBLE_WIDTH - BUBBLE_CORNERS_RADIOUS,
y: intialDisplace.y + BUBBLE_CORNERS_RADIOUS
};
borderPoint2 = {
x: intialDisplace.x + BUBBLE_WIDTH - BUBBLE_CORNERS_RADIOUS,
y: intialDisplace.y + BUBBLE_CORNERS_RADIOUS
}
borderPoint3 = {
x: intialDisplace.x + BUBBLE_WIDTH - BUBBLE_CORNERS_RADIOUS,
y: intialDisplace.y + BUBBLE_HEIGHT - BUBBLE_CORNERS_RADIOUS
};
borderPoint3 = {
x: intialDisplace.x + BUBBLE_WIDTH - BUBBLE_CORNERS_RADIOUS,
y: intialDisplace.y + BUBBLE_HEIGHT - BUBBLE_CORNERS_RADIOUS
}
borderPoint4 = {
x: intialDisplace.x + BUBBLE_CORNERS_RADIOUS,
y: intialDisplace.y + + BUBBLE_HEIGHT - BUBBLE_CORNERS_RADIOUS
};
borderPoint4 = {
x: intialDisplace.x + BUBBLE_CORNERS_RADIOUS,
y: intialDisplace.y + +BUBBLE_HEIGHT - BUBBLE_CORNERS_RADIOUS
}
titleBarPoint1 = {
x: intialDisplace.x + 0,
y: intialDisplace.y + TITLE_BAR_HEIGHT
};
titleBarPoint1 = {
x: intialDisplace.x + 0,
y: intialDisplace.y + TITLE_BAR_HEIGHT
}
titleBarPoint2 = {
x: intialDisplace.x + BUBBLE_WIDTH,
y: intialDisplace.y + TITLE_BAR_HEIGHT
};
titleBarPoint2 = {
x: intialDisplace.x + BUBBLE_WIDTH,
y: intialDisplace.y + TITLE_BAR_HEIGHT
}
/* We paint the panel background first */
browserCanvasContext.fillStyle = 'rgba(255, 249, 196, 0.75)';
browserCanvasContext.beginPath();
browserCanvasContext.fillStyle = 'rgba(255, 249, 196, 0.75)'
browserCanvasContext.beginPath()
browserCanvasContext.arc(borderPoint1.x, borderPoint1.y, BUBBLE_CORNERS_RADIOUS, 1.0 * Math.PI, 1.5 * Math.PI);
browserCanvasContext.lineTo(borderPoint2.x, borderPoint2.y - BUBBLE_CORNERS_RADIOUS);
browserCanvasContext.arc(borderPoint2.x, borderPoint2.y, BUBBLE_CORNERS_RADIOUS, 1.5 * Math.PI, 2.0 * Math.PI);
browserCanvasContext.lineTo(borderPoint3.x + BUBBLE_CORNERS_RADIOUS, borderPoint3.y);
browserCanvasContext.arc(borderPoint3.x, borderPoint3.y, BUBBLE_CORNERS_RADIOUS, 0 * Math.PI, 0.5 * Math.PI);
browserCanvasContext.lineTo(borderPoint4.x, borderPoint4.y + BUBBLE_CORNERS_RADIOUS);
browserCanvasContext.arc(borderPoint4.x, borderPoint4.y, BUBBLE_CORNERS_RADIOUS, 0.5 * Math.PI, 1.0 * Math.PI);
browserCanvasContext.lineTo(borderPoint1.x - BUBBLE_CORNERS_RADIOUS, borderPoint1.y);
browserCanvasContext.arc(borderPoint1.x, borderPoint1.y, BUBBLE_CORNERS_RADIOUS, 1.0 * Math.PI, 1.5 * Math.PI)
browserCanvasContext.lineTo(borderPoint2.x, borderPoint2.y - BUBBLE_CORNERS_RADIOUS)
browserCanvasContext.arc(borderPoint2.x, borderPoint2.y, BUBBLE_CORNERS_RADIOUS, 1.5 * Math.PI, 2.0 * Math.PI)
browserCanvasContext.lineTo(borderPoint3.x + BUBBLE_CORNERS_RADIOUS, borderPoint3.y)
browserCanvasContext.arc(borderPoint3.x, borderPoint3.y, BUBBLE_CORNERS_RADIOUS, 0 * Math.PI, 0.5 * Math.PI)
browserCanvasContext.lineTo(borderPoint4.x, borderPoint4.y + BUBBLE_CORNERS_RADIOUS)
browserCanvasContext.arc(borderPoint4.x, borderPoint4.y, BUBBLE_CORNERS_RADIOUS, 0.5 * Math.PI, 1.0 * Math.PI)
browserCanvasContext.lineTo(borderPoint1.x - BUBBLE_CORNERS_RADIOUS, borderPoint1.y)
browserCanvasContext.closePath();
browserCanvasContext.closePath()
browserCanvasContext.fill();
browserCanvasContext.fill()
browserCanvasContext.lineWidth = 0.1;
browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.DARK + ', 0.75)';
browserCanvasContext.stroke();
browserCanvasContext.lineWidth = 0.1
browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.DARK + ', 0.75)'
browserCanvasContext.stroke()
/* We paint the title bar now */
browserCanvasContext.fillStyle = 'rgba(244, 224, 44, 0.75)';
browserCanvasContext.beginPath();
browserCanvasContext.fillStyle = 'rgba(244, 224, 44, 0.75)'
browserCanvasContext.beginPath()
browserCanvasContext.moveTo(titleBarPoint1.x, titleBarPoint1.y);
browserCanvasContext.lineTo(borderPoint1.x - BUBBLE_CORNERS_RADIOUS, borderPoint1.y);
browserCanvasContext.arc(borderPoint1.x, borderPoint1.y, BUBBLE_CORNERS_RADIOUS, 1.0 * Math.PI, 1.5 * Math.PI);
browserCanvasContext.lineTo(borderPoint2.x, borderPoint2.y - BUBBLE_CORNERS_RADIOUS);
browserCanvasContext.arc(borderPoint2.x, borderPoint2.y, BUBBLE_CORNERS_RADIOUS, 1.5 * Math.PI, 2.0 * Math.PI);
browserCanvasContext.lineTo(titleBarPoint2.x, titleBarPoint2.y);
browserCanvasContext.moveTo(titleBarPoint1.x, titleBarPoint1.y)
browserCanvasContext.lineTo(borderPoint1.x - BUBBLE_CORNERS_RADIOUS, borderPoint1.y)
browserCanvasContext.arc(borderPoint1.x, borderPoint1.y, BUBBLE_CORNERS_RADIOUS, 1.0 * Math.PI, 1.5 * Math.PI)
browserCanvasContext.lineTo(borderPoint2.x, borderPoint2.y - BUBBLE_CORNERS_RADIOUS)
browserCanvasContext.arc(borderPoint2.x, borderPoint2.y, BUBBLE_CORNERS_RADIOUS, 1.5 * Math.PI, 2.0 * Math.PI)
browserCanvasContext.lineTo(titleBarPoint2.x, titleBarPoint2.y)
browserCanvasContext.closePath();
browserCanvasContext.fill();
browserCanvasContext.closePath()
browserCanvasContext.fill()
browserCanvasContext.lineWidth = 0.1;
browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.RUSTED_RED + ', 0.75)';
browserCanvasContext.stroke();
}
if (pFloatingObject.currentRadius > 0.5) {
browserCanvasContext.lineWidth = 0.1
browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.RUSTED_RED + ', 0.75)'
browserCanvasContext.stroke()
}
if (pFloatingObject.currentRadius > 0.5) {
/* Image */
let imagePosition = {
x: pFloatingObject.currentPosition.x,
y: pFloatingObject.currentPosition.y + BUBBLE_HEIGHT / 2
};
let imagePosition = {
x: pFloatingObject.currentPosition.x,
y: pFloatingObject.currentPosition.y + BUBBLE_HEIGHT / 2
}
if (pFloatingObject.payloadImageId !== undefined) {
if (pFloatingObject.payloadImageId !== undefined) {
let image = document.getElementById(pFloatingObject.payloadImageId)
let image = document.getElementById(pFloatingObject.payloadImageId);
if (image !== null) {
browserCanvasContext.drawImage(image, imagePosition.x - pFloatingObject.currentImageSize / 2, imagePosition.y - pFloatingObject.currentImageSize / 2, pFloatingObject.currentImageSize, pFloatingObject.currentImageSize);
}
}
if (image !== null) {
browserCanvasContext.drawImage(image, imagePosition.x - pFloatingObject.currentImageSize / 2, imagePosition.y - pFloatingObject.currentImageSize / 2, pFloatingObject.currentImageSize, pFloatingObject.currentImageSize)
}
}
/* Image Contourn */
browserCanvasContext.beginPath();
browserCanvasContext.arc(imagePosition.x, imagePosition.y, pFloatingObject.currentImageSize / 2, 0, Math.PI * 2, true);
browserCanvasContext.closePath();
browserCanvasContext.strokeStyle = 'rgba(30, 30, 30, 0.25)';
browserCanvasContext.lineWidth = 1;
browserCanvasContext.stroke();
browserCanvasContext.beginPath()
browserCanvasContext.arc(imagePosition.x, imagePosition.y, pFloatingObject.currentImageSize / 2, 0, Math.PI * 2, true)
browserCanvasContext.closePath()
browserCanvasContext.strokeStyle = 'rgba(30, 30, 30, 0.25)'
browserCanvasContext.lineWidth = 1
browserCanvasContext.stroke()
/* Labels */
if (pFloatingObject.currentRadius > 6) {
if (pFloatingObject.currentRadius > 6) {
browserCanvasContext.strokeStyle = pFloatingObject.labelStrokeStyle
browserCanvasContext.strokeStyle = pFloatingObject.labelStrokeStyle;
const SIZE_PERCENTAGE = Math.trunc(pFloatingObject.currentRadius / pFloatingObject.targetRadius * 100) / 100
let ALPHA
const SIZE_PERCENTAGE = Math.trunc(pFloatingObject.currentRadius / pFloatingObject.targetRadius * 100) / 100;
let ALPHA;
if (pFloatingObject.targetRadius > 0) {
ALPHA = 0.5 - (1 - SIZE_PERCENTAGE) * 5
} else {
// Object is dying...
if (pFloatingObject.targetRadius > 0) {
ALPHA = Math.trunc((0.5 - (100 - pFloatingObject.currentRadius / 100)) * 100) / 100
ALPHA = 0.5 - (1 - SIZE_PERCENTAGE) * 5;
if (ALPHA < 0) { ALPHA = 0 }
}
} else { // Object is dying...
let labelPoint
let fontSize = 10
ALPHA = Math.trunc((0.5 - (100 - pFloatingObject.currentRadius / 100) ) * 100) / 100;
if (ALPHA < 0) { ALPHA = 0}
}
let labelPoint;
let fontSize = 10;
let label;
let label
/* print the title */
label = pFloatingObject.payload.notes[pFloatingObject.payloadNoteIndex].title;
label = pFloatingObject.payload.notes[pFloatingObject.payloadNoteIndex].title
if (label !== undefined) {
if (label !== undefined) {
if (SIZE_PERCENTAGE > 0.9) {
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY
if (SIZE_PERCENTAGE > 0.9) {
let xOffset = label.length / 2 * fontSize * FONT_ASPECT_RATIO
let yOffset = (TITLE_BAR_HEIGHT - fontSize) / 2 + 2
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY;
labelPoint = {
x: intialDisplace.x + BUBBLE_WIDTH / 2 - xOffset,
y: intialDisplace.y + TITLE_BAR_HEIGHT - yOffset
}
let xOffset = label.length / 2 * fontSize * FONT_ASPECT_RATIO;
let yOffset = (TITLE_BAR_HEIGHT - fontSize) / 2 + 2;
labelPoint = {
x: intialDisplace.x + BUBBLE_WIDTH / 2 - xOffset,
y: intialDisplace.y + TITLE_BAR_HEIGHT - yOffset
};
browserCanvasContext.fillStyle = 'rgba(30, 30, 30, ' + ALPHA + ')'
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y);
}
}
browserCanvasContext.fillStyle = 'rgba(30, 30, 30, ' + ALPHA + ')'
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y)
}
}
/* Message Body */
label = pFloatingObject.payload.notes[pFloatingObject.payloadNoteIndex].body;
label = pFloatingObject.payload.notes[pFloatingObject.payloadNoteIndex].body
if (label !== undefined) {
if (label !== undefined) {
const WORDS_PER_ROW = 5
const TOTAL_ROWS = 5
const WORDS_PER_ROW = 5;
const TOTAL_ROWS = 5;
if (SIZE_PERCENTAGE > 0.9) {
let rawLabelArray = label.split(" ");
let labelArray = [];
if (SIZE_PERCENTAGE > 0.9) {
let rawLabelArray = label.split(' ')
let labelArray = []
/* Lets check when words are to long we add an empty space to the same line so as to roll all other words forward. */
for (let i = 0; i < rawLabelArray.length; i++) {
for (let i = 0; i < rawLabelArray.length; i++) {
let word = rawLabelArray[i]
let word = rawLabelArray[i];
labelArray.push(word)
labelArray.push(word);
if (word.length > 8) {
labelArray.push('')
}
if (word.length > 8) {
labelArray.push("");
}
if (word.length > 10) {
labelArray.push("");
}
}
if (word.length > 10) {
labelArray.push('')
}
}
/* Calculate each ROW */
let labelRows = [];
let labelRows = []
for (let i = 0; i < TOTAL_ROWS; i++) {
for (let i = 0; i < TOTAL_ROWS; i++) {
let labelRow = ''
let labelRow = "";
for (let j = 0; j < WORDS_PER_ROW; j++) {
let newWord = labelArray[j + i * WORDS_PER_ROW]
for (let j = 0; j < WORDS_PER_ROW; j++) {
if (newWord !== undefined && newWord !== '') {
labelRow = labelRow + ' ' + newWord
}
}
let newWord = labelArray[j + i * WORDS_PER_ROW];
if (newWord !== undefined && newWord !== "") {
labelRow = labelRow + " " + newWord;
}
}
if (labelRow !== "") {
labelRows.push(labelRow);
}
}
if (labelRow !== '') {
labelRows.push(labelRow)
}
}
/* Now we plot each row. */
for (let i = 0; i < labelRows.length; i++) {
for (let i = 0; i < labelRows.length; i++) {
let labelRow = labelRows[i]
let labelRow = labelRows[i];
let startingPosition = {
x: pFloatingObject.currentPosition.x,
y: pFloatingObject.currentPosition.y - labelRows.length / 2 * (fontSize * FONT_ASPECT_RATIO + 10)
}
let startingPosition = {
x: pFloatingObject.currentPosition.x,
y: pFloatingObject.currentPosition.y - labelRows.length / 2 * (fontSize * FONT_ASPECT_RATIO + 10)
};
labelPoint = {
x: startingPosition.x - labelRow.length / 2 * fontSize * FONT_ASPECT_RATIO,
y: startingPosition.y + (i + 1) * (fontSize * FONT_ASPECT_RATIO + 10)
}
labelPoint = {
x: startingPosition.x - labelRow.length / 2 * fontSize * FONT_ASPECT_RATIO,
y: startingPosition.y + (i + 1) * (fontSize * FONT_ASPECT_RATIO + 10)
};
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY;
browserCanvasContext.fillStyle = 'rgba(60, 60, 60, ' + ALPHA + ')'
browserCanvasContext.fillText(labelRow, labelPoint.x, labelPoint.y);
}
}
}
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY
browserCanvasContext.fillStyle = 'rgba(60, 60, 60, ' + ALPHA + ')'
browserCanvasContext.fillText(labelRow, labelPoint.x, labelPoint.y)
}
}
}
}
}
}
}
FloatingSpace/NoteSets.js
+186 -222
View File
@@ -1,6 +1,5 @@
function newNoteSets() {

function newNoteSets () {
/*
Different plotters will identify sets of notes whithin the data they are plotting. They will create with them arrays of Notes data.
On the other hand the floating space, and a floting layer in particular, manages Notes floating objects, which are visible entities
@@ -14,48 +13,43 @@ function newNoteSets() {
This module is capable of managing an array of NoteSets.
*/
const MODULE_NAME = "Note Sets";
const INFO_LOG = false;
const INFO_WARN = true;
const ERROR_LOG = true;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
const MODULE_NAME = 'Note Sets'
const INFO_LOG = false
const INFO_WARN = true
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
let thisObject = {
createNoteSet: createNoteSet,
destroyNoteSet: destroyNoteSet,
initialize: initialize
};
let thisObject = {
createNoteSet: createNoteSet,
destroyNoteSet: destroyNoteSet,
initialize: initialize
}
let noteSets = [];
let floatingLayer;
let noteSets = []
let floatingLayer
return thisObject;
function initialize(pFloatingLayer, callBackFunction) {
return thisObject
function initialize (pFloatingLayer, callBackFunction) {
/*
During the initialization process, we receive the floatingLayer where all the floatingObjects we will be creating here will live at.
*/
try {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
floatingLayer = pFloatingLayer
floatingLayer = pFloatingLayer;
callBackFunction(GLOBAL.CUSTOM_OK_RESPONSE);
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
callBackFunction(GLOBAL.CUSTOM_OK_RESPONSE)
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function createNoteSet(pPayload, pEventHandler, callBackFunction) {
try {
function createNoteSet (pPayload, pEventHandler, callBackFunction) {
try {
/*
During the creating of a NoteSet, no floating objects are created yet. What we do here is to create the data structure which will allocate
the Notes floating objects, once we receive the array of notes raw data from the plotter. This array will come as an event raised by the
@@ -63,41 +57,39 @@ function newNoteSets() {
position the user gives to the viewport, but also, the plotter can be receiving actually new notes from its datasource.
*/
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> Entering function."); }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> Entering function.') }
let noteSet = {
imageId: pPayload.profile.imageId,
floatingNotes: [],
payload: pPayload,
handle: Math.floor((Math.random() * 10000000) + 1)
};
let noteSet = {
imageId: pPayload.profile.imageId,
floatingNotes: [],
payload: pPayload,
handle: Math.floor((Math.random() * 10000000) + 1)
}
noteSets.push(noteSet);
noteSets.push(noteSet)
pEventHandler.listenToEvent("Notes Changed", onNotesChanged, noteSets.length - 1)
pEventHandler.listenToEvent('Notes Changed', onNotesChanged, noteSets.length - 1)
callBackFunction(GLOBAL.CUSTOM_OK_RESPONSE, noteSet.handle);
callBackFunction(GLOBAL.CUSTOM_OK_RESPONSE, noteSet.handle)
function onNotesChanged(pNewNotes, pNoteSetIndex) {
function onNotesChanged (pNewNotes, pNoteSetIndex) {
try {
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> pNewNotes.length = ' + pNewNotes.length) }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> pNoteSetIndex = ' + pNoteSetIndex) }
try {
let noteSet = noteSets[pNoteSetIndex]
let found = false
let newFloatingNotes
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> pNewNotes.length = " + pNewNotes.length); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> pNoteSetIndex = " + pNoteSetIndex); }
let noteSet = noteSets[pNoteSetIndex];
let found = false;
let newFloatingNotes;
/*
/*
First we remove the old notes. This means that we are going to scan all the floating objects that we have, and see one by one if they
are still present on the raw data sent by the plotter. If it is not there, that means that the floating object must be discarded.
*/
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes."); }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes.') }
newFloatingNotes = []; // We will create a new array of Floating Notes as a result of this operation.
newFloatingNotes = [] // We will create a new array of Floating Notes as a result of this operation.
/*
Here we scan the curren array of floating objects. We use the date + rate to create a unique key for each one, in order to be able to
@@ -105,171 +97,156 @@ function newNoteSets() {
that are still at the raw data array to a new array, and not adding the ones that are not.
*/
for (let j = 0; j < noteSet.floatingNotes.length; j++) {
for (let j = 0; j < noteSet.floatingNotes.length; j++) {
found = false
found = false;
let floatingNote = noteSet.floatingNotes[j]
let floatingNoteKey = floatingNote.date.toString() + floatingNote.rate.toString()
let floatingNote = noteSet.floatingNotes[j];
let floatingNoteKey = floatingNote.date.toString() + floatingNote.rate.toString();
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> j = ' + j) }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> j = " + j); }
let i
let i;
for (i = 0; i < pNewNotes.length; i++) {
let plotterNote = pNewNotes[i]
let plotterNoteKey = plotterNote.date.toString() + plotterNote.rate.toString()
for (i = 0; i < pNewNotes.length; i++) {
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> i = ' + i) }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingNoteKey = ' + floatingNoteKey) }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> plotterNoteKey = ' + plotterNoteKey) }
let plotterNote = pNewNotes[i];
let plotterNoteKey = plotterNote.date.toString() + plotterNote.rate.toString();
if (plotterNoteKey === floatingNoteKey) {
found = true
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> i = " + i); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingNoteKey = " + floatingNoteKey); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> plotterNoteKey = " + plotterNoteKey); }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> found = ' + found) }
break
}
}
if (plotterNoteKey === floatingNoteKey) {
found = true;
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> found = " + found); }
break;
}
}
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> End of For i."); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> found = " + found); }
if (found === false) {
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> End of For i.') }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> found = ' + found) }
if (found === false) {
/*
Each time we identify a floatingObject that is not at the raw data anymore, we request the floatinglayer to kill it.
*/
floatingLayer.killFloatingObject(floatingNote.floatingHandle, onObjectKilled);
floatingLayer.killFloatingObject(floatingNote.floatingHandle, onObjectKilled)
function onObjectKilled(err) {
function onObjectKilled (err) {
if (err.result !== GLOBAL.DEFAULT_OK_RESPONSE.result) {
if (ERROR_LOG === true) { logger.write('[ERROR] createNoteSet -> onNotesChanged -> Remove old Notes -> Floating Object Not Found.') }
if (ERROR_LOG === true) { logger.write('[ERROR] createNoteSet -> onNotesChanged -> Remove old Notes -> Floating Object cannot be killed.') }
if (ERROR_LOG === true) { logger.write('[ERROR] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingNote.floatingHandle = ' + floatingNote.floatingHandle) }
return
}
if (err.result !== GLOBAL.DEFAULT_OK_RESPONSE.result) {
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingNote.floatingHandle = ' + floatingNote.floatingHandle) }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> Removed from Layer.') }
}
} else {
newFloatingNotes.push(floatingNote)
if (ERROR_LOG === true) { logger.write("[ERROR] createNoteSet -> onNotesChanged -> Remove old Notes -> Floating Object Not Found."); }
if (ERROR_LOG === true) { logger.write("[ERROR] createNoteSet -> onNotesChanged -> Remove old Notes -> Floating Object cannot be killed."); }
if (ERROR_LOG === true) { logger.write("[ERROR] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingNote.floatingHandle = " + floatingNote.floatingHandle); }
return;
}
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingNote.floatingHandle = " + floatingNote.floatingHandle); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> Removed from Layer."); }
}
} else {
newFloatingNotes.push(floatingNote);
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingNote.floatingHandle = " + floatingNote.floatingHandle); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> Added to newFloatingNotes."); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> newFloatingNotes.length = " + newFloatingNotes.length); }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingNote.floatingHandle = ' + floatingNote.floatingHandle) }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> Added to newFloatingNotes.') }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> newFloatingNotes.length = ' + newFloatingNotes.length) }
/*
We set a property at each floatingObject of which is the index of the note at the raw data array, so that it can later evaluate its position or its visibility.
*/
let floatingObject = floatingLayer.getFloatingObject(floatingNote.floatingHandle);
floatingObject.payloadNoteIndex = i;
let floatingObject = floatingLayer.getFloatingObject(floatingNote.floatingHandle)
floatingObject.payloadNoteIndex = i
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingObject index updated."); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingObject.payloadNoteIndex = " + i); }
}
}
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingObject index updated.') }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> floatingObject.payloadNoteIndex = ' + i) }
}
}
/*
We replace the current array, with the new one that only contains the surviving floating objects, meaning the ones that are still at the raw data received.
*/
noteSet.floatingNotes = newFloatingNotes;
noteSet.floatingNotes = newFloatingNotes
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> noteSet.floatingNotes.length = " + noteSet.floatingNotes.length); }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Remove old Notes -> noteSet.floatingNotes.length = ' + noteSet.floatingNotes.length) }
/*
/*
Second we add the new notes. There might be new notes at the raw data received that we didnt have before at the NodeSet array. To figure out which
ones are, we need to scan the raw data array and compare each element with the ones of the NodeSet array. Whenever we find one that is not there,
we add it.
*/
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes."); }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes.') }
newFloatingNotes = []; // We will create a new array of Floating Notes as a result of this operation.
newFloatingNotes = [] // We will create a new array of Floating Notes as a result of this operation.
/*
We are using the date and rate as a unique key to identify each note. To prevent the cases of duplicate keys, we will check that at
least to consecutive records dont have the same key, and if they do, will ignore the second one.
*/
let lastPlotterKey = "";
let lastPlotterKey = ''
for (let i = 0; i < pNewNotes.length; i++) {
for (let i = 0; i < pNewNotes.length; i++) {
found = false
found = false;
let plotterNote = pNewNotes[i]
let plotterNoteKey = plotterNote.date.toString() + plotterNote.rate.toString()
let floatingNote
let floatingNoteKey
let plotterNote = pNewNotes[i];
let plotterNoteKey = plotterNote.date.toString() + plotterNote.rate.toString();
let floatingNote;
let floatingNoteKey;
if (lastPlotterKey === plotterNoteKey) {
if (INFO_WARN === true) { logger.write('[WARN] createNoteSet -> onNotesChanged -> Add new Notes -> Duplicate record detected. Discarding it.') }
if (INFO_WARN === true) { logger.write('[WARN] createNoteSet -> onNotesChanged -> Add new Notes -> i = ' + i) }
continue
}
if (lastPlotterKey === plotterNoteKey) {
lastPlotterKey = plotterNoteKey
if (INFO_WARN=== true) { logger.write("[WARN] createNoteSet -> onNotesChanged -> Add new Notes -> Duplicate record detected. Discarding it."); }
if (INFO_WARN === true) { logger.write("[WARN] createNoteSet -> onNotesChanged -> Add new Notes -> i = " + i); }
continue;
}
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> i = ' + i) }
lastPlotterKey = plotterNoteKey;
for (let j = 0; j < noteSet.floatingNotes.length; j++) {
floatingNote = noteSet.floatingNotes[j]
floatingNoteKey = floatingNote.date.toString() + floatingNote.rate.toString()
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> i = " + i); }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> j = ' + j) }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> floatingNoteKey = ' + floatingNoteKey) }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> plotterNoteKey = ' + plotterNoteKey) }
for (let j = 0; j < noteSet.floatingNotes.length; j++) {
if (plotterNoteKey === floatingNoteKey) {
found = true
floatingNote = noteSet.floatingNotes[j];
floatingNoteKey = floatingNote.date.toString() + floatingNote.rate.toString();
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> found = ' + found) }
break
}
}
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> j = " + j); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> floatingNoteKey = " + floatingNoteKey); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> plotterNoteKey = " + plotterNoteKey); }
if (plotterNoteKey === floatingNoteKey) {
found = true;
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> found = " + found); }
break;
}
}
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> End of For j."); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> found = " + found); }
if (found === false) {
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> End of For j.') }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> found = ' + found) }
if (found === false) {
/*
Before adding a new item to the array, we need to create a floatingObject of type Note. Once we set its basic parameters
we can it to our array and to the floating layer.
*/
let floatingObject = newFloatingObject();
floatingObject.initialize("Note", onInitialized);
let floatingObject = newFloatingObject()
floatingObject.initialize('Note', onInitialized)
function onInitialized(err) {
function onInitialized (err) {
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> Entering function."); }
floatingObject.payload = noteSet.payload
floatingObject.payloadNoteIndex = i
floatingObject.payloadImageId = noteSet.imageId
floatingObject.payload = noteSet.payload;
floatingObject.payloadNoteIndex = i;
floatingObject.payloadImageId = noteSet.imageId;
floatingObject.friction = 0.995
floatingObject.friction = .995;
floatingObject.initializeMass(200)
floatingObject.initializeMass(200);
//let bodyText = pNewNotes[i].body;
let radius;
// let bodyText = pNewNotes[i].body;
let radius
/*
if (bodyText.length < 100) {
@@ -278,96 +255,83 @@ function newNoteSets() {
radius = bodyText.length;
}
*/
radius = 50;
radius = 50
floatingObject.initializeRadius(radius);
floatingObject.initializeImageSize(15);
floatingObject.initializeRadius(radius)
floatingObject.initializeImageSize(15)
floatingObject.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 0.5)';
floatingObject.labelStrokeStyle = 'rgba(60, 60, 60, 0.50)';
floatingObject.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 0.5)'
floatingObject.labelStrokeStyle = 'rgba(60, 60, 60, 0.50)'
floatingLayer.addFloatingObject(floatingObject);
floatingLayer.addFloatingObject(floatingObject)
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> New Note added to Layer."); }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> New Note added to Layer.') }
plotterNote.floatingHandle = floatingObject.handle;
plotterNote.floatingHandle = floatingObject.handle
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> plotterNote.floatingHandle = " + plotterNote.floatingHandle); }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> plotterNote.floatingHandle = ' + plotterNote.floatingHandle) }
newFloatingNotes.push(plotterNote);
newFloatingNotes.push(plotterNote)
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> Added to newFloatingNotes."); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> newFloatingNotes.length = " + newFloatingNotes.length); }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> Added to newFloatingNotes.') }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> newFloatingNotes.length = ' + newFloatingNotes.length) }
}
} else {
newFloatingNotes.push(floatingNote)
}
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> Old Note Kept.') }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> floatingNote.floatingHandle = ' + floatingNote.floatingHandle) }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> Added to newFloatingNotes.') }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> newFloatingNotes.length = ' + newFloatingNotes.length) }
} else {
let floatingObject = floatingLayer.getFloatingObject(floatingNote.floatingHandle)
floatingObject.payloadNoteIndex = i
newFloatingNotes.push(floatingNote);
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> Old Note Kept."); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> floatingNote.floatingHandle = " + floatingNote.floatingHandle); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> Added to newFloatingNotes."); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> newFloatingNotes.length = " + newFloatingNotes.length); }
let floatingObject = floatingLayer.getFloatingObject(floatingNote.floatingHandle);
floatingObject.payloadNoteIndex = i;
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> floatingObject index updated."); }
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> floatingObject.payloadNoteIndex = " + i); }
}
}
noteSet.floatingNotes = newFloatingNotes;
if (INFO_LOG === true) { logger.write("[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> noteSet.floatingNotes.length = " + noteSet.floatingNotes.length); }
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] createNoteSet -> onNotesChanged -> err = " + err); }
}
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> floatingObject index updated.') }
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> onInitialized -> floatingObject.payloadNoteIndex = ' + i) }
}
}
noteSet.floatingNotes = newFloatingNotes
if (INFO_LOG === true) { logger.write('[INFO] createNoteSet -> onNotesChanged -> Add new Notes -> noteSet.floatingNotes.length = ' + noteSet.floatingNotes.length) }
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] createNoteSet -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
if (ERROR_LOG === true) { logger.write('[ERROR] createNoteSet -> onNotesChanged -> err = ' + err) }
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] createNoteSet -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function destroyNoteSet(pHandle) {
try {
function destroyNoteSet (pHandle) {
try {
/*
Usually when a bot is disabled by the end user, or the zoom level changes to one where the notes must not be seen, this method
to destroy an entire NoteSet is executed. What we do in this situation is to localize the NoteSet to be destroyed and we need to
kill, one by one the floating objects in it. Finally we remove this NoteSet item from the NoteSets array.
*/
if (INFO_LOG === true) { logger.write("[INFO] destroyNoteSet -> Entering function."); }
if (INFO_LOG === true) { logger.write('[INFO] destroyNoteSet -> Entering function.') }
for (let i = 0; i < noteSets.length; i++) {
for (let i = 0; i < noteSets.length; i++) {
let noteSet = noteSets[i]
let noteSet = noteSets[i];
if (noteSet.handle === pHandle) {
for (let j = 0; j < noteSet.floatingNotes.length; j++) {
let floatingNote = noteSet.floatingNotes[j]
if (noteSet.handle === pHandle) {
floatingLayer.killFloatingObject(floatingNote.floatingHandle)
}
for (let j = 0; j < noteSet.floatingNotes.length; j++) {
let floatingNote = noteSet.floatingNotes[j];
floatingLayer.killFloatingObject(floatingNote.floatingHandle);
}
noteSets.splice(i, 1); // Delete item from array.
return;
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] destroyNoteSet -> err = " + err); }
noteSets.splice(i, 1) // Delete item from array.
return
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] destroyNoteSet -> err = ' + err) }
}
}
}
FloatingSpace/ProfileBall.js
-1
View File
@@ -310,4 +310,3 @@ function newProfileBall () {
}
}
}
FloatingSpace/ProfileBalls.js
+53 -52
View File
@@ -1,11 +1,10 @@
function newProfileBalls() {
const MODULE_NAME = "Profile Balls";
const INFO_LOG = false;
const ERROR_LOG = true;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;

function newProfileBalls () {
const MODULE_NAME = 'Profile Balls'
const INFO_LOG = false
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
/*
@@ -13,65 +12,67 @@ function newProfileBalls() {
*/
let thisObject = {
let thisObject = {
createNewProfileBall: createNewProfileBall,
destroyProfileBall: destroyProfileBall,
initialize: initialize
createNewProfileBall: createNewProfileBall,
destroyProfileBall: destroyProfileBall,
initialize: initialize,
finalize: finalize
}
let floatingLayer
return thisObject
function finalize () {
try {
if (INFO_LOG === true) { logger.write('[INFO] finalize -> Entering function.') }
floatingLayer.finalize()
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] finalize -> err = ' + err) }
}
}
let floatingLayer;
function initialize (pFloatingLayer, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
return thisObject;
floatingLayer = pFloatingLayer
function initialize(pFloatingLayer, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
floatingLayer = pFloatingLayer;
callBackFunction(GLOBAL.CUSTOM_OK_RESPONSE);
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
callBackFunction(GLOBAL.CUSTOM_OK_RESPONSE)
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function createNewProfileBall(pPayload, callBackFunction) {
function createNewProfileBall (pPayload, callBackFunction) {
let floatingObject = newFloatingObject()
floatingObject.initialize('Profile Ball', onInitialized)
let floatingObject = newFloatingObject();
floatingObject.initialize("Profile Ball", onInitialized);
function onInitialized (err) {
floatingObject.payload = pPayload
function onInitialized(err) {
floatingObject.friction = 0.995
floatingObject.payload = pPayload;
floatingObject.initializeMass(100)
floatingObject.initializeRadius(30)
floatingObject.initializeImageSize(50)
floatingObject.initializeFontSize(10)
floatingObject.friction = .995;
floatingObject.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 0.5)'
floatingObject.labelStrokeStyle = 'rgba(60, 60, 60, 0.50)'
floatingObject.initializeMass(100);
floatingObject.initializeRadius(30);
floatingObject.initializeImageSize(50);
floatingObject.initializeFontSize(10);
floatingLayer.addFloatingObject(floatingObject)
floatingObject.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 0.5)';
floatingObject.labelStrokeStyle = 'rgba(60, 60, 60, 0.50)';
floatingLayer.addFloatingObject(floatingObject);
callBackFunction(GLOBAL.CUSTOM_OK_RESPONSE, floatingObject.handle);
}
callBackFunction(GLOBAL.CUSTOM_OK_RESPONSE, floatingObject.handle)
}
}
function destroyProfileBall(pFloatingObjectHandle) {
floatingLayer.killFloatingObject(pFloatingObjectHandle);
}
function destroyProfileBall (pFloatingObjectHandle) {
floatingLayer.killFloatingObject(pFloatingObjectHandle)
}
}
Frame.js
+386 -438
View File
@@ -1,130 +1,110 @@
function newFrame() {

function newFrame () {
const PANEL_CORNERS_RADIOUS = 5
const TITLE_BAR_HEIGHT = 14 // this must be grater than radius
const PANEL_CORNERS_RADIOUS = 5;
const TITLE_BAR_HEIGHT = 14; // this must be grater than radius
var frame = {
containerName: '', // This is for debugging purposes only.
parentFrame: undefined, // Here we store the parent cointainer zoom object.
width: browserCanvas.width,
height: browserCanvas.height,
position: undefined,
getBodyHeight: getBodyHeight,
draw: draw,
container: undefined,
frameThisPoint: frameThisPoint, // This function changes the actual frame coordinate system to the screen coordinate system.
unframeThisPoint: unframeThisPoint,
fitIntoFrame: fitIntoFrame,
isThisPointHere: isThisPointHere, // This function return true is the point received as parameter lives within this frame.
isInViewPort: isInViewPort,
canYouMoveHere: canYouMoveHere,
canYouZoomHere: canYouZoomHere,
initialize: initialize
}
var frame = {
containerName: "", // This is for debugging purposes only.
parentFrame: undefined, // Here we store the parent cointainer zoom object.
width: browserCanvas.width,
height: browserCanvas.height,
position: undefined,
getBodyHeight: getBodyHeight,
draw: draw,
container: undefined,
frameThisPoint: frameThisPoint, // This function changes the actual frame coordinate system to the screen coordinate system.
unframeThisPoint: unframeThisPoint,
fitIntoFrame: fitIntoFrame,
isThisPointHere: isThisPointHere, // This function return true is the point received as parameter lives within this frame.
isInViewPort: isInViewPort,
canYouMoveHere: canYouMoveHere,
canYouZoomHere: canYouZoomHere,
initialize: initialize
};
return frame
return frame;
function initialize() {
var position = {
x: 0,
y: 0
};
this.position = position;
function initialize () {
var position = {
x: 0,
y: 0
}
this.position = position
}
function getBodyHeight() {
return frame.height - TITLE_BAR_HEIGHT;
function getBodyHeight () {
return frame.height - TITLE_BAR_HEIGHT
}
function isInViewPort () {
point1 = {
x: 0,
y: 0
}
function isInViewPort() {
point1 = {
x: 0,
y: 0
};
point3 = {
x: frame.width,
y: frame.height
};
point3 = {
x: frame.width,
y: frame.height
}
/* Now the transformations. */
point1 = transformThisPoint(point1, frame.container);
point3 = transformThisPoint(point3, frame.container);
if (point1.x < viewPort.visibleArea.topRight.x && point1.y < viewPort.visibleArea.bottomRight.y && point3.x > viewPort.visibleArea.bottomLeft.x && point3.y > viewPort.visibleArea.topLeft.y ) {
return true;
} else {
return false;
}
point1 = transformThisPoint(point1, frame.container)
point3 = transformThisPoint(point3, frame.container)
if (point1.x < viewPort.visibleArea.topRight.x && point1.y < viewPort.visibleArea.bottomRight.y && point3.x > viewPort.visibleArea.bottomLeft.x && point3.y > viewPort.visibleArea.topLeft.y) {
return true
} else {
return false
}
}
function fitIntoFrame(point) {
function fitIntoFrame (point) {
/* Here we check the boundaries of the resulting points, so they dont go out of the visible area. */
if (point.x > frame.width) {
point.x = frame.width;
}
if (point.x < 0) {
point.x = 0;
}
if (point.y > frame.height) {
point.y = frame.height;
}
if (point.y < 0) {
point.y = 0;
}
return point;
if (point.x > frame.width) {
point.x = frame.width
}
function frameThisPoint(point) {
if (this.parentFrame !== undefined) {
point = this.parentFrame.frameThisPoint(point);
}
point.x = point.x + frame.position.x;
point.y = point.y + frame.position.y;
return point;
if (point.x < 0) {
point.x = 0
}
function unframeThisPoint(point) {
if (this.parentFrame !== undefined) {
point = this.parentFrame.unframeThisPoint(point);
}
point.x = point.x - this.position.x;
point.y = point.y - this.position.y;
return point;
if (point.y > frame.height) {
point.y = frame.height
}
function canYouMoveHere(tempDisplacement) {
if (point.y < 0) {
point.y = 0
}
return point
}
function frameThisPoint (point) {
if (this.parentFrame !== undefined) {
point = this.parentFrame.frameThisPoint(point)
}
point.x = point.x + frame.position.x
point.y = point.y + frame.position.y
return point
}
function unframeThisPoint (point) {
if (this.parentFrame !== undefined) {
point = this.parentFrame.unframeThisPoint(point)
}
point.x = point.x - this.position.x
point.y = point.y - this.position.y
return point
}
function canYouMoveHere (tempDisplacement) {
/*
The current frame has a position and a displacement. We need to check that none of the boundaries points of the frame fall outside of its container frame.
@@ -132,459 +112,427 @@ function newFrame() {
*/
point1 = {
x: this.position.x,
y: this.position.y
};
point1 = {
x: this.position.x,
y: this.position.y
}
point2 = {
x: this.position.x + this.width,
y: this.position.y
};
point2 = {
x: this.position.x + this.width,
y: this.position.y
}
point3 = {
x: this.position.x + this.width,
y: this.position.y + this.height
};
point3 = {
x: this.position.x + this.width,
y: this.position.y + this.height
}
point4 = {
x: this.position.x,
y: this.position.y + this.height
};
point4 = {
x: this.position.x,
y: this.position.y + this.height
}
/* Now the transformations. */
if (this.parentFrame !== undefined) { // If there is not a parent then there is no point to check bounderies.
if (this.parentFrame !== undefined) {
// If there is not a parent then there is no point to check bounderies.
point1 = this.parentFrame.frameThisPoint(point1);
point2 = this.parentFrame.frameThisPoint(point2);
point3 = this.parentFrame.frameThisPoint(point3);
point4 = this.parentFrame.frameThisPoint(point4);
point1 = this.parentFrame.frameThisPoint(point1)
point2 = this.parentFrame.frameThisPoint(point2)
point3 = this.parentFrame.frameThisPoint(point3)
point4 = this.parentFrame.frameThisPoint(point4)
/* We apply the temporary displacement. */
point1 = tempDisplacement.displaceThisPoint(point1);
point2 = tempDisplacement.displaceThisPoint(point2);
point3 = tempDisplacement.displaceThisPoint(point3);
point4 = tempDisplacement.displaceThisPoint(point4);
point1 = tempDisplacement.displaceThisPoint(point1)
point2 = tempDisplacement.displaceThisPoint(point2)
point3 = tempDisplacement.displaceThisPoint(point3)
point4 = tempDisplacement.displaceThisPoint(point4)
/* We add the actual displacement. */
point1 = this.container.displacement.displaceThisPoint(point1);
point2 = this.container.displacement.displaceThisPoint(point2);
point3 = this.container.displacement.displaceThisPoint(point3);
point4 = this.container.displacement.displaceThisPoint(point4);
point1 = this.container.displacement.displaceThisPoint(point1)
point2 = this.container.displacement.displaceThisPoint(point2)
point3 = this.container.displacement.displaceThisPoint(point3)
point4 = this.container.displacement.displaceThisPoint(point4)
if (this.parentFrame.isThisPointHere(point1) === false) {
return false;
}
if (this.parentFrame.isThisPointHere(point1) === false) {
return false
}
if (this.parentFrame.isThisPointHere(point2) === false) {
return false;
}
if (this.parentFrame.isThisPointHere(point2) === false) {
return false
}
if (this.parentFrame.isThisPointHere(point3) === false) {
return false;
}
if (this.parentFrame.isThisPointHere(point3) === false) {
return false
}
if (this.parentFrame.isThisPointHere(point4) === false) {
return false;
}
}
return true;
if (this.parentFrame.isThisPointHere(point4) === false) {
return false
}
}
function canYouZoomHere(tempZoom) {
return true
}
point1 = {
x: this.position.x,
y: this.position.y
};
function canYouZoomHere (tempZoom) {
point1 = {
x: this.position.x,
y: this.position.y
}
point2 = {
x: this.position.x + this.width,
y: this.position.y
};
point2 = {
x: this.position.x + this.width,
y: this.position.y
}
point3 = {
x: this.position.x + this.width,
y: this.position.y + this.height
};
point3 = {
x: this.position.x + this.width,
y: this.position.y + this.height
}
point4 = {
x: this.position.x,
y: this.position.y + this.height
};
point4 = {
x: this.position.x,
y: this.position.y + this.height
}
/* Now the transformations. */
if (this.parentFrame !== undefined) { // If there is not a parent then there is no point to check bounderies.
if (this.parentFrame !== undefined) {
// If there is not a parent then there is no point to check bounderies.
point1 = this.parentFrame.frameThisPoint(point1);
point2 = this.parentFrame.frameThisPoint(point2);
point3 = this.parentFrame.frameThisPoint(point3);
point4 = this.parentFrame.frameThisPoint(point4);
point1 = this.parentFrame.frameThisPoint(point1)
point2 = this.parentFrame.frameThisPoint(point2)
point3 = this.parentFrame.frameThisPoint(point3)
point4 = this.parentFrame.frameThisPoint(point4)
/* We add the actual displacement. */
point1 = this.container.displacement.displaceThisPoint(point1);
point2 = this.container.displacement.displaceThisPoint(point2);
point3 = this.container.displacement.displaceThisPoint(point3);
point4 = this.container.displacement.displaceThisPoint(point4);
point1 = this.container.displacement.displaceThisPoint(point1)
point2 = this.container.displacement.displaceThisPoint(point2)
point3 = this.container.displacement.displaceThisPoint(point3)
point4 = this.container.displacement.displaceThisPoint(point4)
/* We temp zoom. */
point1 = tempZoom.zoomThisPoint(point1);
point2 = tempZoom.zoomThisPoint(point2);
point3 = tempZoom.zoomThisPoint(point3);
point4 = tempZoom.zoomThisPoint(point4);
point1 = tempZoom.zoomThisPoint(point1)
point2 = tempZoom.zoomThisPoint(point2)
point3 = tempZoom.zoomThisPoint(point3)
point4 = tempZoom.zoomThisPoint(point4)
if (this.parentFrame.isThisPointHere(point1) === false) {
return false;
}
if (this.parentFrame.isThisPointHere(point1) === false) {
return false
}
if (this.parentFrame.isThisPointHere(point2) === false) {
return false;
}
if (this.parentFrame.isThisPointHere(point2) === false) {
return false
}
if (this.parentFrame.isThisPointHere(point3) === false) {
return false;
}
if (this.parentFrame.isThisPointHere(point3) === false) {
return false
}
if (this.parentFrame.isThisPointHere(point4) === false) {
return false;
}
}
return true;
if (this.parentFrame.isThisPointHere(point4) === false) {
return false
}
}
return true
}
function isThisPointHere(point, outsideViewPort) { // The second parameter is usefull when you want to check a point that you already know is outside the viewport.
function isThisPointHere (point, outsideViewPort) {
// The second parameter is usefull when you want to check a point that you already know is outside the viewport.
/* We need not to modify the point received, so me make a copy of it. */
var checkPoint = {
x: point.x,
y: point.y
};
var checkPoint = {
x: point.x,
y: point.y
}
/* The point received is on the screen coordinates system, which already has zoom and displacement applied. We need to remove the zoom and displacement
in order to have the point on the containers coordinate system and be able to compare it with its dimmensions. */
if (outsideViewPort === true) {
checkPoint = this.container.displacement.undisplaceThisPoint(checkPoint);
checkPoint = this.container.frame.unframeThisPoint(checkPoint);
} else {
checkPoint = unTransformThisPoint(checkPoint, frame.container);
}
if (outsideViewPort === true) {
checkPoint = this.container.displacement.undisplaceThisPoint(checkPoint)
checkPoint = this.container.frame.unframeThisPoint(checkPoint)
} else {
checkPoint = unTransformThisPoint(checkPoint, frame.container)
}
/* Now we check if the resulting point is whin the current Frame. */
if (checkPoint.x < 0 || checkPoint.y < 0 || checkPoint.x > frame.width || checkPoint.y > frame.height) {
if (checkPoint.x < 0 || checkPoint.y < 0 || checkPoint.x > frame.width || checkPoint.y > frame.height) {
/* The point received is not in this frame */
return false;
} else {
return false
} else {
/* The point is within this frame. */
return true;
}
return true
}
}
function draw (drawGrid, drawBorders, drawBackground) {
if (drawBorders === true) {
borders()
}
function draw(drawGrid, drawBorders, drawBackground) {
if (drawBorders === true) {
borders();
}
if (drawGrid === true) {
grid();
}
if (drawBackground === true) {
background();
}
if (drawGrid === true) {
grid()
}
function background() {
if (drawBackground === true) {
background()
}
}
function background () {
borderPoint1 = {
x: PANEL_CORNERS_RADIOUS,
y: PANEL_CORNERS_RADIOUS
}
borderPoint2 = {
x: frame.width - PANEL_CORNERS_RADIOUS,
y: PANEL_CORNERS_RADIOUS
}
borderPoint1 = {
x: PANEL_CORNERS_RADIOUS,
y: PANEL_CORNERS_RADIOUS
};
borderPoint3 = {
x: frame.width - PANEL_CORNERS_RADIOUS,
y: frame.height - PANEL_CORNERS_RADIOUS
}
borderPoint2 = {
x: frame.width - PANEL_CORNERS_RADIOUS,
y: PANEL_CORNERS_RADIOUS
};
borderPoint4 = {
x: PANEL_CORNERS_RADIOUS,
y: frame.height - PANEL_CORNERS_RADIOUS
}
borderPoint3 = {
x: frame.width - PANEL_CORNERS_RADIOUS,
y: frame.height - PANEL_CORNERS_RADIOUS
};
borderPoint4 = {
x: PANEL_CORNERS_RADIOUS,
y: frame.height - PANEL_CORNERS_RADIOUS
};
titleBarPoint1 = {
x: 0,
y: TITLE_BAR_HEIGHT
};
titleBarPoint2 = {
x: frame.width,
y: TITLE_BAR_HEIGHT
};
titleBarPoint1 = {
x: 0,
y: TITLE_BAR_HEIGHT
}
titleBarPoint2 = {
x: frame.width,
y: TITLE_BAR_HEIGHT
}
/* Now the transformations. */
borderPoint1 = frameThisPoint(borderPoint1);
borderPoint2 = frameThisPoint(borderPoint2);
borderPoint3 = frameThisPoint(borderPoint3);
borderPoint4 = frameThisPoint(borderPoint4);
borderPoint1 = frameThisPoint(borderPoint1)
borderPoint2 = frameThisPoint(borderPoint2)
borderPoint3 = frameThisPoint(borderPoint3)
borderPoint4 = frameThisPoint(borderPoint4)
titleBarPoint1 = frameThisPoint(titleBarPoint1);
titleBarPoint2 = frameThisPoint(titleBarPoint2);
titleBarPoint1 = frameThisPoint(titleBarPoint1)
titleBarPoint2 = frameThisPoint(titleBarPoint2)
/* We paint the panel background first */
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 0.75)';
browserCanvasContext.beginPath();
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 0.75)'
browserCanvasContext.beginPath()
browserCanvasContext.arc(borderPoint1.x, borderPoint1.y, PANEL_CORNERS_RADIOUS, 1.0 * Math.PI, 1.5 * Math.PI);
browserCanvasContext.lineTo(borderPoint2.x, borderPoint2.y - PANEL_CORNERS_RADIOUS);
browserCanvasContext.arc(borderPoint2.x, borderPoint2.y, PANEL_CORNERS_RADIOUS, 1.5 * Math.PI, 2.0 * Math.PI);
browserCanvasContext.lineTo(borderPoint3.x + PANEL_CORNERS_RADIOUS, borderPoint3.y);
browserCanvasContext.arc(borderPoint3.x, borderPoint3.y, PANEL_CORNERS_RADIOUS, 0 * Math.PI, 0.5 * Math.PI);
browserCanvasContext.lineTo(borderPoint4.x, borderPoint4.y + PANEL_CORNERS_RADIOUS);
browserCanvasContext.arc(borderPoint4.x, borderPoint4.y, PANEL_CORNERS_RADIOUS, 0.5 * Math.PI, 1.0 * Math.PI);
browserCanvasContext.lineTo(borderPoint1.x - PANEL_CORNERS_RADIOUS, borderPoint1.y);
browserCanvasContext.arc(borderPoint1.x, borderPoint1.y, PANEL_CORNERS_RADIOUS, 1.0 * Math.PI, 1.5 * Math.PI)
browserCanvasContext.lineTo(borderPoint2.x, borderPoint2.y - PANEL_CORNERS_RADIOUS)
browserCanvasContext.arc(borderPoint2.x, borderPoint2.y, PANEL_CORNERS_RADIOUS, 1.5 * Math.PI, 2.0 * Math.PI)
browserCanvasContext.lineTo(borderPoint3.x + PANEL_CORNERS_RADIOUS, borderPoint3.y)
browserCanvasContext.arc(borderPoint3.x, borderPoint3.y, PANEL_CORNERS_RADIOUS, 0 * Math.PI, 0.5 * Math.PI)
browserCanvasContext.lineTo(borderPoint4.x, borderPoint4.y + PANEL_CORNERS_RADIOUS)
browserCanvasContext.arc(borderPoint4.x, borderPoint4.y, PANEL_CORNERS_RADIOUS, 0.5 * Math.PI, 1.0 * Math.PI)
browserCanvasContext.lineTo(borderPoint1.x - PANEL_CORNERS_RADIOUS, borderPoint1.y)
browserCanvasContext.closePath();
browserCanvasContext.closePath()
browserCanvasContext.fill();
browserCanvasContext.fill()
browserCanvasContext.lineWidth = 0.1;
browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.MANGANESE_PURPLE + ', 0.75)';
browserCanvasContext.stroke();
browserCanvasContext.lineWidth = 0.1
browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.MANGANESE_PURPLE + ', 0.75)'
browserCanvasContext.stroke()
/* We paint the title bar now */
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.DARK + ', 0.75)';
browserCanvasContext.beginPath();
browserCanvasContext.moveTo(titleBarPoint1.x, titleBarPoint1.y);
browserCanvasContext.lineTo(borderPoint1.x - PANEL_CORNERS_RADIOUS, borderPoint1.y);
browserCanvasContext.arc(borderPoint1.x, borderPoint1.y, PANEL_CORNERS_RADIOUS, 1.0 * Math.PI, 1.5 * Math.PI);
browserCanvasContext.lineTo(borderPoint2.x, borderPoint2.y - PANEL_CORNERS_RADIOUS);
browserCanvasContext.arc(borderPoint2.x, borderPoint2.y, PANEL_CORNERS_RADIOUS, 1.5 * Math.PI, 2.0 * Math.PI);
browserCanvasContext.lineTo(titleBarPoint2.x, titleBarPoint2.y);
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.DARK + ', 0.75)'
browserCanvasContext.beginPath()
browserCanvasContext.closePath();
browserCanvasContext.fill();
browserCanvasContext.lineWidth = 0.1;
browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.MANGANESE_PURPLE + ', 0.75)';
browserCanvasContext.stroke();
browserCanvasContext.moveTo(titleBarPoint1.x, titleBarPoint1.y)
browserCanvasContext.lineTo(borderPoint1.x - PANEL_CORNERS_RADIOUS, borderPoint1.y)
browserCanvasContext.arc(borderPoint1.x, borderPoint1.y, PANEL_CORNERS_RADIOUS, 1.0 * Math.PI, 1.5 * Math.PI)
browserCanvasContext.lineTo(borderPoint2.x, borderPoint2.y - PANEL_CORNERS_RADIOUS)
browserCanvasContext.arc(borderPoint2.x, borderPoint2.y, PANEL_CORNERS_RADIOUS, 1.5 * Math.PI, 2.0 * Math.PI)
browserCanvasContext.lineTo(titleBarPoint2.x, titleBarPoint2.y)
browserCanvasContext.closePath()
browserCanvasContext.fill()
browserCanvasContext.lineWidth = 0.1
browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.MANGANESE_PURPLE + ', 0.75)'
browserCanvasContext.stroke()
/* print the title */
let labelPoint;
let fontSize = 10;
let labelPoint
let fontSize = 10
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY;
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY
let label = frame.containerName;
let label = frame.containerName
let xOffset = label.length / 2 * fontSize * FONT_ASPECT_RATIO;
let yOffset = (TITLE_BAR_HEIGHT - fontSize) / 2 + 2;
let xOffset = label.length / 2 * fontSize * FONT_ASPECT_RATIO
let yOffset = (TITLE_BAR_HEIGHT - fontSize) / 2 + 2
labelPoint = {
x: frame.width / 2 - xOffset,
y: TITLE_BAR_HEIGHT - yOffset
};
labelPoint = frame.frameThisPoint(labelPoint);
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 1)';
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y);
labelPoint = {
x: frame.width / 2 - xOffset,
y: TITLE_BAR_HEIGHT - yOffset
}
labelPoint = frame.frameThisPoint(labelPoint)
function borders() {
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 1)'
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y)
}
function borders () {
/* Lest get the important points of the drawing so as to apply the needed transformations. */
point1 = {
x: 0,
y: 0
};
point1 = {
x: 0,
y: 0
}
point2 = {
x: frame.width,
y: 0
};
point2 = {
x: frame.width,
y: 0
}
point3 = {
x: frame.width,
y: frame.height
};
point3 = {
x: frame.width,
y: frame.height
}
point4 = {
x: 0,
y: frame.height
};
point4 = {
x: 0,
y: frame.height
}
/* Now the transformations. */
point1 = transformThisPoint(point1, frame.container);
point2 = transformThisPoint(point2, frame.container);
point3 = transformThisPoint(point3, frame.container);
point4 = transformThisPoint(point4, frame.container);
point1 = transformThisPoint(point1, frame.container)
point2 = transformThisPoint(point2, frame.container)
point3 = transformThisPoint(point3, frame.container)
point4 = transformThisPoint(point4, frame.container)
/* Lets start the drawing. */
browserCanvasContext.beginPath();
browserCanvasContext.moveTo(point1.x, point1.y);
browserCanvasContext.lineTo(point2.x, point2.y);
browserCanvasContext.lineTo(point3.x, point3.y);
browserCanvasContext.lineTo(point4.x, point4.y);
browserCanvasContext.lineTo(point1.x, point1.y);
browserCanvasContext.closePath();
browserCanvasContext.beginPath()
browserCanvasContext.moveTo(point1.x, point1.y)
browserCanvasContext.lineTo(point2.x, point2.y)
browserCanvasContext.lineTo(point3.x, point3.y)
browserCanvasContext.lineTo(point4.x, point4.y)
browserCanvasContext.lineTo(point1.x, point1.y)
browserCanvasContext.closePath()
browserCanvasContext.strokeStyle = 'rgba(150, 150, 150, 1)'
browserCanvasContext.lineWidth = 1
browserCanvasContext.stroke()
browserCanvasContext.strokeStyle = 'rgba(150, 150, 150, 1)';
browserCanvasContext.lineWidth = 1;
browserCanvasContext.stroke();
browserCanvasContext.closePath();
}
function grid(smallLines) {
if (smallLines === true) {
browserCanvasContext.closePath()
}
function grid (smallLines) {
if (smallLines === true) {
/* Small Lines */
var step = frame.width / 100;
var step = frame.width / 100
browserCanvasContext.beginPath();
browserCanvasContext.beginPath()
for (var i = 0; i < frame.width; i = i + step) {
for (var i = 0; i < frame.width; i = i + step) {
for (var j = 0; j < frame.height; j = j + step) {
let point1 = {
x: 0,
y: j
}
for (var j = 0; j < frame.height; j = j + step) {
let point2 = {
x: frame.width,
y: j
}
let point1 = {
x: 0,
y: j
};
point1 = transformThisPoint(point1, frame.container)
point2 = transformThisPoint(point2, frame.container)
let point2 = {
x: frame.width,
y: j
};
point1 = transformThisPoint(point1, frame.container);
point2 = transformThisPoint(point2, frame.container);
browserCanvasContext.moveTo(point1.x, point1.y);
browserCanvasContext.lineTo(point2.x, point2.y);
}
let point3 = {
x: frame.width,
y: frame.height
};
let point4 = {
x: 0,
y: frame.height
};
point3 = transformThisPoint(point3, frame.container);
point4 = transformThisPoint(point4, frame.container);
browserCanvasContext.moveTo(point3.x, point3.y);
browserCanvasContext.lineTo(point4.x, point4.y);
}
browserCanvasContext.closePath();
browserCanvasContext.strokeStyle = 'rgba(150, 150, 150, 0.1)';
browserCanvasContext.lineWidth = 1;
browserCanvasContext.stroke();
browserCanvasContext.moveTo(point1.x, point1.y)
browserCanvasContext.lineTo(point2.x, point2.y)
}
let point3 = {
x: frame.width,
y: frame.height
}
let point4 = {
x: 0,
y: frame.height
}
point3 = transformThisPoint(point3, frame.container)
point4 = transformThisPoint(point4, frame.container)
browserCanvasContext.moveTo(point3.x, point3.y)
browserCanvasContext.lineTo(point4.x, point4.y)
}
browserCanvasContext.closePath()
browserCanvasContext.strokeStyle = 'rgba(150, 150, 150, 0.1)'
browserCanvasContext.lineWidth = 1
browserCanvasContext.stroke()
}
/* Main Lines */
var step = frame.width / 20;
var step = frame.width / 20
browserCanvasContext.beginPath();
browserCanvasContext.beginPath()
for (var i = 0; i < frame.width; i = i + step) {
for (var j = 0; j < frame.height; j = j + step) {
let point1 = {
x: 0,
y: j
};
let point2 = {
x: frame.width,
y: j
};
point1 = transformThisPoint(point1, frame.container);
point2 = transformThisPoint(point2, frame.container);
browserCanvasContext.moveTo(point1.x, point1.y);
browserCanvasContext.lineTo(point2.x, point2.y);
}
let point3 = {
x: i,
y: 0
};
let point4 = {
x: i,
y: frame.height
};
point3 = transformThisPoint(point3, frame.container);
point4 = transformThisPoint(point4, frame.container);
browserCanvasContext.moveTo(point3.x, point3.y);
browserCanvasContext.lineTo(point4.x, point4.y);
for (var i = 0; i < frame.width; i = i + step) {
for (var j = 0; j < frame.height; j = j + step) {
let point1 = {
x: 0,
y: j
}
browserCanvasContext.closePath();
browserCanvasContext.strokeStyle = 'rgba(100, 100, 100, 0.2)';
browserCanvasContext.lineWidth = 1;
browserCanvasContext.stroke();
let point2 = {
x: frame.width,
y: j
}
point1 = transformThisPoint(point1, frame.container)
point2 = transformThisPoint(point2, frame.container)
browserCanvasContext.moveTo(point1.x, point1.y)
browserCanvasContext.lineTo(point2.x, point2.y)
}
let point3 = {
x: i,
y: 0
}
let point4 = {
x: i,
y: frame.height
}
point3 = transformThisPoint(point3, frame.container)
point4 = transformThisPoint(point4, frame.container)
browserCanvasContext.moveTo(point3.x, point3.y)
browserCanvasContext.lineTo(point4.x, point4.y)
}
}
browserCanvasContext.closePath()
browserCanvasContext.strokeStyle = 'rgba(100, 100, 100, 0.2)'
browserCanvasContext.lineWidth = 1
browserCanvasContext.stroke()
}
}
Globals.js
+1 -1
View File
@@ -1,4 +1,4 @@
/* User Interface Colors */
/* User Interface Colors */
UI_COLOR = {
DARK: "48, 48, 54",
Panels/ProductsPanel.js
+127 -157
View File
@@ -1,240 +1,210 @@
function newProductsPanel() {
var thisObject = {
container: undefined,
getLoadingProductCards: getLoadingProductCards,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
};
function newProductsPanel () {
var thisObject = {
container: undefined,
getLoadingProductCards: getLoadingProductCards,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
}
/* Cointainer stuff */
var container = newContainer();
var container = newContainer()
container.name = "Indicators and Algobots Product Panel";
container.initialize();
container.name = 'Indicators and Algobots Product Panel'
container.initialize()
container.isDraggeable = true;
container.isWheelable = true;
container.isDraggeable = true
container.isWheelable = true
thisObject.container = container;
thisObject.container.frame.containerName = "Indicators and Algobots's Products";
thisObject.container = container
thisObject.container.frame.containerName = "Indicators and Algobots's Products"
let isInitialized = false;
let productCards = [];
let isInitialized = false
let productCards = []
let visibleProductCards = [];
let firstVisibleCard = 1;
let visibleProductCards = []
let firstVisibleCard = 1
/* Needed Variables */
var lastY = 5;
var lastY = 5
return thisObject;
return thisObject
function initialize() {
function initialize () {
thisObject.container.frame.width = UI_PANEL.WIDTH.LARGE
thisObject.container.frame.height = viewPort.visibleArea.bottomLeft.y - viewPort.visibleArea.topLeft.y // UI_PANEL.HEIGHT.LARGE;
thisObject.container.frame.width = UI_PANEL.WIDTH.LARGE;
thisObject.container.frame.height = viewPort.visibleArea.bottomLeft.y - viewPort.visibleArea.topLeft.y; //UI_PANEL.HEIGHT.LARGE;
var position = {
x: viewPort.visibleArea.topLeft.x,
y: viewPort.visibleArea.bottomLeft.y - thisObject.container.frame.height
}
var position = {
x: viewPort.visibleArea.topLeft.x,
y: viewPort.visibleArea.bottomLeft.y - thisObject.container.frame.height
};
thisObject.container.frame.position = position;
thisObject.container.frame.position = position
/* First thing is to build the productCards array */
let devTeams = ecosystem.getTeams();
let devTeams = ecosystem.getTeams()
for (let i = 0; i < devTeams.length; i++) {
for (let i = 0; i < devTeams.length; i++) {
let devTeam = devTeams[i]
let devTeam = devTeams[i];
for (let j = 0; j < devTeam.bots.length; j++) {
let bot = devTeam.bots[j]
for (let j = 0; j < devTeam.bots.length; j++) {
let bot = devTeam.bots[j];
if (bot.products !== undefined) {
for (let k = 0; k < bot.products.length; k++) {
let product = bot.products[k];
if (bot.products !== undefined) {
for (let k = 0; k < bot.products.length; k++) {
let product = bot.products[k]
/* Now we create Product objects */
let productCard = newProductCard();
let productCard = newProductCard()
productCard.devTeam = devTeam;
productCard.bot = bot;
productCard.product = product;
productCard.devTeam = devTeam
productCard.bot = bot
productCard.product = product
productCard.code = devTeam.codeName + '-' + bot.codeName + '-' + product.codeName;
productCard.code = devTeam.codeName + '-' + bot.codeName + '-' + product.codeName
/* Initialize it */
productCard.initialize();
productCard.initialize()
/* Container Stuff */
productCard.container.displacement.parentDisplacement = thisObject.container.displacement;
productCard.container.frame.parentFrame = thisObject.container.frame;
productCard.container.parentContainer = thisObject.container;
productCard.container.isWheelable = true;
productCard.container.displacement.parentDisplacement = thisObject.container.displacement
productCard.container.frame.parentFrame = thisObject.container.frame
productCard.container.parentContainer = thisObject.container
productCard.container.isWheelable = true
/* Positioning within thisObject Panel */
let position = {
x: 10,
y: thisObject.container.frame.height - thisObject.container.frame.getBodyHeight()
};
let position = {
x: 10,
y: thisObject.container.frame.height - thisObject.container.frame.getBodyHeight()
}
productCard.container.frame.position.x = position.x;
productCard.container.frame.position.y = position.y + lastY;
productCard.container.frame.position.x = position.x
productCard.container.frame.position.y = position.y + lastY
lastY = lastY + productCard.container.frame.height;
lastY = lastY + productCard.container.frame.height
/* Add to the Product Array */
productCards.push(productCard);
productCards.push(productCard)
/* Add to Visible Product Array */
if (productCard.container.frame.position.y + productCard.container.frame.height < thisObject.container.frame.height) {
visibleProductCards.push(productCard);
}
if (productCard.container.frame.position.y + productCard.container.frame.height < thisObject.container.frame.height) {
visibleProductCards.push(productCard)
}
/* Listen to Status Changes Events */
productCard.container.eventHandler.listenToEvent('Status Changed', onProductCardStatusChanged);
productCard.container.eventHandler.listenToEvent('Mouse Wheel', onMouseWheel);
productCard.container.eventHandler.listenToEvent('Status Changed', onProductCardStatusChanged)
productCard.container.eventHandler.listenToEvent('Mouse Wheel', onMouseWheel)
}
}
}
}
}
}
}
}
thisObject.container.eventHandler.listenToEvent('Mouse Wheel', onMouseWheel)
isInitialized = true
}
thisObject.container.eventHandler.listenToEvent("Mouse Wheel", onMouseWheel);
isInitialized = true;
function onMouseWheel (pDelta) {
if (pDelta > 0) {
pDelta = -1
} else {
pDelta = 1
}
}
firstVisibleCard = firstVisibleCard + pDelta
function onMouseWheel(pDelta) {
let availableSlots = visibleProductCards.length
if (pDelta > 0) {
pDelta = -1;
} else {
pDelta = 1;
}
if (firstVisibleCard < 1) { firstVisibleCard = 1 }
if (firstVisibleCard > (productCards.length - availableSlots + 1)) { firstVisibleCard = productCards.length - availableSlots + 1 }
firstVisibleCard = firstVisibleCard + pDelta;
visibleProductCards = []
var lastY = 5
let availableSlots = visibleProductCards.length;
if (firstVisibleCard < 1) { firstVisibleCard = 1; }
if (firstVisibleCard > (productCards.length - availableSlots + 1)) { firstVisibleCard = productCards.length - availableSlots + 1; }
visibleProductCards = [];
var lastY = 5;
for (let i = 0; i < productCards.length; i++) {
if (i + 1 >= firstVisibleCard && i + 1 < firstVisibleCard + availableSlots) {
let productCard = productCards[i];
for (let i = 0; i < productCards.length; i++) {
if (i + 1 >= firstVisibleCard && i + 1 < firstVisibleCard + availableSlots) {
let productCard = productCards[i]
/* Positioning within thisObject Panel */
let position = {
x: 10,
y: thisObject.container.frame.height - thisObject.container.frame.getBodyHeight()
};
productCard.container.frame.position.x = position.x;
productCard.container.frame.position.y = position.y + lastY;
let position = {
x: 10,
y: thisObject.container.frame.height - thisObject.container.frame.getBodyHeight()
}
productCard.container.frame.position.x = position.x
productCard.container.frame.position.y = position.y + lastY
lastY = lastY + productCard.container.frame.height;
lastY = lastY + productCard.container.frame.height
/* Add to Visible Product Array */
visibleProductCards.push(productCard);
}
}
}
visibleProductCards.push(productCard)
}
}
}
function onProductCardStatusChanged(pProductCard) {
thisObject.container.eventHandler.raiseEvent('Product Card Status Changed', pProductCard);
}
function getLoadingProductCards() {
function onProductCardStatusChanged (pProductCard) {
thisObject.container.eventHandler.raiseEvent('Product Card Status Changed', pProductCard)
}
function getLoadingProductCards () {
/* Returns all productCards which status is LOADING */
let onProducts = [];
let onProducts = []
for (let i = 0; i < productCards.length; i++) {
for (let i = 0; i < productCards.length; i++) {
if (productCards[i].status === PRODUCT_CARD_STATUS.LOADING) {
onProducts.push(productCards[i])
}
}
if (productCards[i].status === PRODUCT_CARD_STATUS.LOADING) {
return onProducts
}
onProducts.push(productCards[i]);
}
}
return onProducts;
}
function getContainer(point) {
var container;
function getContainer (point) {
var container
/* First we check if thisObject point is inside thisObject space. */
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
/* Now we see which is the inner most container that has it */
for (var i = 0; i < visibleProductCards.length; i++) {
container = visibleProductCards[i].getContainer(point)
for (var i = 0; i < visibleProductCards.length; i++) {
container = visibleProductCards[i].getContainer(point);
if (container !== undefined) {
if (container !== undefined) {
/* We found an inner container which has the point. We return it. */
return container;
}
}
return container
}
}
/* The point does not belong to any inner container, so we return the current container. */
return thisObject.container;
} else {
return thisObject.container
} else {
/* This point does not belong to thisObject space. */
return undefined;
}
return undefined
}
}
}
function draw () {
if (isInitialized === false) { return }
thisObject.container.frame.draw(false, false, true)
function draw() {
if (isInitialized === false) {return;}
thisObject.container.frame.draw(false, false, true);
for (let i = 0; i < visibleProductCards.length; i++) {
visibleProductCards[i].draw();
}
}
}
for (let i = 0; i < visibleProductCards.length; i++) {
visibleProductCards[i].draw()
}
}
}
Panels/TimeControlPanel.js
+112 -130
View File
@@ -1,177 +1,159 @@
function newTimeControlPanel() {

function newTimeControlPanel () {
let thisObject = {
container: undefined,
setDatetime: setDatetime,
datetimeDisplay: undefined,
stepDisplay: undefined,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
}
let thisObject = {
container: undefined,
setDatetime: setDatetime,
datetimeDisplay: undefined,
stepDisplay: undefined,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
};
let container = newContainer()
container.initialize()
container.isDraggeable = true
thisObject.container = container
thisObject.container.frame.containerName = 'Current Datetime'
let container = newContainer();
container.initialize();
container.isDraggeable = true;
thisObject.container = container;
thisObject.container.frame.containerName = "Current Datetime";
let timePeriod
let timePeriod;
return thisObject
return thisObject;
function initialize () {
thisObject.container.frame.width = UI_PANEL.WIDTH.SMALL
thisObject.container.frame.height = UI_PANEL.HEIGHT.SMALL
function initialize() {
let position = {
x: (viewPort.visibleArea.topRight.x - viewPort.visibleArea.topLeft.x) / 2 - thisObject.container.frame.width / 2,
y: viewPort.visibleArea.bottomLeft.y - thisObject.container.frame.height
}
thisObject.container.frame.width = UI_PANEL.WIDTH.SMALL;
thisObject.container.frame.height = UI_PANEL.HEIGHT.SMALL;
thisObject.container.frame.position = position
let position = {
x: (viewPort.visibleArea.topRight.x - viewPort.visibleArea.topLeft.x) / 2 - thisObject.container.frame.width / 2,
y: viewPort.visibleArea.bottomLeft.y - thisObject.container.frame.height
};
let buttonPosition
thisObject.container.frame.position = position;
let buttonNames = ['Fast Backwards', 'Play Backwards', 'Step Backwards', 'Pause', 'Step Forward', 'Play Forward', 'Fast Forward']
let lastX = 0
let buttonPosition;
let datetime = INITIAL_DATE
let buttonNames = ['Fast Backwards', 'Play Backwards', 'Step Backwards', 'Pause', 'Step Forward', 'Play Forward', 'Fast Forward'];
let lastX = 0;
let datetimeDisplay = {
currentDatetime: datetime,
addTime: addTime,
draw: drawTimeDisplay
}
let datetime = INITIAL_DATE;
let datetimeDisplay = {
currentDatetime: datetime,
addTime: addTime,
draw: drawTimeDisplay
};
thisObject.datetimeDisplay = datetimeDisplay;
thisObject.datetimeDisplay = datetimeDisplay
/* Here we will listen to the event when time was changed due to a Bot Execution. */
canvas.bottomSpace.playStopButton.container.eventHandler.listenToEvent("Bot Execution Changed Datetime", onBotChangedTime);
canvas.bottomSpace.playStopButton.setDatetime(datetime);
canvas.bottomSpace.playStopButton.container.eventHandler.listenToEvent('Bot Execution Changed Datetime', onBotChangedTime)
canvas.bottomSpace.playStopButton.setDatetime(datetime)
viewPort.eventHandler.listenToEvent("Zoom Changed", onZoomChanged);
timePeriod = INITIAL_TIME_PERIOD;
}
viewPort.eventHandler.listenToEvent('Zoom Changed', onZoomChanged)
timePeriod = INITIAL_TIME_PERIOD
}
function onBotChangedTime(pNewDatetime) {
function onBotChangedTime (pNewDatetime) {
let newDatetime = new Date(pNewDatetime)
let newDatetime = new Date(pNewDatetime);
thisObject.container.eventHandler.raiseEvent('Datetime Changed', newDatetime)
}
thisObject.container.eventHandler.raiseEvent("Datetime Changed", newDatetime);
function onZoomChanged (event) {
timePeriod = recalculatePeriod(event.newLevel)
}
}
function onZoomChanged(event) {
timePeriod = recalculatePeriod(event.newLevel);
}
function getContainer(point) {
let container;
function getContainer (point) {
let container
/* First we check if thisObject point is inside thisObject space. */
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
/* The point does not belong to any inner container, so we return the current container. */
return thisObject.container;
} else {
return thisObject.container
} else {
/* This point does not belong to thisObject space. */
return undefined;
}
return undefined
}
}
function setDatetime(pDatetime) {
function setDatetime (pDatetime) {
thisObject.datetimeDisplay.currentDatetime = new Date(pDatetime)
canvas.bottomSpace.playStopButton.setDatetime(pDatetime)
}
thisObject.datetimeDisplay.currentDatetime = new Date(pDatetime);
canvas.bottomSpace.playStopButton.setDatetime(pDatetime);
}
function addTime (seconds) {
let newDate = thisObject.datetimeDisplay.currentDatetime
function addTime(seconds) {
newDate.setSeconds(newDate.getSeconds() + seconds)
thisObject.datetimeDisplay.currentDatetime = newDate
}
let newDate = thisObject.datetimeDisplay.currentDatetime;
function draw () {
thisObject.container.frame.draw(false, false, true)
newDate.setSeconds(newDate.getSeconds() + seconds);
thisObject.datetimeDisplay.currentDatetime = newDate;
thisObject.datetimeDisplay.draw()
}
}
function drawTimeDisplay () {
let fontSize = 10
function draw() {
let label = thisObject.datetimeDisplay.currentDatetime.toUTCString()
let labelArray = label.split(' ')
thisObject.container.frame.draw(false, false, true);
thisObject.datetimeDisplay.draw();
}
function drawTimeDisplay() {
let fontSize = 10;
let label = thisObject.datetimeDisplay.currentDatetime.toUTCString();
let labelArray = label.split(" ");
label = labelArray[0] + " " + labelArray[1] + " " + labelArray[2] + " " + labelArray[3];
label = labelArray[0] + ' ' + labelArray[1] + ' ' + labelArray[2] + ' ' + labelArray[3]
/* Now we transform x on the actual coordinate on the canvas. */
let labelPoint = {
x: thisObject.container.frame.width / 2 - label.length / 2 * fontSize * FONT_ASPECT_RATIO,
y: thisObject.container.frame.height * 4.4 / 10
};
let labelPoint = {
x: thisObject.container.frame.width / 2 - label.length / 2 * fontSize * FONT_ASPECT_RATIO,
y: thisObject.container.frame.height * 4.4 / 10
}
labelPoint = thisObject.container.frame.frameThisPoint(labelPoint);
labelPoint = thisObject.container.frame.frameThisPoint(labelPoint)
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY;
browserCanvasContext.fillStyle = 'rgba(60, 60, 60, 0.50)';
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y);
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY
browserCanvasContext.fillStyle = 'rgba(60, 60, 60, 0.50)'
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y)
/* The time */
label = labelArray[4] + " " + labelArray[5];
label = labelArray[4] + ' ' + labelArray[5]
/* Now we transform x on the actual coordinate on the canvas. */
labelPoint = {
x: thisObject.container.frame.width / 2 - label.length / 2 * fontSize * FONT_ASPECT_RATIO,
y: thisObject.container.frame.height * 6.5 / 10
};
labelPoint = thisObject.container.frame.frameThisPoint(labelPoint);
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY;
browserCanvasContext.fillStyle = 'rgba(60, 60, 60, 0.50)';
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y);
if (timePeriod > _45_MINUTES_IN_MILISECONDS) {
label = timePeriod / _1_HOUR_IN_MILISECONDS + ' hs';
} else {
label = timePeriod / _1_MINUTE_IN_MILISECONDS + ' min';
}
/* Now we transform x on the actual coordinate on the canvas. */
labelPoint = {
x: thisObject.container.frame.width / 2 - label.length / 2 * fontSize * FONT_ASPECT_RATIO,
y: thisObject.container.frame.height * 8.5 / 10
};
labelPoint = thisObject.container.frame.frameThisPoint(labelPoint);
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY;
browserCanvasContext.fillStyle = 'rgba(60, 60, 60, 0.50)';
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y);
labelPoint = {
x: thisObject.container.frame.width / 2 - label.length / 2 * fontSize * FONT_ASPECT_RATIO,
y: thisObject.container.frame.height * 6.5 / 10
}
}
labelPoint = thisObject.container.frame.frameThisPoint(labelPoint)
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY
browserCanvasContext.fillStyle = 'rgba(60, 60, 60, 0.50)'
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y)
if (timePeriod > _45_MINUTES_IN_MILISECONDS) {
label = timePeriod / _1_HOUR_IN_MILISECONDS + ' hs'
} else {
label = timePeriod / _1_MINUTE_IN_MILISECONDS + ' min'
}
/* Now we transform x on the actual coordinate on the canvas. */
labelPoint = {
x: thisObject.container.frame.width / 2 - label.length / 2 * fontSize * FONT_ASPECT_RATIO,
y: thisObject.container.frame.height * 8.5 / 10
}
labelPoint = thisObject.container.frame.frameThisPoint(labelPoint)
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.SECONDARY
browserCanvasContext.fillStyle = 'rgba(60, 60, 60, 0.50)'
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y)
}
}
PlottersManager.js
+692 -748
View File
File diff suppressed because it is too large. Load diff
ProductCard.js
+596 -667
View File
File diff suppressed because it is too large. Load diff
ProductStorage.js
+342 -411
View File
@@ -1,18 +1,17 @@

function newProductStorage(pName) {
const MODULE_NAME = "Product Storage";
const INFO_LOG = false;
const ERROR_LOG = true;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;

function newProductStorage (pName) {
const MODULE_NAME = 'Product Storage'
const INFO_LOG = false
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
/*
This object will initialize children objects that will end up loading the data of each set defined at each product of the bot received at initialization.
Once all the underlaying objects are fully initialized it will callback.
At the same time it will raise an event for each underlaying file being loaded, so that the UI can reflect the progress to the end user.
At the same time it will raise an event for each underlaying file being loaded, so that the UI can reflect the progress to the end user.
Product Storage
|
@@ -26,471 +25,403 @@ function newProductStorage(pName) {
*/
let thisObject = {
let thisObject = {
marketFiles: [],
dailyFiles: [],
singleFile: [],
fileSequences: [],
marketFiles: [],
dailyFiles: [],
singleFile: [],
fileSequences: [],
setDatetime: setDatetime,
setTimePeriod: setTimePeriod,
setDatetime: setDatetime,
setTimePeriod: setTimePeriod,
eventHandler: undefined,
initialize: initialize,
finalize: finalize
eventHandler: undefined,
initialize: initialize,
finalize: finalize
}
}
thisObject.eventHandler = newEventHandler();
thisObject.eventHandler = newEventHandler()
/* We name the event Handler to easy debugging. */
thisObject.eventHandler.name = "Storage-" + pName;
thisObject.eventHandler.name = 'Storage-' + pName
let datetime;
let timePeriod;
let datetime
let timePeriod
return thisObject;
return thisObject
function finalize() {
function finalize () {
try {
if (INFO_LOG === true) { logger.write('[INFO] finalize -> Entering function.') }
try {
for (let i = 0; i < thisObject.marketFiles.length; i++) {
let marketFile = thisObject.marketFiles[i]
marketFile.finalize()
}
if (INFO_LOG === true) { logger.write("[INFO] finalize -> Entering function."); }
thisObject.marketFiles = undefined
for (let i = 0; i < thisObject.marketFiles.length; i++) {
for (let i = 0; i < thisObject.dailyFiles.length; i++) {
let dailyFile = thisObject.dailyFiles[i]
dailyFile.finalize()
}
let marketFile = thisObject.marketFiles[i];
marketFile.finalize();
}
thisObject.dailyFiles = undefined
thisObject.marketFiles = undefined;
for (let i = 0; i < thisObject.fileSequences.length; i++) {
let fileSequence = thisObject.fileSequences[i]
fileSequence.finalize()
}
for (let i = 0; i < thisObject.dailyFiles.length; i++) {
let dailyFile = thisObject.dailyFiles[i];
dailyFile.finalize();
}
thisObject.dailyFile = undefined;
for (let i = 0; i < thisObject.fileSequences.length; i++) {
let fileSequence = thisObject.fileSequences[i];
fileSequence.finalize();
}
thisObject.dailyFile = undefined;
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] finalize -> err = " + err); }
}
thisObject.fileSequences = undefined
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] finalize -> err = ' + err) }
}
function initialize(pDevTeam, pBot, pProduct, pExchange, pMarket, pDatetime, pTimePeriod, callBackFunction) {
}
try {
function initialize (pDevTeam, pBot, pProduct, pExchange, pMarket, pDatetime, pTimePeriod, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
datetime = pDatetime
timePeriod = pTimePeriod
datetime = pDatetime;
timePeriod = pTimePeriod;
let dataSetsToLoad = 0
let dataSetsLoaded = 0
let dataSetsToLoad = 0;
let dataSetsLoaded = 0;
if (INFO_LOG === true) { logger.write('[INFO] initialize -> dataSetsToLoad = ' + dataSetsToLoad) }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> dataSetsLoaded = ' + dataSetsLoaded) }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> dataSetsToLoad = " + dataSetsToLoad); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> dataSetsLoaded = " + dataSetsLoaded); }
for (let i = 0; i < pProduct.dataSets.length; i++) {
let thisSet = pProduct.dataSets[i]
switch (thisSet.type) {
case 'Market Files': {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Market Files -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
for (let i = 0; i < pProduct.dataSets.length; i++) {
dataSetsToLoad++
let thisSet = pProduct.dataSets[i];
if (INFO_LOG === true) { logger.write('[INFO] initialize -> dataSetsToLoad = ' + dataSetsToLoad) }
switch (thisSet.type) {
case 'Market Files': {
let marketFiles = newMarketFiles()
marketFiles.initialize(pDevTeam, pBot, pProduct, thisSet, pExchange, pMarket, onMarketFileReady)
thisObject.marketFiles.push(marketFiles)
}
break
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Market Files -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
case 'Daily Files': {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Daily Files -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
dataSetsToLoad++;
dataSetsToLoad++
if (INFO_LOG === true) { logger.write("[INFO] initialize -> dataSetsToLoad = " + dataSetsToLoad); }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> dataSetsToLoad = ' + dataSetsToLoad) }
let marketFiles = newMarketFiles();
marketFiles.initialize(pDevTeam, pBot, pProduct, thisSet, pExchange, pMarket, onMarketFileReady);
thisObject.marketFiles.push(marketFiles);
}
break;
let dailyFiles = newDailyFiles()
dailyFiles.initialize(pDevTeam, pBot, pProduct, thisSet, pExchange, pMarket, pDatetime, pTimePeriod, onDailyFileReady)
thisObject.dailyFiles.push(dailyFiles)
}
break
case 'Daily Files': {
case 'Single File': {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Single File -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Daily Files -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
dataSetsToLoad++
dataSetsToLoad++;
if (INFO_LOG === true) { logger.write('[INFO] initialize -> dataSetsToLoad = ' + dataSetsToLoad) }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> dataSetsToLoad = " + dataSetsToLoad); }
let singleFile = newSingleFile()
singleFile.initialize(pDevTeam, pBot, pProduct, thisSet, pExchange, pMarket, onSingleFileReady)
thisObject.singleFile.push(singleFile)
}
break
let dailyFiles = newDailyFiles();
dailyFiles.initialize(pDevTeam, pBot, pProduct, thisSet, pExchange, pMarket, pDatetime, pTimePeriod, onDailyFileReady);
thisObject.dailyFiles.push(dailyFiles);
}
break;
case 'File Sequence': {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> File Sequence -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
case 'Single File': {
dataSetsToLoad++
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Single File -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> dataSetsToLoad = ' + dataSetsToLoad) }
dataSetsToLoad++;
let fileSequences = newFileSequence()
fileSequences.initialize(pDevTeam, pBot, pProduct, thisSet, pExchange, pMarket, onFileSequenceReady)
thisObject.fileSequences.push(fileSequences)
}
break
}
if (INFO_LOG === true) { logger.write("[INFO] initialize -> dataSetsToLoad = " + dataSetsToLoad); }
function onMarketFileReady (err, pCaller) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onMarketFileReady -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onMarketFileReady -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
let singleFile = newSingleFile();
singleFile.initialize(pDevTeam, pBot, pProduct, thisSet, pExchange, pMarket, onSingleFileReady);
thisObject.singleFile.push(singleFile);
}
break;
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onMarketFileReady -> Received OK Response.') }
break
}
case 'File Sequence': {
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onMarketFileReady -> Received FAIL Response.') }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
return
}
if (INFO_LOG === true) { logger.write("[INFO] initialize -> File Sequence -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onMarketFileReady -> Received CUSTOM FAIL Response.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onMarketFileReady -> err.message = ' + err.message) }
dataSetsToLoad++;
callBackFunction(err)
return
}
if (INFO_LOG === true) { logger.write("[INFO] initialize -> dataSetsToLoad = " + dataSetsToLoad); }
let fileSequences = newFileSequence();
fileSequences.initialize(pDevTeam, pBot, pProduct, thisSet, pExchange, pMarket, onFileSequenceReady);
thisObject.fileSequences.push(fileSequences);
}
break;
}
function onMarketFileReady(err, pCaller) {
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onMarketFileReady -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onMarketFileReady -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onMarketFileReady -> Received OK Response."); }
break;
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onMarketFileReady -> Received FAIL Response."); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
return;
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onMarketFileReady -> Received CUSTOM FAIL Response."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onMarketFileReady -> err.message = " + err.message); }
callBackFunction(err);
return;
}
default: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onMarketFileReady -> Received Unexpected Response."); }
callBackFunction(err);
return;
}
}
let event = {
totalValue: pCaller.getExpectedFiles(),
currentValue: pCaller.getFilesLoaded()
}
thisObject.eventHandler.raiseEvent('Market File Loaded', event);
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onMarketFileReady -> event.currentValue = " + event.currentValue); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onMarketFileReady -> event.totalValue = " + event.totalValue); }
if (event.currentValue === event.totalValue) {
dataSetsLoaded++;
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onMarketFileReady -> dataSetsLoaded = " + dataSetsLoaded); }
checkInitializeComplete();
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onMarketFileReady -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
}
function onDailyFileReady(err, pCaller) {
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDailyFileReady -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDailyFileReady -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDailyFileReady -> Received OK Response."); }
break;
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDailyFileReady -> Received FAIL Response."); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
return;
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDailyFileReady -> Received CUSTOM FAIL Response."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDailyFileReady -> err.message = " + err.message); }
callBackFunction(err);
return;
}
default: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDailyFileReady -> Received Unexpected Response."); }
callBackFunction(err);
return;
}
}
let event = {
totalValue: pCaller.getExpectedFiles(),
currentValue: pCaller.getFilesLoaded()
}
thisObject.eventHandler.raiseEvent('Daily File Loaded', event);
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDailyFileReady -> event.currentValue = " + event.currentValue); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDailyFileReady -> event.totalValue = " + event.totalValue); }
if (event.currentValue === event.totalValue) {
dataSetsLoaded++;
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDailyFileReady -> dataSetsLoaded = " + dataSetsLoaded); }
checkInitializeComplete();
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onDailyFileReady -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
}
function onSingleFileReady(err, pCaller) {
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onSingleFileReady -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onSingleFileReady -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onSingleFileReady -> Received OK Response."); }
break;
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onSingleFileReady -> Received FAIL Response."); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
return;
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onSingleFileReady -> Received CUSTOM FAIL Response."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onSingleFileReady -> err.message = " + err.message); }
callBackFunction(err);
return;
}
default: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onSingleFileReady -> Received Unexpected Response."); }
callBackFunction(err);
return;
}
}
let event = {
totalValue: 1,
currentValue: 1
}
thisObject.eventHandler.raiseEvent('Single File Loaded', event);
if (event.currentValue === event.totalValue) {
dataSetsLoaded++;
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onSingleFileReady -> dataSetsLoaded = " + dataSetsLoaded); }
checkInitializeComplete();
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onSingleFileReady -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
}
function onFileSequenceReady(err, pCaller) {
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileSequenceReady -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileSequenceReady -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileSequenceReady -> Received OK Response."); }
break;
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileSequenceReady -> Received FAIL Response."); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
return;
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileSequenceReady -> Received CUSTOM FAIL Response."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileSequenceReady -> err.message = " + err.message); }
callBackFunction(err);
return;
}
default: {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileSequenceReady -> Received Unexpected Response."); }
callBackFunction(err);
return;
}
}
let event = {
totalValue: pCaller.getExpectedFiles(),
currentValue: pCaller.getFilesLoaded()
}
thisObject.eventHandler.raiseEvent('File Sequence Loaded', event);
if (event.currentValue === event.totalValue) {
dataSetsLoaded++;
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onFileSequenceReady = " + dataSetsLoaded); }
checkInitializeComplete();
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onFileSequenceReady -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
}
function checkInitializeComplete() {
try {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> checkInitializeComplete -> Entering function."); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> checkInitializeComplete -> key = " + pDevTeam.codeName + "-" + pBot.codeName + "-" + pProduct.codeName); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> checkInitializeComplete -> dataSetsToLoad = " + dataSetsToLoad); }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> checkInitializeComplete -> dataSetsLoaded = " + dataSetsLoaded); }
if (dataSetsLoaded === dataSetsToLoad) {
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE);
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> checkInitializeComplete -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
}
default: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onMarketFileReady -> Received Unexpected Response.') }
callBackFunction(err)
return
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
let event = {
totalValue: pCaller.getExpectedFiles(),
currentValue: pCaller.getFilesLoaded()
}
thisObject.eventHandler.raiseEvent('Market File Loaded', event)
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onMarketFileReady -> event.currentValue = ' + event.currentValue) }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onMarketFileReady -> event.totalValue = ' + event.totalValue) }
if (event.currentValue === event.totalValue) {
dataSetsLoaded++
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onMarketFileReady -> dataSetsLoaded = ' + dataSetsLoaded) }
checkInitializeComplete()
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> onMarketFileReady -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function onDailyFileReady (err, pCaller) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDailyFileReady -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDailyFileReady -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDailyFileReady -> Received OK Response.') }
break
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDailyFileReady -> Received FAIL Response.') }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
return
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDailyFileReady -> Received CUSTOM FAIL Response.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDailyFileReady -> err.message = ' + err.message) }
callBackFunction(err)
return
}
default: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDailyFileReady -> Received Unexpected Response.') }
callBackFunction(err)
return
}
}
let event = {
totalValue: pCaller.getExpectedFiles(),
currentValue: pCaller.getFilesLoaded()
}
thisObject.eventHandler.raiseEvent('Daily File Loaded', event)
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDailyFileReady -> event.currentValue = ' + event.currentValue) }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDailyFileReady -> event.totalValue = ' + event.totalValue) }
if (event.currentValue === event.totalValue) {
dataSetsLoaded++
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDailyFileReady -> dataSetsLoaded = ' + dataSetsLoaded) }
checkInitializeComplete()
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> onDailyFileReady -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function onSingleFileReady (err, pCaller) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSingleFileReady -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSingleFileReady -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSingleFileReady -> Received OK Response.') }
break
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSingleFileReady -> Received FAIL Response.') }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
return
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSingleFileReady -> Received CUSTOM FAIL Response.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSingleFileReady -> err.message = ' + err.message) }
callBackFunction(err)
return
}
default: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSingleFileReady -> Received Unexpected Response.') }
callBackFunction(err)
return
}
}
let event = {
totalValue: 1,
currentValue: 1
}
thisObject.eventHandler.raiseEvent('Single File Loaded', event)
if (event.currentValue === event.totalValue) {
dataSetsLoaded++
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onSingleFileReady -> dataSetsLoaded = ' + dataSetsLoaded) }
checkInitializeComplete()
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> onSingleFileReady -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function onFileSequenceReady (err, pCaller) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileSequenceReady -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileSequenceReady -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
switch (err.result) {
case GLOBAL.DEFAULT_OK_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileSequenceReady -> Received OK Response.') }
break
}
case GLOBAL.DEFAULT_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileSequenceReady -> Received FAIL Response.') }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
return
}
case GLOBAL.CUSTOM_FAIL_RESPONSE.result: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileSequenceReady -> Received CUSTOM FAIL Response.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileSequenceReady -> err.message = ' + err.message) }
callBackFunction(err)
return
}
default: {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileSequenceReady -> Received Unexpected Response.') }
callBackFunction(err)
return
}
}
let event = {
totalValue: pCaller.getExpectedFiles(),
currentValue: pCaller.getFilesLoaded()
}
thisObject.eventHandler.raiseEvent('File Sequence Loaded', event)
if (event.currentValue === event.totalValue) {
dataSetsLoaded++
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onFileSequenceReady = ' + dataSetsLoaded) }
checkInitializeComplete()
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> onFileSequenceReady -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function checkInitializeComplete () {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> checkInitializeComplete -> Entering function.') }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> checkInitializeComplete -> key = ' + pDevTeam.codeName + '-' + pBot.codeName + '-' + pProduct.codeName) }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> checkInitializeComplete -> dataSetsToLoad = ' + dataSetsToLoad) }
if (INFO_LOG === true) { logger.write('[INFO] initialize -> checkInitializeComplete -> dataSetsLoaded = ' + dataSetsLoaded) }
if (dataSetsLoaded === dataSetsToLoad) {
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE)
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> checkInitializeComplete -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
function setDatetime(pDatetime) {
if (INFO_LOG === true) { logger.write("[INFO] setDatetime -> Entering function."); }
function setDatetime (pDatetime) {
if (INFO_LOG === true) { logger.write('[INFO] setDatetime -> Entering function.') }
/* If there is a change in the day, then we take some actions, otherwise, we dont. */
let currentDate = Math.trunc(datetime.valueOf() / ONE_DAY_IN_MILISECONDS);
let newDate = Math.trunc(pDatetime.valueOf() / ONE_DAY_IN_MILISECONDS);
let currentDate = Math.trunc(datetime.valueOf() / ONE_DAY_IN_MILISECONDS)
let newDate = Math.trunc(pDatetime.valueOf() / ONE_DAY_IN_MILISECONDS)
datetime = new Date(pDatetime);
datetime = new Date(pDatetime)
if (currentDate !== newDate) {
if (timePeriod <= _1_HOUR_IN_MILISECONDS) {
for (let i = 0; i < thisObject.dailyFiles.length; i++) {
thisObject.dailyFiles[i].setDatetime(pDatetime);
}
}
if (currentDate !== newDate) {
if (timePeriod <= _1_HOUR_IN_MILISECONDS) {
for (let i = 0; i < thisObject.dailyFiles.length; i++) {
thisObject.dailyFiles[i].setDatetime(pDatetime)
}
}
}
}
function setTimePeriod(pTimePeriod) {
if (INFO_LOG === true) { logger.write("[INFO] setTimePeriod -> Entering function."); }
function setTimePeriod (pTimePeriod) {
if (INFO_LOG === true) { logger.write('[INFO] setTimePeriod -> Entering function.') }
/* We are going to filter out the cases in which the timePeriod received is the same that the one we already know. */
if (timePeriod !== pTimePeriod) {
if (timePeriod !== pTimePeriod) {
timePeriod = pTimePeriod
timePeriod = pTimePeriod;
if (timePeriod <= _1_HOUR_IN_MILISECONDS) {
for (let i = 0; i < thisObject.dailyFiles.length; i++) {
thisObject.dailyFiles[i].setTimePeriod(pTimePeriod, datetime);
}
}
if (timePeriod <= _1_HOUR_IN_MILISECONDS) {
for (let i = 0; i < thisObject.dailyFiles.length; i++) {
thisObject.dailyFiles[i].setTimePeriod(pTimePeriod, datetime)
}
}
}
}
}
Scales/ChartGrid.js
+480 -537
View File
File diff suppressed because it is too large. Load diff
Scales/RightScale.js
+40 -51
View File
@@ -1,67 +1,56 @@
function newRigthScale() {
function newRigthScale () {
let thisObject = {
container: undefined,
draw: draw,
getContainer: getContainer,
initialize: initialize
}
let thisObject = {
container: undefined,
draw: draw,
getContainer: getContainer,
initialize: initialize
};
const RIGHT_MARGIN = 50
const RIGHT_MARGIN = 50;
let container = newContainer()
container.initialize()
thisObject.container = container
let container = newContainer();
container.initialize();
thisObject.container = container;
thisObject.container.frame.width = RIGHT_MARGIN
thisObject.container.frame.height = viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topRight.y
thisObject.container.frame.width = RIGHT_MARGIN;
thisObject.container.frame.height = viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topRight.y;
container.frame.position.x = viewPort.visibleArea.bottomRight.x
container.frame.position.y = TOP_SPACE_HEIGHT
container.frame.position.x = viewPort.visibleArea.bottomRight.x;
container.frame.position.y = TOP_SPACE_HEIGHT;
container.isDraggeable = false
container.isClickeable = false
container.isWheeleable = true
container.isDraggeable = false;
container.isClickeable = false;
container.isWheeleable = true;
return thisObject
return thisObject;
function initialize () {
thisObject.container.eventHandler.listenToEvent('Mouse Wheel', onMouseWheel)
}
function initialize() {
function onMouseWheel (pDelta) {
if (pDelta < 0) {
pDelta = -0.1
} else {
pDelta = 0.1
}
}
thisObject.container.eventHandler.listenToEvent('Mouse Wheel', onMouseWheel);
}
function onMouseWheel(pDelta) {
if (pDelta < 0) {
pDelta = -0.1;
} else {
pDelta = 0.1;
}
}
function getContainer(point) {
let container;
function getContainer (point) {
let container
/* First we check if this point is inside this object UI. */
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container;
} else {
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container
} else {
/* This point does not belong to this space. */
return undefined;
}
}
return undefined
}
}
function draw() {
function draw () {
}
}
}
}
Spaces/BottomSpace.js
+72 -82
View File
@@ -1,105 +1,95 @@

function newBottomSpace() {

function newBottomSpace () {
var thisObject = {
deleteTradingHistory: undefined,
chartAspectRatio: undefined,
playStopButton: undefined,
container: undefined,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
}
var thisObject = {
deleteTradingHistory: undefined,
chartAspectRatio: undefined,
playStopButton: undefined,
container: undefined,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
};
var container = newContainer()
container.initialize()
thisObject.container = container
var container = newContainer();
container.initialize();
thisObject.container = container;
container.isDraggeable = false
container.isDraggeable = false;
resize()
resize();
return thisObject
return thisObject;
function initialize () {
thisObject.deleteTradingHistory = newDeleteTradingHistory()
thisObject.deleteTradingHistory.initialize()
function initialize() {
thisObject.chartAspectRatio = newChartAspectRatio()
thisObject.chartAspectRatio.initialize()
thisObject.deleteTradingHistory = newDeleteTradingHistory();
thisObject.deleteTradingHistory.initialize();
thisObject.playStopButton = newPlayStopButton()
thisObject.playStopButton.initialize()
thisObject.chartAspectRatio = newChartAspectRatio();
thisObject.chartAspectRatio.initialize();
window.canvasApp.eventHandler.listenToEvent('Browser Resized', resize)
}
thisObject.playStopButton = newPlayStopButton();
thisObject.playStopButton.initialize();
function resize () {
container.frame.position.x = 0
container.frame.position.y = viewPort.visibleArea.bottomLeft.y
window.canvasApp.eventHandler.listenToEvent("Browser Resized", resize);
thisObject.container.frame.width = browserCanvas.width
thisObject.container.frame.height = BOTTOM_SPACE_HEIGHT
}
}
function getContainer (point) {
let container
function resize() {
container = thisObject.deleteTradingHistory.getContainer(point)
if (container !== undefined) { return container }
container.frame.position.x = 0;
container.frame.position.y = viewPort.visibleArea.bottomLeft.y;
container = thisObject.chartAspectRatio.getContainer(point)
if (container !== undefined) { return container }
thisObject.container.frame.width = browserCanvas.width;
thisObject.container.frame.height = BOTTOM_SPACE_HEIGHT;
}
function getContainer(point) {
let container;
container = thisObject.deleteTradingHistory.getContainer(point);
if (container !== undefined) { return container; }
container = thisObject.chartAspectRatio.getContainer(point);
if (container !== undefined) { return container; }
container = thisObject.playStopButton.getContainer(point);
if (container !== undefined) { return container; }
container = thisObject.playStopButton.getContainer(point)
if (container !== undefined) { return container }
/* The point does not belong to any inner container, so we return the current container. */
return thisObject.container;
return thisObject.container
}
function draw () {
thisObject.container.frame.draw(false, false)
drawBackground()
thisObject.deleteTradingHistory.draw()
thisObject.chartAspectRatio.draw()
thisObject.playStopButton.draw()
}
function drawBackground () {
let opacity = 1
let zeroPoint = {
x: 0,
y: 0
}
function draw() {
zeroPoint = thisObject.container.frame.frameThisPoint(zeroPoint)
thisObject.container.frame.draw(false, false);
let breakpointsHeight = 15
const RED_LINE_HIGHT = 5
drawBackground();
thisObject.deleteTradingHistory.draw();
thisObject.chartAspectRatio.draw();
thisObject.playStopButton.draw();
browserCanvasContext.beginPath()
browserCanvasContext.rect(zeroPoint.x, zeroPoint.y + breakpointsHeight, thisObject.container.frame.width, thisObject.container.frame.height)
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.DARK + ', ' + opacity + ')'
browserCanvasContext.closePath()
browserCanvasContext.fill()
}
function drawBackground() {
let opacity = 1;
let zeroPoint = {
x: 0,
y: 0
};
zeroPoint = thisObject.container.frame.frameThisPoint(zeroPoint);
let breakpointsHeight = 15;
const RED_LINE_HIGHT = 5;
browserCanvasContext.beginPath();
browserCanvasContext.rect(zeroPoint.x, zeroPoint.y + breakpointsHeight, thisObject.container.frame.width, thisObject.container.frame.height );
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.DARK + ', ' + opacity + ')';
browserCanvasContext.closePath();
browserCanvasContext.fill();
browserCanvasContext.beginPath();
browserCanvasContext.rect(zeroPoint.x, zeroPoint.y + breakpointsHeight, thisObject.container.frame.width,RED_LINE_HIGHT);
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.RUSTED_RED + ', ' + opacity + ')';
browserCanvasContext.closePath();
browserCanvasContext.fill();
}
}
browserCanvasContext.beginPath()
browserCanvasContext.rect(zeroPoint.x, zeroPoint.y + breakpointsHeight, thisObject.container.frame.width, RED_LINE_HIGHT)
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.RUSTED_RED + ', ' + opacity + ')'
browserCanvasContext.closePath()
browserCanvasContext.fill()
}
}
Spaces/ChartSpace.js
+82 -82
View File
@@ -1,132 +1,132 @@
/*
/*
The chart space is where all the charts live. What this space contains is a type of object we call Time Machine. A Time Machine is a cointainer of
charts objects. The idea is simple, all the chart objects are ploted according to the time of the Time Machine object. When the time of the Time Machine
charts objects. The idea is simple, all the chart objects are ploted according to the time of the Time Machine object. When the time of the Time Machine
changes, then all charts in it are replotted with the corresponging data.
*/
function newChartSpace() {
function newChartSpace () {
const MODULE_NAME = 'Chart Space'
const INFO_LOG = false
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
const MODULE_NAME = "Chart Space";
const INFO_LOG = false;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
var thisObject = {
container: undefined,
draw: draw,
timeMachines: [],
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize,
finalize: finalize
}
var thisObject = {
container: undefined,
draw: draw,
timeMachines: [],
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
};
var container = newContainer()
container.initialize()
thisObject.container = container
thisObject.container.frame.width = CHART_SPACE_WIDTH
thisObject.container.frame.height = CHART_SPACE_HEIGHT
var container = newContainer();
container.initialize();
thisObject.container = container;
container.displacement.containerName = 'Chart Space'
container.frame.containerName = 'Chart Space'
thisObject.container.frame.width = CHART_SPACE_WIDTH;
thisObject.container.frame.height = CHART_SPACE_HEIGHT;
container.frame.position.x = browserCanvas.width / 2 - thisObject.container.frame.width / 2
container.frame.position.y = browserCanvas.height / 2 - thisObject.container.frame.height / 2
container.displacement.containerName = "Chart Space";
container.frame.containerName = "Chart Space";
container.isDraggeable = false
container.frame.position.x = browserCanvas.width / 2 - thisObject.container.frame.width / 2;
container.frame.position.y = browserCanvas.height / 2 - thisObject.container.frame.height / 2;
return thisObject
container.isDraggeable = false;
function finalize () {
try {
if (INFO_LOG === true) { logger.write('[INFO] finalize -> Entering function.') }
return thisObject;
for (let i = 0; i < thisObject.timeMachines.length; i++) {
let timeMachine = thisObject.timeMachines[i]
timeMachine.finalize()
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] finalize -> err = ' + err) }
}
}
function initialize(callBackFunction) {
function initialize (callBackFunction) {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
let initializedCounter = 0;
let toInitialize = 1;
let initializedCounter = 0
let toInitialize = 1
/* We create the first of many possible time machines that could live at the Chart Space. */
var timeMachine = newTimeMachine();
var timeMachine = newTimeMachine()
timeMachine.container.displacement.parentDisplacement = this.container.displacement;
timeMachine.container.frame.parentFrame = this.container.frame;
timeMachine.container.displacement.parentDisplacement = this.container.displacement
timeMachine.container.frame.parentFrame = this.container.frame
timeMachine.container.parentContainer = this.container;
timeMachine.container.parentContainer = this.container
/* We make the time machine a little bit smaller than the current space. */
timeMachine.container.frame.width = this.container.frame.width * 1;
timeMachine.container.frame.height = this.container.frame.height * 1;
timeMachine.container.frame.width = this.container.frame.width * 1
timeMachine.container.frame.height = this.container.frame.height * 1
timeMachine.container.frame.position.x = this.container.frame.width / 2 - timeMachine.container.frame.width / 2;
timeMachine.container.frame.position.y = this.container.frame.height / 2 - timeMachine.container.frame.height / 2;
timeMachine.container.frame.position.x = this.container.frame.width / 2 - timeMachine.container.frame.width / 2
timeMachine.container.frame.position.y = this.container.frame.height / 2 - timeMachine.container.frame.height / 2
timeMachine.initialize(onTimeMachineInitialized);
timeMachine.initialize(onTimeMachineInitialized)
function onTimeMachineInitialized(err) {
function onTimeMachineInitialized (err) {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onTimeMachineInitialized -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onTimeMachineInitialized -> Entering function."); }
initializedCounter++
initializedCounter++;
if (err.result !== GLOBAL.DEFAULT_OK_RESPONSE.result) {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onTimeMachineInitialized -> Initialization of a Time Machine failed.') }
if (err.result !== GLOBAL.DEFAULT_OK_RESPONSE.result) {
callBackFunction(err)
return
}
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onTimeMachineInitialized -> Initialization of a Time Machine failed."); }
thisObject.timeMachines.push(timeMachine)
callBackFunction(err);
return;
}
thisObject.timeMachines.push(timeMachine);
if (initializedCounter === toInitialize) {
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE);
}
}
if (initializedCounter === toInitialize) {
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE)
}
}
}
function draw() {
thisObject.container.frame.draw(false, false);
function draw () {
thisObject.container.frame.draw(false, false)
/* When we draw the chart space, that means we draw all the time machines in it. */
for (var i = 0; i < thisObject.timeMachines.length; i++ ) {
var timeMachine = thisObject.timeMachines[i];
timeMachine.draw();
}
for (var i = 0; i < thisObject.timeMachines.length; i++) {
var timeMachine = thisObject.timeMachines[i]
timeMachine.draw()
}
}
function getContainer(point) {
function getContainer (point) {
if (INFO_LOG === true) { logger.write('[INFO] getContainer -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] getContainer -> Entering function."); }
let container;
let container
/* Now we see which is the inner most container that has it */
for (var i = 0; i < this.timeMachines.length; i++) {
container = this.timeMachines[i].getContainer(point);
if (container !== undefined) {
for (var i = 0; i < this.timeMachines.length; i++) {
container = this.timeMachines[i].getContainer(point)
if (container !== undefined) {
/* We found an inner container which has the point. We return it. */
return container;
}
}
return container
}
}
/* The point does not belong to any inner container, so we return the current container. */
return this.container;
}
}
return this.container
}
}
Spaces/FloatingSpace.js
+40 -33
View File
@@ -1,44 +1,51 @@

function newFloatingSpace() {

function newFloatingSpace () {
const MODULE_NAME = 'Floating Space'
const INFO_LOG = false
const ERROR_LOG = true
/*
The Floating Space is the place where floating elements like floatingObjects, live and are rendered.
This space has its own physics which helps with the animation of these objects and also preventing them to overlap.
*/
let thisObject = {
floatingLayer: undefined, // This is the array of floatingObjects being displayed
profileBalls: undefined,
noteSets: undefined,
initialize: initialize
};
let thisObject = {
floatingLayer: undefined, // This is the array of floatingObjects being displayed
profileBalls: undefined,
noteSets: undefined,
initialize: initialize,
finalize: finalize
}
return thisObject;
return thisObject
function initialize(callBackFunction) {
function finalize () {
try {
if (INFO_LOG === true) { logger.write('[INFO] finalize -> Entering function.') }
thisObject.floatingLayer = newFloatingLayer();
thisObject.floatingLayer.initialize(onFloatingLayerInitialized);
function onFloatingLayerInitialized(err) {
thisObject.profileBalls = newProfileBalls();
thisObject.profileBalls.initialize(thisObject.floatingLayer, onProfileBallsInitialized);
function onProfileBallsInitialized(err) {
thisObject.noteSets = newNoteSets();
thisObject.noteSets.initialize(thisObject.floatingLayer, onNoteSetsInitialized);
function onNoteSetsInitialized(err) {
}
}
}
thisObject.floatingLayer.finalize()
thisObject.profileBalls.finalize()
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] finalize -> err = ' + err) }
}
}
function initialize (callBackFunction) {
thisObject.floatingLayer = newFloatingLayer()
thisObject.floatingLayer.initialize(onFloatingLayerInitialized)
function onFloatingLayerInitialized (err) {
thisObject.profileBalls = newProfileBalls()
thisObject.profileBalls.initialize(thisObject.floatingLayer, onProfileBallsInitialized)
function onProfileBallsInitialized (err) {
thisObject.noteSets = newNoteSets()
thisObject.noteSets.initialize(thisObject.floatingLayer, onNoteSetsInitialized)
function onNoteSetsInitialized (err) {
}
}
}
}
}
Spaces/PanelsSpace.js
+80 -93
View File
@@ -1,114 +1,104 @@
/*
/*
The Panel Space y the place wehre all panels live, no matter who create them.
The Panel Space y the place wehre all panels live, no matter who create them.
*/
function newPanelsSpace() {
function newPanelsSpace () {
var thisObject = {
container: undefined,
createNewPanel: createNewPanel,
destroyPanel: destroyPanel,
getPanel: getPanel,
draw: draw,
panels: [],
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
}
var thisObject = {
container: undefined,
createNewPanel: createNewPanel,
destroyPanel: destroyPanel,
getPanel: getPanel,
draw: draw,
panels: [],
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
};
var container = newContainer()
container.initialize()
thisObject.container = container
thisObject.container.isDraggeable = false
var container = newContainer();
container.initialize();
thisObject.container = container;
thisObject.container.isDraggeable = false;
container.displacement.containerName = 'Panels Space'
container.frame.containerName = 'Panels Space'
container.displacement.containerName = "Panels Space";
container.frame.containerName = "Panels Space";
return thisObject
return thisObject;
function initialize() {
function initialize () {
/* The space does not create any Panels for itself, it just sits and waits others need panels. */
}
}
function createNewPanel(pType, pParameters) {
function createNewPanel (pType, pParameters) {
let panel
let panel;
switch (pType) {
switch (pType) {
case "Time Control Panel":
{
panel = newTimeControlPanel();
panel.initialize();
break;
}
case "Products Panel":
{
panel = newProductsPanel();
panel.initialize();
break;
}
case "Plotter Panel":
{
panel = getNewPlotterPanel(pParameters.devTeam, pParameters.plotterCodeName, pParameters.moduleCodeName, pParameters.panelCodeName);
panel.initialize();
break;
}
case 'Time Control Panel':
{
panel = newTimeControlPanel()
panel.initialize()
break
}
thisObject.panels.push(panel);
panel.handle = Math.floor((Math.random() * 10000000) + 1);
return panel.handle;
}
function destroyPanel(pPanelHandle) {
for (let i = 0; i < thisObject.panels.length; i++) {
let panel = thisObject.panels[i];
if (panel.handle === pPanelHandle) {
thisObject.panels.splice(i, 1); // Delete item from array.
return;
}
case 'Products Panel':
{
panel = newProductsPanel()
panel.initialize()
break
}
case 'Plotter Panel':
{
panel = getNewPlotterPanel(pParameters.devTeam, pParameters.plotterCodeName, pParameters.moduleCodeName, pParameters.panelCodeName)
panel.initialize()
break
}
}
function getPanel(pPanelHandle) {
thisObject.panels.push(panel)
for (let i = 0; i < thisObject.panels.length; i++) {
panel.handle = Math.floor((Math.random() * 10000000) + 1)
let panel = thisObject.panels[i];
return panel.handle
}
if (panel.handle === pPanelHandle) {
return panel;
}
}
function destroyPanel (pPanelHandle) {
for (let i = 0; i < thisObject.panels.length; i++) {
let panel = thisObject.panels[i]
if (panel.handle === pPanelHandle) {
thisObject.panels.splice(i, 1) // Delete item from array.
return
}
}
}
function draw() {
function getPanel (pPanelHandle) {
for (let i = 0; i < thisObject.panels.length; i++) {
let panel = thisObject.panels[i]
thisObject.container.frame.draw(false, false);
if (panel.handle === pPanelHandle) {
return panel
}
}
}
function draw () {
thisObject.container.frame.draw(false, false)
/* When we draw a time machine, that means also to draw all the charts in it. */
for (var i = 0; i < thisObject.panels.length; i++) {
let panel = thisObject.panels[i];
panel.draw();
}
for (var i = 0; i < thisObject.panels.length; i++) {
let panel = thisObject.panels[i]
panel.draw()
}
}
function getContainer(point) {
let container;
function getContainer (point) {
let container
/*
@@ -117,21 +107,18 @@ function newPanelsSpace() {
*/
for (var i = thisObject.panels.length - 1; i >= 0; i--) {
container = thisObject.panels[i].getContainer(point);
if (container !== undefined) {
for (var i = thisObject.panels.length - 1; i >= 0; i--) {
container = thisObject.panels[i].getContainer(point)
if (container !== undefined) {
/* We found an inner container which has the point. We return it. */
return container;
}
}
return container
}
}
/* The point does not belong to any inner container, so we return the current container. */
return thisObject.container;
}
}
return thisObject.container
}
}
SplashScreen.js
+95 -117
View File
@@ -1,180 +1,158 @@
/*
/*
The Splash Screen is to show some 'loading...' controls while the app is being loaded on the background. After the loading is complete the Splash Screens dissapears for good.
*/
function newSplashScreen() {
function newSplashScreen () {
var thisObject = {
container: undefined,
draw: draw,
timeMachines: [],
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
}
var thisObject = {
container: undefined,
draw: draw,
timeMachines: [],
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
};
var container = newContainer()
container.initialize()
thisObject.container = container
resize()
var container = newContainer();
container.initialize();
thisObject.container = container;
container.displacement.containerName = 'Splash Screen'
container.frame.containerName = 'Splash Screen'
resize();
container.frame.position.x = 0
container.frame.position.y = 0
container.displacement.containerName = "Splash Screen";
container.frame.containerName = "Splash Screen";
container.isDraggeable = false
container.frame.position.x = 0;
container.frame.position.y = 0;
let fadeOutCounter = 0
let opacity = 1
container.isDraggeable = false;
let logo
let canDrawLogo = false
return thisObject
let fadeOutCounter = 0;
let opacity = 1;
function initialize () {
logo = new Image()
let logo;
let canDrawLogo = false;
return thisObject;
function initialize() {
logo = new Image();
logo.onload = onImageLoad;
function onImageLoad() {
canDrawLogo = true;
}
logo.src = window.canvasApp.urlPrefix + "Images/aa-logo.png";
window.canvasApp.eventHandler.listenToEvent("Browser Resized", resize);
logo.onload = onImageLoad
function onImageLoad () {
canDrawLogo = true
}
function resize() {
logo.src = window.canvasApp.urlPrefix + 'Images/aa-logo.png'
thisObject.container.frame.width = browserCanvas.width;
thisObject.container.frame.height = browserCanvas.height;
window.canvasApp.eventHandler.listenToEvent('Browser Resized', resize)
}
function resize () {
thisObject.container.frame.width = browserCanvas.width
thisObject.container.frame.height = browserCanvas.height
}
function draw () {
if (splashScreenNeeded === false) {
stepsInitializationCounter = 100
fadeOutCounter++
if (fadeOutCounter > 20) {
return
}
opacity = opacity - 0.1
}
function draw() {
if (splashScreenNeeded === false) {
stepsInitializationCounter = 100;
fadeOutCounter++;
if (fadeOutCounter > 20) {
return;
}
opacity = opacity - 0.1;
}
thisObject.container.frame.draw(false, false);
thisObject.container.frame.draw(false, false)
/* Set the background. */
browserCanvasContext.beginPath();
browserCanvasContext.beginPath()
browserCanvasContext.rect(0, 0, thisObject.container.frame.width, thisObject.container.frame.height);
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', ' + opacity + ')';
browserCanvasContext.rect(0, 0, thisObject.container.frame.width, thisObject.container.frame.height)
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', ' + opacity + ')'
browserCanvasContext.closePath();
browserCanvasContext.closePath()
browserCanvasContext.fill();
browserCanvasContext.fill()
if (canDrawLogo === false) { return; }
if (canDrawLogo === false) { return }
/* First the AA Logo. */
let imageHeight = 96;
let imageWidth = 480;
let yDisplacement = -50;
let imageHeight = 96
let imageWidth = 480
let yDisplacement = -50
let imagePoint = {
x: thisObject.container.frame.width * 1 / 2 - imageWidth / 2,
y: thisObject.container.frame.height * 1 / 2 - imageHeight / 2 + yDisplacement
};
let imagePoint = {
x: thisObject.container.frame.width * 1 / 2 - imageWidth / 2,
y: thisObject.container.frame.height * 1 / 2 - imageHeight / 2 + yDisplacement
}
imagePoint = thisObject.container.frame.frameThisPoint(imagePoint);
imagePoint = thisObject.container.frame.frameThisPoint(imagePoint)
browserCanvasContext.drawImage(logo, imagePoint.x, imagePoint.y, imageWidth, imageHeight);
browserCanvasContext.drawImage(logo, imagePoint.x, imagePoint.y, imageWidth, imageHeight)
/* Second the % of Advance. */
let label = '' + Math.trunc(stepsInitializationCounter) + ' %';
stepsInitializationCounter = stepsInitializationCounter + 0.5;
let label = '' + Math.trunc(stepsInitializationCounter) + ' %'
stepsInitializationCounter = stepsInitializationCounter + 0.5
if (stepsInitializationCounter > 99) {
if (stepsInitializationCounter > 99) {
splashScreenNeeded = false
stepsInitializationCounter = 99
}
splashScreenNeeded = false;
stepsInitializationCounter = 99;
}
let fontSize = 10
let labelPoint = {
x: thisObject.container.frame.width / 2 - label.length / 2 * fontSize * FONT_ASPECT_RATIO - 25,
y: thisObject.container.frame.height / 2 + fontSize / 2 + fontSize * 0.1 + 80 + yDisplacement
}
let fontSize = 10;
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.PRIMARY
browserCanvasContext.fillStyle = 'rgba(0, 0, 0, ' + opacity + ')'
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y)
let labelPoint = {
x: thisObject.container.frame.width / 2 - label.length / 2 * fontSize * FONT_ASPECT_RATIO - 25,
y: thisObject.container.frame.height / 2 + fontSize / 2 + fontSize * 0.1 + 80 + yDisplacement
};
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.PRIMARY;
browserCanvasContext.fillStyle = 'rgba(0, 0, 0, ' + opacity + ')';
browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y);
let title;
let titlePoint;
let title
let titlePoint
/* Algo Bots Competitions Sub Title */
fontSize = 15;
fontSize = 15
title = "Trading Bots Competitions Platform"
title = 'Trading Bots Competitions Platform'
titlePoint = {
x: thisObject.container.frame.width / 2 - title.length / 2 * fontSize * FONT_ASPECT_RATIO - 20,
y: thisObject.container.frame.height / 2 - fontSize * 2 + 80 + yDisplacement
};
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.PRIMARY;
browserCanvasContext.fillStyle = 'rgba(0, 0, 0, ' + opacity + ')';
browserCanvasContext.fillText(title, titlePoint.x, titlePoint.y);
titlePoint = {
x: thisObject.container.frame.width / 2 - title.length / 2 * fontSize * FONT_ASPECT_RATIO - 20,
y: thisObject.container.frame.height / 2 - fontSize * 2 + 80 + yDisplacement
}
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.PRIMARY
browserCanvasContext.fillStyle = 'rgba(0, 0, 0, ' + opacity + ')'
browserCanvasContext.fillText(title, titlePoint.x, titlePoint.y)
}
function getContainer(point) {
var container;
function getContainer (point) {
var container
/* First we check if this point is inside this space. */
if (this.container.frame.isThisPointHere(point) === true) {
if (this.container.frame.isThisPointHere(point) === true) {
/* Now we see which is the inner most container that has it */
// add validation of inner most containers here.
/* The point does not belong to any inner container, so we return the current container. */
return this.container;
} else {
return this.container
} else {
/* This point does not belong to this space. */
return undefined;
}
return undefined
}
}
}
}
TimeLineCoordinateSystem.js
+75 -103
View File
@@ -1,4 +1,4 @@
/*
/*
This Object object is responsible for defining the coordinate system in a TimeLine.
@@ -7,85 +7,77 @@ The scale on the Y axis depends on the data that wants to be plotted. Usually we
*/
function newTimeLineCoordinateSystem() {
function newTimeLineCoordinateSystem () {
var thisObject = {
min: undefined,
max: undefined,
scale: undefined,
transformThisPoint: transformThisPoint,
transformThisPoint2: transformThisPoint2,
unInverseTransform: unInverseTransform,
inverseTransformUncappedY: inverseTransformUncappedY,
initializeX: initializeX,
initializeY: initializeY,
initialize: initialize
}
var thisObject = {
min: undefined,
max: undefined,
scale: undefined,
transformThisPoint: transformThisPoint,
transformThisPoint2: transformThisPoint2,
unInverseTransform: unInverseTransform,
inverseTransformUncappedY: inverseTransformUncappedY,
initializeX: initializeX,
initializeY: initializeY,
initialize: initialize
};
var min = {
x: 0,
y: 0
}
var min = {
x: 0,
y: 0
};
var max = {
x: 0,
y: 0
}
var max = {
x: 0,
y: 0
};
var scale = {
x: 0,
y: 0
}
var scale = {
x: 0,
y: 0
};
thisObject.min = min
thisObject.max = max
thisObject.scale = scale
thisObject.min = min;
thisObject.max = max;
thisObject.scale = scale;
let maxHeight
let maxHeight;
return thisObject;
function initialize(minValue, maxValue, maxWidth, pMaxHeight) {
return thisObject
function initialize (minValue, maxValue, maxWidth, pMaxHeight) {
/* Defines the min and max value of rate that we are going to transport to the available screen at the center position. */
thisObject.min.x = minValue.x; // * 0.999; // 0.1% less
thisObject.max.x = maxValue.x; // * 1.001; // 0.1% more
thisObject.min.x = minValue.x // * 0.999; // 0.1% less
thisObject.max.x = maxValue.x // * 1.001; // 0.1% more
thisObject.min.y = minValue.y; // * 0.999; // 0.1% less
thisObject.max.y = maxValue.y; // * 1.001; // 0.1% more
thisObject.min.y = minValue.y // * 0.999; // 0.1% less
thisObject.max.y = maxValue.y // * 1.001; // 0.1% more
/* Defines the initial Zoom level at center position. */
thisObject.scale.x = maxWidth / (thisObject.max.x - thisObject.min.x);
thisObject.scale.y = pMaxHeight / (thisObject.max.y - thisObject.min.y);
thisObject.scale.x = maxWidth / (thisObject.max.x - thisObject.min.x)
thisObject.scale.y = pMaxHeight / (thisObject.max.y - thisObject.min.y)
maxHeight = pMaxHeight;
maxHeight = pMaxHeight
}
}
function initializeX (minValue, maxValue, maxWidth) {
thisObject.min.x = minValue.x // * 0.999; // 0.1% less
thisObject.max.x = maxValue.x // * 1.001; // 0.1% more
function initializeX(minValue, maxValue, maxWidth) {
thisObject.scale.x = maxWidth / (thisObject.max.x - thisObject.min.x)
}
thisObject.min.x = minValue.x; // * 0.999; // 0.1% less
thisObject.max.x = maxValue.x; // * 1.001; // 0.1% more
function initializeY (minValue, maxValue, pMaxHeight) {
thisObject.min.y = minValue.y // * 0.999; // 0.1% less
thisObject.max.y = maxValue.y // * 1.001; // 0.1% more
thisObject.scale.x = maxWidth / (thisObject.max.x - thisObject.min.x);
thisObject.scale.y = pMaxHeight / (thisObject.max.y - thisObject.min.y)
}
function initializeY(minValue, maxValue, pMaxHeight) {
thisObject.min.y = minValue.y; // * 0.999; // 0.1% less
thisObject.max.y = maxValue.y; // * 1.001; // 0.1% more
thisObject.scale.y = pMaxHeight / (thisObject.max.y - thisObject.min.y);
maxHeight = pMaxHeight;
}
function transformThisPoint(point) {
maxHeight = pMaxHeight
}
function transformThisPoint (point) {
/*
This is the straigh fordward transformation this object provides. The input is a point on the data set that wants to be plotted in a timeline.
@@ -99,59 +91,39 @@ function newTimeLineCoordinateSystem() {
*/
point = {
x: (point.x - this.min.x) * this.scale.x,
y: maxHeight - (point.y - this.min.y) * this.scale.y
};
return point;
point = {
x: (point.x - this.min.x) * this.scale.x,
y: maxHeight - (point.y - this.min.y) * this.scale.y
}
return point
}
function transformThisPoint2(point) {
point = {
x: (point.x - this.min.x) * this.scale.x,
y: (maxHeight- point.y - this.min.y) * this.scale.y
};
return point;
function transformThisPoint2 (point) {
point = {
x: (point.x - this.min.x) * this.scale.x,
y: (maxHeight - point.y - this.min.y) * this.scale.y
}
return point
}
function unInverseTransform(point, inverseY) {
point = {
x: (point.x / this.scale.x) + this.min.x,
y: (inverseY - point.y) / this.scale.y + this.min.y
};
return point;
function unInverseTransform (point, inverseY) {
point = {
x: (point.x / this.scale.x) + this.min.x,
y: (inverseY - point.y) / this.scale.y + this.min.y
}
return point
}
function inverseTransformUncappedY(point, inverseY) {
point = {
x: (point.x - this.min.x) * this.scale.x,
y: (inverseY - point.y) * this.scale.y
};
return point;
function inverseTransformUncappedY (point, inverseY) {
point = {
x: (point.x - this.min.x) * this.scale.x,
y: (inverseY - point.y) * this.scale.y
}
return point
}
}
TimeMachine.js
+125 -125
View File
@@ -1,180 +1,180 @@
/*
/*
Markets are a function of time. When watching them, end users must be positioned at one particular point in time. The system currently allows users
to position themselves at any time they like.
In the future, it will be usefull to explore markets and compare them at different times simultaneously. Anticipating that future this module exists.
All the charts that depand on a datetime are children of this object Time Machine. In the future we will allow users to have more than one Time Machine,
each one with it own charts, and each one positioned at an especific point in titme.
each one with it own charts, and each one positioned at an especific point in titme.
*/
function newTimeMachine() {
function newTimeMachine () {
const MODULE_NAME = 'Time Machine'
const INFO_LOG = false
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
const MODULE_NAME = "Time Machine";
const INFO_LOG = false;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
let thisObject = {
container: undefined,
draw: draw,
charts: [],
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize,
finalize: finalize
}
let thisObject = {
container: undefined,
draw: draw,
charts: [],
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
};
let container = newContainer()
container.initialize()
thisObject.container = container
thisObject.container.isDraggeable = false
let container = newContainer();
container.initialize();
thisObject.container = container;
thisObject.container.isDraggeable = false;
container.displacement.containerName = 'Time Machine'
container.frame.containerName = 'Time Machine'
container.displacement.containerName = "Time Machine";
container.frame.containerName = "Time Machine";
let controlPanelHandle // We need this to destroy the Panel when this object is itself destroyed or no longer needs it...
let productsPanelHandle // ... also to request a reference to the object for the cases we need it.
let controlPanelHandle; // We need this to destroy the Panel when this object is itself destroyed or no longer needs it...
let productsPanelHandle; // ... also to request a reference to the object for the cases we need it.
return thisObject
return thisObject;
function finalize () {
try {
if (INFO_LOG === true) { logger.write('[INFO] finalize -> Entering function.') }
function initialize(callBackFunction) {
for (let i = 0; i < thisObject.charts.length; i++) {
let chart = thisObject.charts[i]
chart.finalize()
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] finalize -> err = ' + err) }
}
}
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
function initialize (callBackFunction) {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
/* Each Time Machine has a Control Panel. */
controlPanelHandle = canvas.panelsSpace.createNewPanel("Time Control Panel");
let controlPanel = canvas.panelsSpace.getPanel(controlPanelHandle);
controlPanelHandle = canvas.panelsSpace.createNewPanel('Time Control Panel')
let controlPanel = canvas.panelsSpace.getPanel(controlPanelHandle)
productsPanelHandle = canvas.panelsSpace.createNewPanel("Products Panel");
let productsPanel = canvas.panelsSpace.getPanel(productsPanelHandle);
productsPanelHandle = canvas.panelsSpace.createNewPanel('Products Panel')
let productsPanel = canvas.panelsSpace.getPanel(productsPanelHandle)
let iteration = 0;
let iteration = 0
/* First, we initialize the market that we are going to show first on screen. Later all the other markets will be initialized on the background. */
let timelineChart = newTimelineChart();
let timelineChart = newTimelineChart()
timelineChart.container.displacement.parentDisplacement = thisObject.container.displacement;
timelineChart.container.frame.parentFrame = thisObject.container.frame;
timelineChart.container.displacement.parentDisplacement = thisObject.container.displacement
timelineChart.container.frame.parentFrame = thisObject.container.frame
timelineChart.container.parentContainer = thisObject.container;
timelineChart.container.parentContainer = thisObject.container
timelineChart.container.frame.width = thisObject.container.frame.width * 1;
timelineChart.container.frame.height = thisObject.container.frame.height * 1 * canvas.bottomSpace.chartAspectRatio.aspectRatio.y;
timelineChart.container.frame.width = thisObject.container.frame.width * 1
timelineChart.container.frame.height = thisObject.container.frame.height * 1 * canvas.bottomSpace.chartAspectRatio.aspectRatio.y
timelineChart.container.frame.position.x = thisObject.container.frame.width / 2 - timelineChart.container.frame.width / 2;
timelineChart.container.frame.position.y = timelineChart.container.frame.height * 1.5 * iteration;
timelineChart.container.frame.position.x = thisObject.container.frame.width / 2 - timelineChart.container.frame.width / 2
timelineChart.container.frame.position.y = timelineChart.container.frame.height * 1.5 * iteration
timelineChart.initialize(productsPanel, onDefaultMarketInitialized);
timelineChart.initialize(productsPanel, onDefaultMarketInitialized)
iteration++;
iteration++
function onDefaultMarketInitialized(err) {
function onDefaultMarketInitialized (err) {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDefaultMarketInitialized -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDefaultMarketInitialized -> Entering function."); }
if (err.result !== GLOBAL.DEFAULT_OK_RESPONSE.result) {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onDefaultMarketInitialized -> Initialization of the only market failed.') }
if (err.result !== GLOBAL.DEFAULT_OK_RESPONSE.result) {
callBackFunction(err)
return
}
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onDefaultMarketInitialized -> Initialization of the only market failed."); }
thisObject.charts.push(timelineChart)
callBackFunction(err);
return;
}
controlPanel.container.eventHandler.listenToEvent('Datetime Changed', timelineChart.setDatetime, undefined)
timelineChart.container.eventHandler.listenToEvent('Datetime Changed', controlPanel.setDatetime)
thisObject.charts.push(timelineChart);
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE)
controlPanel.container.eventHandler.listenToEvent('Datetime Changed', timelineChart.setDatetime, undefined);
timelineChart.container.eventHandler.listenToEvent('Datetime Changed', controlPanel.setDatetime);
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE);
//initializeTheRestOfTheMarkets();
}
function initializeTheRestOfTheMarkets() {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> initializeTheRestOfTheMarkets -> Entering function."); }
markets.forEach(initializeTimelineChart);
function initializeTimelineChart(item, key, mapObj) {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> initializeTheRestOfTheMarkets -> initializeTimelineChart -> Entering function."); }
if (key === INITIAL_DEFAULT_MARKET) { // We skip this market since it has already been initialized.
return;
}
let timelineChart = newTimelineChart();
timelineChart.container.displacement.parentDisplacement = thisObject.container.displacement;
timelineChart.container.frame.parentFrame = thisObject.container.frame;
timelineChart.container.parentContainer = thisObject.container;
timelineChart.container.frame.width = thisObject.container.frame.width * 1;
timelineChart.container.frame.height = thisObject.container.frame.height * 1 * canvas.bottomSpace.chartAspectRatio.aspectRatio.y;
timelineChart.container.frame.position.x = thisObject.container.frame.width / 2 - timelineChart.container.frame.width / 2;
timelineChart.container.frame.position.y = timelineChart.container.frame.height * 1.5 * iteration;
timelineChart.initialize(productsPanel, finalSteps);
iteration++;
function finalSteps() {
if (INFO_LOG === true) { logger.write("[INFO] initialize -> initializeTheRestOfTheMarkets -> initializeTimelineChart -> finalSteps -> Entering function."); }
thisObject.charts.push(timelineChart);
controlPanel.container.eventHandler.listenToEvent('Datetime Changed', timelineChart.setDatetime, undefined);
timelineChart.container.eventHandler.listenToEvent('Datetime Changed', controlPanel.setDatetime);
}
}
}
// initializeTheRestOfTheMarkets();
}
function draw() {
function initializeTheRestOfTheMarkets () {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> initializeTheRestOfTheMarkets -> Entering function.') }
this.container.frame.draw(false, false);
markets.forEach(initializeTimelineChart)
function initializeTimelineChart (item, key, mapObj) {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> initializeTheRestOfTheMarkets -> initializeTimelineChart -> Entering function.') }
if (key === INITIAL_DEFAULT_MARKET) {
// We skip this market since it has already been initialized.
return
}
let timelineChart = newTimelineChart()
timelineChart.container.displacement.parentDisplacement = thisObject.container.displacement
timelineChart.container.frame.parentFrame = thisObject.container.frame
timelineChart.container.parentContainer = thisObject.container
timelineChart.container.frame.width = thisObject.container.frame.width * 1
timelineChart.container.frame.height = thisObject.container.frame.height * 1 * canvas.bottomSpace.chartAspectRatio.aspectRatio.y
timelineChart.container.frame.position.x = thisObject.container.frame.width / 2 - timelineChart.container.frame.width / 2
timelineChart.container.frame.position.y = timelineChart.container.frame.height * 1.5 * iteration
timelineChart.initialize(productsPanel, finalSteps)
iteration++
function finalSteps () {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> initializeTheRestOfTheMarkets -> initializeTimelineChart -> finalSteps -> Entering function.') }
thisObject.charts.push(timelineChart)
controlPanel.container.eventHandler.listenToEvent('Datetime Changed', timelineChart.setDatetime, undefined)
timelineChart.container.eventHandler.listenToEvent('Datetime Changed', controlPanel.setDatetime)
}
}
}
}
function draw () {
this.container.frame.draw(false, false)
/* When we draw a time machine, that means also to draw all the charts in it. */
for (let i = 0; i < this.charts.length; i++) {
let chart = this.charts[i];
chart.draw();
}
for (let i = 0; i < this.charts.length; i++) {
let chart = this.charts[i]
chart.draw()
}
}
function getContainer(point) {
function getContainer (point) {
if (INFO_LOG === true) { logger.write('[INFO] getContainer -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] getContainer -> Entering function."); }
let container;
let container
/* Now we see which is the inner most container that has it */
for (let i = 0; i < this.charts.length; i++) {
container = this.charts[i].getContainer(point);
if (container !== undefined) {
for (let i = 0; i < this.charts.length; i++) {
container = this.charts[i].getContainer(point)
if (container !== undefined) {
/* We found an inner container which has the point. We return it. */
return container;
}
}
return container
}
}
/* The point does not belong to any inner container, so we return the current container. */
return this.container;
}
}
return this.container
}
}
TimelineChart.js
+326 -372
View File
@@ -1,226 +1,216 @@
function newTimelineChart() {
function newTimelineChart () {
const MODULE_NAME = 'Timeline Chart'
const INFO_LOG = false
const INTENSIVE_LOG = false
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
const MODULE_NAME = "Timeline Chart";
const INFO_LOG = false;
const INTENSIVE_LOG = false;
const ERROR_LOG = true;
const logger = newWebDebugLog();
logger.fileName = MODULE_NAME;
let timeLineCoordinateSystem = newTimeLineCoordinateSystem()
let timeLineCoordinateSystem = newTimeLineCoordinateSystem();
let timePeriod = INITIAL_TIME_PERIOD
let datetime = INITIAL_DATE
let timePeriod = INITIAL_TIME_PERIOD;
let datetime = INITIAL_DATE;
let thisObject = {
setDatetime: setDatetime,
container: undefined,
draw: draw,
getContainer: getContainer,
initialize: initialize,
finalize: finalize
}
let thisObject = {
setDatetime: setDatetime,
container: undefined,
draw: draw,
getContainer: getContainer,
initialize: initialize
};
let container = newContainer()
container.initialize()
thisObject.container = container
let container = newContainer();
container.initialize();
thisObject.container = container;
container.displacement.containerName = 'Timeline Chart'
container.frame.containerName = 'Timeline Chart'
container.displacement.containerName = "Timeline Chart";
container.frame.containerName = "Timeline Chart";
let chartGrid
let breakpointsBar
let chartGrid;
let breakpointsBar;
let initializationReady = false
let initializationReady = false;
let productsPanel;
let productsPanel
/* Background */
let logoAssetA;
let logoAssetB;
let logoExchange;
let logoAA;
let canDrawLogoA = false;
let canDrawLogoB = false;
let canDrawLogoExchange = false;
let canDrawLogoAA = false;
let logoAssetA
let logoAssetB
let logoExchange
let logoAA
let canDrawLogoA = false
let canDrawLogoB = false
let canDrawLogoExchange = false
let canDrawLogoAA = false
let plotterManager;
let plotterManager
return thisObject;
return thisObject
function initialize(pProductsPanel, callBackFunction) {
function finalize () {
try {
if (INFO_LOG === true) { logger.write('[INFO] finalize -> Entering function.') }
try {
plotterManager.finalize()
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] finalize -> err = ' + err) }
}
}
if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); }
function initialize (pProductsPanel, callBackFunction) {
try {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> Entering function.') }
/* We load the logow we will need for the background. */
logoA = new Image();
logoB = new Image();
logoExchange = new Image();
logoAA = new Image();
logoA = new Image()
logoB = new Image()
logoExchange = new Image()
logoAA = new Image()
logoA.onload = onImageALoaded;
logoA.onload = onImageALoaded
function onImageALoaded() {
canDrawLogoA = true;
}
function onImageALoaded () {
canDrawLogoA = true
}
logoB.onload = onImageBLoaded;
logoB.onload = onImageBLoaded
function onImageBLoaded() {
canDrawLogoB = true;
}
function onImageBLoaded () {
canDrawLogoB = true
}
logoExchange.onload = onImageExchangeLoaded;
logoExchange.onload = onImageExchangeLoaded
function onImageExchangeLoaded() {
canDrawLogoExchange = true;
}
function onImageExchangeLoaded () {
canDrawLogoExchange = true
}
logoAA.onload = onImageAALoaded;
logoAA.onload = onImageAALoaded
function onImageAALoaded() {
canDrawLogoAA = true;
}
function onImageAALoaded () {
canDrawLogoAA = true
}
logoA.src = window.canvasApp.urlPrefix + "Images/tether-logo-background.png";
logoB.src = window.canvasApp.urlPrefix + "Images/bitcoin-logo-background.png";
logoExchange.src = window.canvasApp.urlPrefix + "Images/poloniex-logo-background.png";
logoAA.src = window.canvasApp.urlPrefix + "Images/aa-logo-background.png";
logoA.src = window.canvasApp.urlPrefix + 'Images/tether-logo-background.png'
logoB.src = window.canvasApp.urlPrefix + 'Images/bitcoin-logo-background.png'
logoExchange.src = window.canvasApp.urlPrefix + 'Images/poloniex-logo-background.png'
logoAA.src = window.canvasApp.urlPrefix + 'Images/aa-logo-background.png'
/* Remember the Products Panel */
productsPanel = pProductsPanel;
productsPanel = pProductsPanel
chartGrid = newChartGrid();
chartGrid.initialize();
chartGrid = newChartGrid()
chartGrid.initialize()
breakpointsBar = newBreakpointsBar();
breakpointsBar.initialize(container, timeLineCoordinateSystem);
breakpointsBar = newBreakpointsBar()
breakpointsBar.initialize(container, timeLineCoordinateSystem)
recalculateScale()
// moveViewPortToCurrentDatetime();
moveToUserPosition(container, timeLineCoordinateSystem)
timePeriod = INITIAL_TIME_PERIOD
datetime = INITIAL_DATE
recalculateScale();
//moveViewPortToCurrentDatetime();
moveToUserPosition(container, timeLineCoordinateSystem);
timePeriod = INITIAL_TIME_PERIOD;
datetime = INITIAL_DATE;
/* Event Subscriptions - we need this events to be fired first here and then in active Plotters. */
viewPort.eventHandler.listenToEvent("Offset Changed", onOffsetChanged);
viewPort.eventHandler.listenToEvent("Zoom Changed", onZoomChanged);
viewPort.eventHandler.listenToEvent('Offset Changed', onOffsetChanged)
viewPort.eventHandler.listenToEvent('Zoom Changed', onZoomChanged)
/* Initialize the Plotter Manager */
plotterManager = newPlottersManager();
plotterManager = newPlottersManager()
plotterManager.container.displacement.parentDisplacement = thisObject.container.displacement;
plotterManager.container.frame.parentFrame = thisObject.container.frame;
plotterManager.container.displacement.parentDisplacement = thisObject.container.displacement
plotterManager.container.frame.parentFrame = thisObject.container.frame
plotterManager.container.parentContainer = thisObject.container;
plotterManager.container.parentContainer = thisObject.container
plotterManager.container.frame.width = thisObject.container.frame.width;
plotterManager.container.frame.height = thisObject.container.frame.height;
plotterManager.container.frame.width = thisObject.container.frame.width
plotterManager.container.frame.height = thisObject.container.frame.height
plotterManager.container.frame.position.x = thisObject.container.frame.position.x;
plotterManager.container.frame.position.y = thisObject.container.frame.position.y;
plotterManager.container.frame.position.x = thisObject.container.frame.position.x
plotterManager.container.frame.position.y = thisObject.container.frame.position.y
plotterManager.initialize(pProductsPanel, onPlotterManagerReady);
plotterManager.initialize(pProductsPanel, onPlotterManagerReady)
function onPlotterManagerReady(err) {
function onPlotterManagerReady (err) {
if (INFO_LOG === true) { logger.write('[INFO] initialize -> onPlotterManagerReady -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] initialize -> onPlotterManagerReady -> Entering function."); }
if (err.result !== GLOBAL.DEFAULT_OK_RESPONSE.result) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> onPlotterManagerReady -> Plotter Manager Initialization Failed. ') }
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> onPlotterManagerReady -> err.message = ' + err.message) }
if (err.result !== GLOBAL.DEFAULT_OK_RESPONSE.result) {
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
return
}
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onPlotterManagerReady -> Plotter Manager Initialization Failed. "); }
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> onPlotterManagerReady -> err.message = " + err.message); }
initializationReady = true
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE)
return
}
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
return;
}
canvas.bottomSpace.chartAspectRatio.container.eventHandler.listenToEvent('Chart Aspect Ratio Changed', onAspectRatioChanged)
initializationReady = true;
callBackFunction(GLOBAL.DEFAULT_OK_RESPONSE);
return;
}
function onAspectRatioChanged (pAspectRatio) {
thisObject.container.frame.height = CHART_SPACE_HEIGHT * pAspectRatio.y
recalculateScale()
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> err = ' + err) }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE)
}
}
canvas.bottomSpace.chartAspectRatio.container.eventHandler.listenToEvent("Chart Aspect Ratio Changed", onAspectRatioChanged);
function onAspectRatioChanged(pAspectRatio) {
function onZoomChanged (event) {
if (INFO_LOG === true) { logger.write('[INFO] onZoomChanged -> Entering function.') }
thisObject.container.frame.height = CHART_SPACE_HEIGHT * pAspectRatio.y;
recalculateScale();
if (initializationReady === true) {
let currentTimePeriod = timePeriod
}
} catch (err) {
if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err = " + err); }
callBackFunction(GLOBAL.DEFAULT_FAIL_RESPONSE);
}
}
function onZoomChanged(event) {
if (INFO_LOG === true) { logger.write("[INFO] onZoomChanged -> Entering function."); }
if (initializationReady === true) {
let currentTimePeriod = timePeriod;
timePeriod = recalculatePeriod(event.newLevel);
timePeriod = recalculatePeriod(event.newLevel)
/* If the period changes, we need to spread the word in cascade towards all the depending objects. */
if (timePeriod !== currentTimePeriod) {
if (timePeriod !== currentTimePeriod) {
plotterManager.setTimePeriod(timePeriod)
}
plotterManager.setTimePeriod(timePeriod);
recalculateCurrentDatetime()
}
saveUserPosition(thisObject.container, timeLineCoordinateSystem)
}
}
recalculateCurrentDatetime();
saveUserPosition(thisObject.container, timeLineCoordinateSystem);
}
}
function setDatetime(pDatetime) {
if (INFO_LOG === true) { logger.write("[INFO] setDatetime -> Entering function."); }
function setDatetime (pDatetime) {
if (INFO_LOG === true) { logger.write('[INFO] setDatetime -> Entering function.') }
/* This function is used when the time is changed through the user interface, but without zooming or panning. */
/* No matter if the day changed or not, we need to inform all visible Plotters. */
if (thisObject.container.frame.isInViewPort()) {
if (thisObject.container.frame.isInViewPort()) {
plotterManager.setDatetime(pDatetime)
plotterManager.positionAtDatetime(pDatetime)
breakpointsBar.setDatetime(pDatetime)
}
}
plotterManager.setDatetime(pDatetime);
plotterManager.positionAtDatetime(pDatetime);
breakpointsBar.setDatetime(pDatetime);
}
}
function onOffsetChanged () {
if (INFO_LOG === true) { logger.write('[INFO] onOffsetChanged -> Entering function.') }
function onOffsetChanged() {
if (initializationReady === true) {
if (thisObject.container.frame.isInViewPort()) {
recalculateCurrentDatetime()
saveUserPosition(thisObject.container, timeLineCoordinateSystem)
}
}
}
if (INFO_LOG === true) { logger.write("[INFO] onOffsetChanged -> Entering function."); }
if (initializationReady === true) {
if (thisObject.container.frame.isInViewPort()) {
recalculateCurrentDatetime();
saveUserPosition(thisObject.container, timeLineCoordinateSystem);
}
}
}
function recalculateCurrentDatetime() {
if (INFO_LOG === true) { logger.write("[INFO] recalculateCurrentDatetime -> Entering function."); }
function recalculateCurrentDatetime () {
if (INFO_LOG === true) { logger.write('[INFO] recalculateCurrentDatetime -> Entering function.') }
/*
@@ -229,298 +219,262 @@
*/
let center = {
x: (viewPort.visibleArea.bottomRight.x - viewPort.visibleArea.bottomLeft.x) / 2,
y: (viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topRight.y) / 2
};
let center = {
x: (viewPort.visibleArea.bottomRight.x - viewPort.visibleArea.bottomLeft.x) / 2,
y: (viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topRight.y) / 2
}
center = unTransformThisPoint(center, thisObject.container);
center = timeLineCoordinateSystem.unInverseTransform(center, thisObject.container.frame.height);
center = unTransformThisPoint(center, thisObject.container)
center = timeLineCoordinateSystem.unInverseTransform(center, thisObject.container.frame.height)
let newDate = new Date(0);
newDate.setUTCSeconds(center.x / 1000);
let newDate = new Date(0)
newDate.setUTCSeconds(center.x / 1000)
datetime = newDate;
datetime = newDate
plotterManager.setDatetime(datetime);
plotterManager.setDatetime(datetime)
breakpointsBar.setDatetime(datetime);
breakpointsBar.setDatetime(datetime)
thisObject.container.eventHandler.raiseEvent("Datetime Changed", datetime);
}
thisObject.container.eventHandler.raiseEvent('Datetime Changed', datetime)
}
function getContainer(point) {
function getContainer (point) {
if (INFO_LOG === true) { logger.write('[INFO] getContainer -> Entering function.') }
if (INFO_LOG === true) { logger.write("[INFO] getContainer -> Entering function."); }
let container
let container;
container = chartGrid.getContainer(point)
container = chartGrid.getContainer(point);
if (container !== undefined) { return container }
if (container !== undefined) { return container;}
container = breakpointsBar.getContainer(point)
container = breakpointsBar.getContainer(point);
return container
}
return container;
function recalculateScale () {
if (INFO_LOG === true) { logger.write('[INFO] recalculateScale -> Entering function.') }
}
let minValue = {
x: EARLIEST_DATE.valueOf(),
y: 0
}
function recalculateScale() {
let maxValue = {
x: MAX_PLOTABLE_DATE.valueOf(),
y: nextPorwerOf10(USDT_BTC_HTH) / 4
}
if (INFO_LOG === true) { logger.write("[INFO] recalculateScale -> Entering function."); }
let minValue = {
x: EARLIEST_DATE.valueOf(),
y: 0
};
let maxValue = {
x: MAX_PLOTABLE_DATE.valueOf(),
y: nextPorwerOf10(USDT_BTC_HTH) / 4
};
timeLineCoordinateSystem.initialize(
timeLineCoordinateSystem.initialize(
minValue,
maxValue,
thisObject.container.frame.width,
thisObject.container.frame.height
);
)
}
}
function tooTiny () {
if (INTENSIVE_LOG === true) { logger.write('[INFO] tooTiny -> Entering function.') }
function tooTiny() {
if (viewPort.zoomLevel < Math.trunc(-28.25 * 100) / 100) {
return true
} else {
return false
}
}
if (INTENSIVE_LOG === true) { logger.write("[INFO] tooTiny -> Entering function."); }
function tooSmall () {
if (INFO_LOG === true) { logger.write('[INFO] tooSmall -> Entering function.') }
if (viewPort.zoomLevel < Math.trunc(-28.25 * 100) / 100) {
return true;
} else {
return false;
}
if (viewPort.zoomLevel < Math.trunc(-27.25 * 100) / 100) {
return true
} else {
return false
}
}
}
function draw () {
if (INTENSIVE_LOG === true) { logger.write('[INFO] draw -> Entering function.') }
function tooSmall() {
if (thisObject.container.frame.isInViewPort()) {
this.container.frame.draw()
if (INFO_LOG === true) { logger.write("[INFO] tooSmall -> Entering function."); }
drawBackground()
if (viewPort.zoomLevel < Math.trunc(-27.25 * 100) / 100) {
return true;
} else {
return false;
}
chartGrid.draw(thisObject.container, timeLineCoordinateSystem)
}
plotterManager.draw()
function draw() {
breakpointsBar.draw()
}
}
if (INTENSIVE_LOG === true) { logger.write("[INFO] draw -> Entering function."); }
function drawBackground () {
if (INTENSIVE_LOG === true) { logger.write('[INFO] drawBackground -> Entering function.') }
if (thisObject.container.frame.isInViewPort()) {
if (canDrawLogoA === false || canDrawLogoB === false || canDrawLogoExchange === false || canDrawLogoAA === false) { return }
this.container.frame.draw();
let backgroundLogoPoint1
let backgroundLogoPoint2
drawBackground();
let imageHeight = 42
let imageWidth = 150
chartGrid.draw(thisObject.container, timeLineCoordinateSystem);
let MAX_COLUMNS = 16
let MAX_ROWS = 7
let Y_TOP_MARGIN = 30
plotterManager.draw();
let point1 = {
x: viewPort.visibleArea.topLeft.x,
y: viewPort.visibleArea.topLeft.y
}
breakpointsBar.draw();
}
}
backgroundLogoPoint1 = {
x: getDateFromPoint(point1, thisObject.container, timeLineCoordinateSystem).valueOf(),
y: getRateFromPoint(point1, thisObject.container, timeLineCoordinateSystem)
}
function drawBackground() {
let point2 = {
x: viewPort.visibleArea.topLeft.x + imageWidth * 8,
y: viewPort.visibleArea.topLeft.y
}
if (INTENSIVE_LOG === true) { logger.write("[INFO] drawBackground -> Entering function."); }
backgroundLogoPoint2 = {
x: getDateFromPoint(point2, thisObject.container, timeLineCoordinateSystem).valueOf(),
y: getRateFromPoint(point2, thisObject.container, timeLineCoordinateSystem)
}
if (canDrawLogoA === false || canDrawLogoB === false || canDrawLogoExchange === false || canDrawLogoAA === false) { return; }
let currentCorner = {
x: getDateFromPoint(viewPort.visibleArea.topLeft, thisObject.container, timeLineCoordinateSystem).valueOf(),
y: getRateFromPoint(viewPort.visibleArea.topLeft, thisObject.container, timeLineCoordinateSystem)
}
let backgroundLogoPoint1;
let backgroundLogoPoint2;
currentCorner.x = Math.trunc(currentCorner.x / (backgroundLogoPoint2.x - backgroundLogoPoint1.x)) * (backgroundLogoPoint2.x - backgroundLogoPoint1.x)
let imageHeight = 42;
let imageWidth = 150;
let rowHight = (viewPort.visibleArea.bottomLeft.y - viewPort.visibleArea.topLeft.y) / 4.5
let MAX_COLUMNS = 16;
let MAX_ROWS = 7;
let Y_TOP_MARGIN = 30;
imagePoint = timeLineCoordinateSystem.transformThisPoint(currentCorner)
imagePoint = transformThisPoint(imagePoint, thisObject.container)
let point1 = {
x: viewPort.visibleArea.topLeft.x,
y: viewPort.visibleArea.topLeft.y
};
let offSet = 0
backgroundLogoPoint1 = {
x: getDateFromPoint(point1, thisObject.container, timeLineCoordinateSystem).valueOf(),
y: getRateFromPoint(point1, thisObject.container, timeLineCoordinateSystem)
};
for (let j = 0; j < MAX_ROWS; j++) {
if (offSet === -imageWidth * 8) {
offSet = -imageWidth * 4 - imageWidth
} else {
offSet = -imageWidth * 8
}
let point2 = {
x: viewPort.visibleArea.topLeft.x + imageWidth * 8,
y: viewPort.visibleArea.topLeft.y
};
for (let i = 0; i < MAX_COLUMNS; i = i + 4) {
let logo = logoA
backgroundLogoPoint2 = {
x: getDateFromPoint(point2, thisObject.container, timeLineCoordinateSystem).valueOf(),
y: getRateFromPoint(point2, thisObject.container, timeLineCoordinateSystem)
};
browserCanvasContext.drawImage(logo, imagePoint.x + i * imageWidth * 2 + offSet, imagePoint.y + j * rowHight + Y_TOP_MARGIN, imageWidth, imageHeight)
}
}
let currentCorner = {
x: getDateFromPoint(viewPort.visibleArea.topLeft, thisObject.container, timeLineCoordinateSystem).valueOf(),
y: getRateFromPoint(viewPort.visibleArea.topLeft, thisObject.container, timeLineCoordinateSystem)
};
offSet = 0
currentCorner.x = Math.trunc(currentCorner.x / (backgroundLogoPoint2.x - backgroundLogoPoint1.x)) * (backgroundLogoPoint2.x - backgroundLogoPoint1.x);
for (let j = 0; j < MAX_ROWS; j++) {
if (offSet === -imageWidth * 8) {
offSet = -imageWidth * 4 - imageWidth
} else {
offSet = -imageWidth * 8
}
let rowHight = (viewPort.visibleArea.bottomLeft.y - viewPort.visibleArea.topLeft.y) / 4.5;
for (let i = 1; i < MAX_COLUMNS; i = i + 4) {
let logo = logoB
imagePoint = timeLineCoordinateSystem.transformThisPoint(currentCorner);
imagePoint = transformThisPoint(imagePoint, thisObject.container);
browserCanvasContext.drawImage(logo, imagePoint.x + i * imageWidth * 2 + offSet, imagePoint.y + j * rowHight + Y_TOP_MARGIN, imageWidth, imageHeight)
}
}
let offSet = 0;
offSet = 0
for (let j = 0; j < MAX_ROWS; j++) {
if (offSet === -imageWidth * 8) {
offSet = -imageWidth * 4 - imageWidth
} else {
offSet = -imageWidth * 8
}
for (let j = 0; j < MAX_ROWS; j++) {
for (let i = 2; i < MAX_COLUMNS; i = i + 4) {
let logo = logoExchange
if (offSet === -imageWidth * 8) {
browserCanvasContext.drawImage(logo, imagePoint.x + i * imageWidth * 2 + offSet, imagePoint.y + j * rowHight + Y_TOP_MARGIN, imageWidth, imageHeight)
}
}
offSet = -imageWidth * 4 - imageWidth;
offSet = 0
} else {
offSet = -imageWidth * 8;
}
for (let j = 0; j < MAX_ROWS; j++) {
if (offSet === -imageWidth * 8) {
offSet = -imageWidth * 4 - imageWidth
} else {
offSet = -imageWidth * 8
}
for (let i = 0; i < MAX_COLUMNS; i = i + 4) {
for (let i = 3; i < MAX_COLUMNS; i = i + 4) {
let logo = logoAA
let logo = logoA;
browserCanvasContext.drawImage(logo, imagePoint.x + i * imageWidth * 2 + offSet, imagePoint.y + j * rowHight + Y_TOP_MARGIN, imageWidth, imageHeight);
}
}
offSet = 0;
for (let j = 0; j < MAX_ROWS; j++) {
if (offSet === -imageWidth * 8) {
offSet = -imageWidth * 4 - imageWidth;
} else {
offSet = -imageWidth * 8;
}
for (let i = 1; i < MAX_COLUMNS; i = i + 4) {
let logo = logoB;
browserCanvasContext.drawImage(logo, imagePoint.x + i * imageWidth * 2 + offSet, imagePoint.y + j * rowHight + Y_TOP_MARGIN, imageWidth, imageHeight);
}
}
offSet = 0;
for (let j = 0; j < MAX_ROWS; j++) {
if (offSet === -imageWidth * 8) {
offSet = -imageWidth * 4 - imageWidth;
} else {
offSet = -imageWidth * 8;
}
for (let i = 2; i < MAX_COLUMNS; i = i + 4) {
let logo = logoExchange;
browserCanvasContext.drawImage(logo, imagePoint.x + i * imageWidth * 2 + offSet, imagePoint.y + j * rowHight + Y_TOP_MARGIN, imageWidth, imageHeight);
}
}
offSet = 0;
for (let j = 0; j < MAX_ROWS; j++) {
if (offSet === -imageWidth * 8) {
offSet = -imageWidth * 4 - imageWidth;
} else {
offSet = -imageWidth * 8;
}
for (let i = 3; i < MAX_COLUMNS; i = i + 4) {
let logo = logoAA;
browserCanvasContext.drawImage(logo, imagePoint.x + i * imageWidth * 2 + offSet, imagePoint.y + j * rowHight + Y_TOP_MARGIN, imageWidth, imageHeight);
}
}
browserCanvasContext.drawImage(logo, imagePoint.x + i * imageWidth * 2 + offSet, imagePoint.y + j * rowHight + Y_TOP_MARGIN, imageWidth, imageHeight)
}
}
/* We will paint some transparent background here. */
let opacity = "0.9";
let opacity = '0.9'
let fromPoint = {
x: 0,
y: 0
};
let fromPoint = {
x: 0,
y: 0
}
let toPoint = {
x: 0,
y: thisObject.container.frame.height
};
let toPoint = {
x: 0,
y: thisObject.container.frame.height
}
fromPoint = transformThisPoint(fromPoint, thisObject.container);
toPoint = transformThisPoint(toPoint, thisObject.container);
fromPoint = transformThisPoint(fromPoint, thisObject.container)
toPoint = transformThisPoint(toPoint, thisObject.container)
browserCanvasContext.beginPath();
browserCanvasContext.beginPath()
browserCanvasContext.rect(viewPort.visibleArea.topLeft.x, fromPoint.y, viewPort.visibleArea.topRight.x - viewPort.visibleArea.topLeft.x, toPoint.y - fromPoint.y);
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', ' + opacity + ')';
browserCanvasContext.rect(viewPort.visibleArea.topLeft.x, fromPoint.y, viewPort.visibleArea.topRight.x - viewPort.visibleArea.topLeft.x, toPoint.y - fromPoint.y)
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', ' + opacity + ')'
browserCanvasContext.closePath();
browserCanvasContext.closePath()
browserCanvasContext.fill();
browserCanvasContext.fill()
}
}
function moveViewPortToCurrentDatetime () {
if (INFO_LOG === true) { logger.write('[INFO] moveViewPortToCurrentDatetime -> Entering function.') }
function moveViewPortToCurrentDatetime() {
if (INFO_LOG === true) { logger.write("[INFO] moveViewPortToCurrentDatetime -> Entering function."); }
let targetPoint = {
x: datetime.valueOf(),
y: 0 // we wont touch the y axis here.
};
let targetPoint = {
x: datetime.valueOf(),
y: 0 // we wont touch the y axis here.
}
/* Lets put this point in the coordinate system of the viewPort */
targetPoint = timeLineCoordinateSystem.transformThisPoint(targetPoint);
targetPoint = transformThisPoint(targetPoint, thisObject.container);
targetPoint = timeLineCoordinateSystem.transformThisPoint(targetPoint)
targetPoint = transformThisPoint(targetPoint, thisObject.container)
/* Lets get the point on the viewPort coordinate system of the center of the visible screen */
let center = {
x: (viewPort.visibleArea.bottomRight.x - viewPort.visibleArea.bottomLeft.x) / 2,
y: (viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topRight.y) / 2
};
let center = {
x: (viewPort.visibleArea.bottomRight.x - viewPort.visibleArea.bottomLeft.x) / 2,
y: (viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topRight.y) / 2
}
/* Lets calculate the displace vector, from the point we want at the center, to the current center. */
let displaceVector = {
x: center.x - targetPoint.x,
y: 0
};
viewPort.displace(displaceVector);
}
}
let displaceVector = {
x: center.x - targetPoint.x,
y: 0
}
viewPort.displace(displaceVector)
}
}
TopSpace/CompanyLogo.js
+56 -65
View File
@@ -1,84 +1,75 @@

function newCompanyLogo() {

function newCompanyLogo () {
var thisObject = {
container: undefined,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
}
var thisObject = {
container: undefined,
draw: draw,
getContainer: getContainer, // returns the inner most container that holds the point received by parameter.
initialize: initialize
};
var container = newContainer()
container.initialize()
thisObject.container = container
var container = newContainer();
container.initialize();
thisObject.container = container;
thisObject.container.frame.width = 150
thisObject.container.frame.height = TOP_SPACE_HEIGHT
thisObject.container.frame.width = 150;
thisObject.container.frame.height = TOP_SPACE_HEIGHT;
container.frame.position.x = 0
container.frame.position.y = 0
container.frame.position.x = 0;
container.frame.position.y = 0;
container.isDraggeable = false
container.isDraggeable = false;
let logo
let canDrawLogo = false
let logo;
let canDrawLogo = false;
return thisObject;
function initialize() {
if (window.canvasApp.executingAt === 'Master App') {
currentLabel = "";
return;
}
logo = new Image();
logo.onload = onImageLoad;
function onImageLoad() {
canDrawLogo = true;
}
logo.src = window.canvasApp.urlPrefix + "Images/aa-logo-dark-8.png";
return thisObject
function initialize () {
if (window.canvasApp.executingAt === 'Master App') {
currentLabel = ''
return
}
function getContainer(point) {
logo = new Image()
let container;
logo.onload = onImageLoad
function onImageLoad () {
canDrawLogo = true
}
logo.src = window.canvasApp.urlPrefix + 'Images/aa-logo-dark-8.png'
}
function getContainer (point) {
let container
/* First we check if this point is inside this object UI. */
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container;
} else {
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container
} else {
/* This point does not belong to this space. */
return undefined;
}
return undefined
}
}
function draw () {
thisObject.container.frame.draw(false, false)
if (canDrawLogo === false) { return }
let imageHeight = 24
let imageWidth = 120
let imagePoint = {
x: 10,
y: thisObject.container.frame.height / 2 - imageHeight / 2
}
function draw() {
imagePoint = thisObject.container.frame.frameThisPoint(imagePoint)
thisObject.container.frame.draw(false, false);
if (canDrawLogo === false) { return;}
let imageHeight = 24;
let imageWidth = 120;
let imagePoint = {
x: 10,
y: thisObject.container.frame.height / 2 - imageHeight / 2
};
imagePoint = thisObject.container.frame.frameThisPoint(imagePoint);
browserCanvasContext.drawImage(logo, imagePoint.x, imagePoint.y, imageWidth, imageHeight);
}
}
browserCanvasContext.drawImage(logo, imagePoint.x, imagePoint.y, imageWidth, imageHeight)
}
}
TopSpace/EndUser.js
+57 -69
View File
@@ -1,96 +1,84 @@

function newEndUser() {

function newEndUser () {
let thisObject = {
container: undefined,
draw: draw,
getContainer: getContainer,
initialize: initialize
}
let thisObject = {
container: undefined,
draw: draw,
getContainer: getContainer,
initialize: initialize
};
let container = newContainer()
container.initialize()
thisObject.container = container
let container = newContainer();
container.initialize();
thisObject.container = container;
thisObject.container.frame.width = 200
thisObject.container.frame.height = BOTTOM_SPACE_HEIGHT
thisObject.container.frame.width = 200;
thisObject.container.frame.height = BOTTOM_SPACE_HEIGHT;
container.frame.position.x = viewPort.visibleArea.topRight.x - thisObject.container.frame.width * 5
container.frame.position.y = viewPort.visibleArea.bottomLeft.y
container.frame.position.x = viewPort.visibleArea.topRight.x - thisObject.container.frame.width * 5;
container.frame.position.y = viewPort.visibleArea.bottomLeft.y;
container.isDraggeable = false
container.isDraggeable = false;
return thisObject
return thisObject;
function initialize() {
let storedUser = window.localStorage.getItem('loggedInUser');
if (storedUser === null || storedUser === "") {
function initialize () {
let storedUser = window.localStorage.getItem('loggedInUser')
if (storedUser === null || storedUser === '') {
// User is currently not logged in.
window.USER_LOGGED_IN = "";
return;
}
window.USER_LOGGED_IN = ''
return
}
let loggedInUser = JSON.parse(storedUser);
let loggedInUser = JSON.parse(storedUser)
window.USER_LOGGED_IN = loggedInUser.alias;
window.USER_LOGGED_IN = loggedInUser.alias
/* Here we will rearrange the storage permissions array into a map, so that it can be easily consumed when needed. */
let permissionsMap = new Map;
let permissionsMap = new Map()
for (i = 0; i < window.USER_PROFILE.storagePermissions.length; i++) {
let permission = window.USER_PROFILE.storagePermissions[i];
permissionsMap.set(permission[0], permission[1]);
}
window.USER_PROFILE.storagePermissions = permissionsMap;
for (i = 0; i < window.USER_PROFILE.storagePermissions.length; i++) {
let permission = window.USER_PROFILE.storagePermissions[i]
permissionsMap.set(permission[0], permission[1])
}
function getContainer(point) {
window.USER_PROFILE.storagePermissions = permissionsMap
}
let container;
function getContainer (point) {
let container
/* First we check if this point is inside this object UI. */
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container;
} else {
if (thisObject.container.frame.isThisPointHere(point, true) === true) {
return this.container
} else {
/* This point does not belong to this space. */
return undefined;
}
return undefined
}
}
function draw () {
return // nothing to show
thisObject.container.frame.draw(false, false)
let fontSize = 12
let label = window.USER_LOGGED_IN
if (label === undefined) { label = '' };
let point = {
x: thisObject.container.frame.width * 1 / 3,
y: (thisObject.container.frame.height / 2) + 4
}
function draw() {
point = thisObject.container.frame.frameThisPoint(point)
return; // nothing to show
thisObject.container.frame.draw(false, false);
let fontSize = 12;
let label = window.USER_LOGGED_IN;
if (label === undefined) { label = "" };
let point = {
x: thisObject.container.frame.width * 1 / 3,
y: (thisObject.container.frame.height / 2) + 4
};
point = thisObject.container.frame.frameThisPoint(point);
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.PRIMARY;
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 1)';
browserCanvasContext.fillText(label, point.x, point.y);
}
}
browserCanvasContext.font = fontSize + 'px ' + UI_FONT.PRIMARY
browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 1)'
browserCanvasContext.fillText(label, point.x, point.y)
}
}
Utilities.js
+78 -91
View File
@@ -1,141 +1,128 @@

function transformThisPoint(point, container) {
function transformThisPoint (point, container) {
/* We make the point relative to the current frame */
point = container.frame.frameThisPoint(point);
point = container.frame.frameThisPoint(point)
/* We add the possible displacement */
point = container.displacement.displaceThisPoint(point);
point = container.displacement.displaceThisPoint(point)
/* We viewport Transformation. */
point = viewPort.zoomThisPoint(point);
point = viewPort.zoomThisPoint(point)
return point;
return point
}
function unTransformThisPoint(point, container) {
function unTransformThisPoint (point, container) {
point = viewPort.unzoomThisPoint(point)
point = container.displacement.undisplaceThisPoint(point)
point = container.frame.unframeThisPoint(point)
point = viewPort.unzoomThisPoint(point);
point = container.displacement.undisplaceThisPoint(point);
point = container.frame.unframeThisPoint(point);
return point;
return point
}
function nextPorwerOf10(number) {
for (let i = -10; i <= 10; i++) {
if (number < Math.pow(10, i)) {
return Math.pow(10, i);
}
function nextPorwerOf10 (number) {
for (let i = -10; i <= 10; i++) {
if (number < Math.pow(10, i)) {
return Math.pow(10, i)
}
}
}
function pad(str, max) {
str = str.toString();
return str.length < max ? pad("0" + str, max) : str;
function pad (str, max) {
str = str.toString()
return str.length < max ? pad('0' + str, max) : str
}
function getDateFromPoint(point, container, timeLineCoordinateSystem) {
function getDateFromPoint (point, container, timeLineCoordinateSystem) {
point = unTransformThisPoint(point, container)
point = timeLineCoordinateSystem.unInverseTransform(point, container.frame.height)
point = unTransformThisPoint(point, container);
point = timeLineCoordinateSystem.unInverseTransform(point, container.frame.height);
let date = new Date(point.x)
let date = new Date(point.x);
return date;
return date
}
function getRateFromPoint(point, container, timeLineCoordinateSystem) {
function getRateFromPoint (point, container, timeLineCoordinateSystem) {
point = unTransformThisPoint(point, container)
point = timeLineCoordinateSystem.unInverseTransform(point, container.frame.height)
point = unTransformThisPoint(point, container);
point = timeLineCoordinateSystem.unInverseTransform(point, container.frame.height);
return point.y;
return point.y
}
function getMilisecondsFromPoint(point, container, timeLineCoordinateSystem) {
function getMilisecondsFromPoint (point, container, timeLineCoordinateSystem) {
point = unTransformThisPoint(point, container)
point = timeLineCoordinateSystem.unInverseTransform(point, container.frame.height)
point = unTransformThisPoint(point, container);
point = timeLineCoordinateSystem.unInverseTransform(point, container.frame.height);
return point.x;
return point.x
}
function saveUserPosition(container, timeLineCoordinateSystem) {
function saveUserPosition (container, timeLineCoordinateSystem) {
let centerPoint = {
x: (viewPort.visibleArea.bottomRight.x - viewPort.visibleArea.topLeft.x) / 2,
y: (viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topLeft.y) / 2
}
let centerPoint = {
x: (viewPort.visibleArea.bottomRight.x - viewPort.visibleArea.topLeft.x) / 2,
y: (viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topLeft.y) / 2
};
let userPosition = {
date: getDateFromPoint(centerPoint, container, timeLineCoordinateSystem),
rate: getRateFromPoint(centerPoint, container, timeLineCoordinateSystem),
market: DEFAULT_MARKET,
zoom: viewPort.zoomTargetLevel
}
let userPosition = {
date: getDateFromPoint(centerPoint, container, timeLineCoordinateSystem),
rate: getRateFromPoint(centerPoint, container, timeLineCoordinateSystem),
market: DEFAULT_MARKET,
zoom: viewPort.zoomTargetLevel
};
window.localStorage.setItem('userPosition', JSON.stringify(userPosition));
window.localStorage.setItem('userPosition', JSON.stringify(userPosition))
}
function moveToUserPosition(container, timeLineCoordinateSystem) {
function moveToUserPosition (container, timeLineCoordinateSystem) {
let savedPosition = window.localStorage.getItem('userPosition')
let userPosition
let savedPosition = window.localStorage.getItem('userPosition');
let userPosition;
if (savedPosition === null) {
userPosition = {
date: (new Date()).toString(),
rate: timeLineCoordinateSystem.max.y / 2,
market: DEFAULT_MARKET,
zoom: INITIAL_ZOOM_LEVEL
};
} else {
userPosition = JSON.parse(savedPosition);
if (savedPosition === null) {
userPosition = {
date: (new Date()).toString(),
rate: timeLineCoordinateSystem.max.y / 2,
market: DEFAULT_MARKET,
zoom: INITIAL_ZOOM_LEVEL
}
} else {
userPosition = JSON.parse(savedPosition)
}
let centerPoint = {
x: (viewPort.visibleArea.bottomRight.x - viewPort.visibleArea.topLeft.x) / 2,
y: (viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topLeft.y) / 2
};
let centerPoint = {
x: (viewPort.visibleArea.bottomRight.x - viewPort.visibleArea.topLeft.x) / 2,
y: (viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topLeft.y) / 2
}
viewPort.newZoomLevel(userPosition.zoom);
INITIAL_TIME_PERIOD = recalculatePeriod(userPosition.zoom);
INITIAL_DATE = new Date (userPosition.date);
viewPort.newZoomLevel(userPosition.zoom)
INITIAL_TIME_PERIOD = recalculatePeriod(userPosition.zoom)
INITIAL_DATE = new Date(userPosition.date)
let targetPoint = {
x: (new Date(userPosition.date)).valueOf(),
y: userPosition.rate
};
let targetPoint = {
x: (new Date(userPosition.date)).valueOf(),
y: userPosition.rate
}
/* Put this point in the coordinate system of the viewPort */
targetPoint = timeLineCoordinateSystem.transformThisPoint(targetPoint);
targetPoint = transformThisPoint(targetPoint, container);
targetPoint = timeLineCoordinateSystem.transformThisPoint(targetPoint)
targetPoint = transformThisPoint(targetPoint, container)
/* Lets calculate the displace vector, from the point we want at the center, to the current center. */
let displaceVector = {
x: centerPoint.x - targetPoint.x,
y: centerPoint.y - targetPoint.y
};
let displaceVector = {
x: centerPoint.x - targetPoint.x,
y: centerPoint.y - targetPoint.y
}
viewPort.displace(displaceVector);
viewPort.displace(displaceVector)
}
function removeTime(datetime) {
function removeTime (datetime) {
if (datetime === undefined) { return }
if (datetime === undefined) { return;}
let dateOnly = new Date(Math.trunc(datetime.valueOf() / ONE_DAY_IN_MILISECONDS) * ONE_DAY_IN_MILISECONDS)
let dateOnly = new Date(Math.trunc(datetime.valueOf() / ONE_DAY_IN_MILISECONDS) * ONE_DAY_IN_MILISECONDS);
return dateOnly;
}
return dateOnly
}
ViewPort.js
+314 -373
View File
@@ -1,100 +1,95 @@

function newViewPort() {

function newViewPort () {
const CONSOLE_LOG = true
const CONSOLE_LOG = true;
let ANIMATION_INCREMENT = 0.25
const TOP_MARGIN = 15 + TOP_SPACE_HEIGHT
const BOTTOM_MARGIN = 15 + BOTTOM_SPACE_HEIGHT
const LEFT_MARGIN = 50
const RIGHT_MARGIN = 50
const MIN_ZOOM_LEVEL = -28.25
let ANIMATION_INCREMENT = 0.25;
const TOP_MARGIN = 15 + TOP_SPACE_HEIGHT;
const BOTTOM_MARGIN = 15 + BOTTOM_SPACE_HEIGHT;
const LEFT_MARGIN = 50;
const RIGHT_MARGIN = 50;
const MIN_ZOOM_LEVEL = -28.25
let thisObject = {
visibleArea: undefined,
eventHandler: undefined,
zoomTargetLevel: undefined,
zoomLevel: undefined,
mousePosition: undefined,
newZoomLevel: newZoomLevel,
applyZoom: applyZoom,
isMinZoom: isMinZoom,
zoomFontSize: zoomFontSize,
zoomThisPoint: zoomThisPoint,
unzoomThisPoint: unzoomThisPoint,
isThisPointVisible: isThisPointVisible,
fitIntoVisibleArea: fitIntoVisibleArea,
displace: displace,
displaceTarget: displaceTarget,
animate: animate,
draw: draw,
raiseEvents: raiseEvents,
initialize: initialize
}
let thisObject = {
visibleArea: undefined,
eventHandler: undefined,
zoomTargetLevel:undefined,
zoomLevel: undefined,
mousePosition: undefined,
newZoomLevel: newZoomLevel,
applyZoom: applyZoom,
isMinZoom: isMinZoom,
zoomFontSize: zoomFontSize,
zoomThisPoint: zoomThisPoint,
unzoomThisPoint: unzoomThisPoint,
isThisPointVisible: isThisPointVisible,
fitIntoVisibleArea: fitIntoVisibleArea,
displace: displace,
displaceTarget: displaceTarget,
animate: animate,
draw: draw,
raiseEvents: raiseEvents,
initialize: initialize
};
let increment = 0.035
let increment = 0.035;
var offset = {
x: 0,
y: 0
}
var offset = {
x: 0,
y: 0
};
var targetOffset = {
x: 0,
y: 0
}
var targetOffset = {
x: 0,
y: 0
};
let offsetIncrement = {
x: 0,
y: 0
}
let offsetIncrement = {
x: 0,
y: 0
};
thisObject.mousePosition = {
x: 0,
y: 0
}
thisObject.mousePosition = {
x: 0,
y: 0
};
thisObject.eventHandler = newEventHandler()
thisObject.eventHandler = newEventHandler();
return thisObject
return thisObject;
function initialize () {
thisObject.visibleArea = {
topLeft: { x: LEFT_MARGIN, y: TOP_MARGIN },
topRight: { x: browserCanvas.width - RIGHT_MARGIN, y: TOP_MARGIN },
bottomRight: { x: browserCanvas.width - RIGHT_MARGIN, y: browserCanvas.height - BOTTOM_MARGIN},
bottomLeft: { x: LEFT_MARGIN, y: browserCanvas.height - BOTTOM_MARGIN}
}
}
function initialize() {
function raiseEvents () {
let event = {
newOffset: offset
}
thisObject.visibleArea = {
topLeft: { x: LEFT_MARGIN, y: TOP_MARGIN },
topRight: { x: browserCanvas.width - RIGHT_MARGIN , y: TOP_MARGIN },
bottomRight: { x: browserCanvas.width - RIGHT_MARGIN, y: browserCanvas.height - BOTTOM_MARGIN},
bottomLeft: { x: LEFT_MARGIN, y: browserCanvas.height - BOTTOM_MARGIN}
};
}
thisObject.eventHandler.raiseEvent('Offset Changed', event)
}
function raiseEvents() {
function animate () {
if (thisObject.zoomLevel < thisObject.zoomTargetLevel) {
if (thisObject.zoomTargetLevel - thisObject.zoomLevel < ANIMATION_INCREMENT) {
ANIMATION_INCREMENT = Math.abs(thisObject.zoomTargetLevel - thisObject.zoomLevel)
}
thisObject.zoomLevel = thisObject.zoomLevel + ANIMATION_INCREMENT
changeZoom(thisObject.zoomLevel - ANIMATION_INCREMENT, thisObject.zoomLevel)
}
let event = {
newOffset: offset
};
thisObject.eventHandler.raiseEvent("Offset Changed", event);
}
function animate() {
if (thisObject.zoomLevel < thisObject.zoomTargetLevel) {
if (thisObject.zoomTargetLevel - thisObject.zoomLevel < ANIMATION_INCREMENT) {
ANIMATION_INCREMENT = Math.abs(thisObject.zoomTargetLevel - thisObject.zoomLevel);
}
thisObject.zoomLevel = thisObject.zoomLevel + ANIMATION_INCREMENT;
changeZoom(thisObject.zoomLevel - ANIMATION_INCREMENT, thisObject.zoomLevel);
}
if (thisObject.zoomLevel > thisObject.zoomTargetLevel) {
if (thisObject.zoomLevel - thisObject.zoomTargetLevel < ANIMATION_INCREMENT) {
ANIMATION_INCREMENT = Math.abs(thisObject.zoomTargetLevel - thisObject.zoomLevel);
}
thisObject.zoomLevel = thisObject.zoomLevel - ANIMATION_INCREMENT;
changeZoom(thisObject.zoomLevel + ANIMATION_INCREMENT, thisObject.zoomLevel);
}
if (thisObject.zoomLevel > thisObject.zoomTargetLevel) {
if (thisObject.zoomLevel - thisObject.zoomTargetLevel < ANIMATION_INCREMENT) {
ANIMATION_INCREMENT = Math.abs(thisObject.zoomTargetLevel - thisObject.zoomLevel)
}
thisObject.zoomLevel = thisObject.zoomLevel - ANIMATION_INCREMENT
changeZoom(thisObject.zoomLevel + ANIMATION_INCREMENT, thisObject.zoomLevel)
}
/*
if (offsetIncrement.x !== 0) {
@@ -105,344 +100,290 @@ function newViewPort() {
offsetIncrement.x = 0;
}
}
*/
*/
if (offsetIncrement.y !== 0) {
if (offsetIncrement.y !== 0) {
if (Math.trunc(Math.abs(targetOffset.y - offset.y) * 1000) >= Math.trunc(Math.abs(offsetIncrement.y) * 1000)) {
offset.y = offset.y + offsetIncrement.y
if (Math.trunc(Math.abs(targetOffset.y - offset.y) * 1000) >= Math.trunc(Math.abs(offsetIncrement.y) * 1000)) {
offset.y = offset.y + offsetIncrement.y;
// console.log("offset.y changed to " + offset.y)
} else {
offsetIncrement.y = 0
}
}
}
//console.log("offset.y changed to " + offset.y)
function displace (displaceVector) {
offset.x = offset.x + displaceVector.x
offset.y = offset.y + displaceVector.y
} else {
offsetIncrement.y = 0;
}
}
let event = {
newOffset: offset
}
}
thisObject.eventHandler.raiseEvent('Offset Changed', event)
function displace(displaceVector) {
// console.log("displace produced new Offset x = " + offset.x + " y = " + offset.y);
}
offset.x = offset.x + displaceVector.x;
offset.y = offset.y + displaceVector.y;
function displaceTarget (displaceVector) {
targetOffset.x = targetOffset.x + displaceVector.x
targetOffset.y = targetOffset.y + displaceVector.y
let event = {
newOffset: offset
};
offsetIncrement = {
x: (targetOffset.x - offset.x) / 10,
y: (targetOffset.y - offset.y) / 10
}
thisObject.eventHandler.raiseEvent("Offset Changed", event);
// console.log("displaceTarget x = " + targetOffset.x + " y = " + targetOffset.y);
}
//console.log("displace produced new Offset x = " + offset.x + " y = " + offset.y);
function newZoomLevel (level) {
thisObject.zoomTargetLevel = level
thisObject.zoomLevel = level
}
ANIMATION_INCREMENT = Math.abs(thisObject.zoomTargetLevel - thisObject.zoomLevel) / 3
function displaceTarget(displaceVector) {
let event = {
newLevel: thisObject.zoomTargetLevel,
newOffset: offset,
type: undefined
}
thisObject.eventHandler.raiseEvent('Zoom Changed', event)
targetOffset.x = targetOffset.x + displaceVector.x;
targetOffset.y = targetOffset.y + displaceVector.y;
return true
}
offsetIncrement = {
x: (targetOffset.x - offset.x) / 10,
y: (targetOffset.y - offset.y) / 10
};
//console.log("displaceTarget x = " + targetOffset.x + " y = " + targetOffset.y);
}
function newZoomLevel(level) {
thisObject.zoomTargetLevel = level;
thisObject.zoomLevel = level;
ANIMATION_INCREMENT = Math.abs(thisObject.zoomTargetLevel - thisObject.zoomLevel) / 3;
let event = {
newLevel: thisObject.zoomTargetLevel,
newOffset: offset,
type: undefined
};
thisObject.eventHandler.raiseEvent("Zoom Changed", event);
return true;
}
function isMinZoom() {
function isMinZoom () {
/* returns true is we are currently at the min zoom level. */
if (thisObject.zoomTargetLevel === MIN_ZOOM_LEVEL) { return true; } else { return false;}
if (thisObject.zoomTargetLevel === MIN_ZOOM_LEVEL) { return true } else { return false }
}
}
function applyZoom (amount) {
// console.log("applyZoom amount: " + amount);
function applyZoom(amount) {
if (amount > 0) {
if (thisObject.zoomTargetLevel > -5) {
amount = amount * 2
}
//console.log("applyZoom amount: " + amount);
if (amount > 0) {
if (thisObject.zoomTargetLevel > -5) {
amount = amount * 2;
}
if (thisObject.zoomTargetLevel > 10) {
amount = amount * 3;
}
if (thisObject.zoomTargetLevel > 15) {
amount = amount * 4;
}
}
if (amount < 0) {
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 > 1000) {
return false;
}
if (thisObject.zoomTargetLevel <= -27 && amount < 0) {
amount = amount / 4;
}
if (thisObject.zoomTargetLevel < -27 && amount > 0) {
amount = amount / 4;
}
if (thisObject.zoomTargetLevel + amount < MIN_ZOOM_LEVEL) {
return false;
}
thisObject.zoomTargetLevel = thisObject.zoomTargetLevel + amount;
ANIMATION_INCREMENT = Math.abs(thisObject.zoomTargetLevel - thisObject.zoomLevel) / 3;
let event = {
newLevel: thisObject.zoomTargetLevel,
newOffset: offset,
type: undefined
};
if (amount > 0) {
event.type = "Zoom In";
} else {
event.type = "Zoom Out";
}
thisObject.eventHandler.raiseEvent("Zoom Changed", event);
return true;
}
function changeZoom(oldLevel, newLevel) {
let mouseNoZoom = unzoomThisPoint(thisObject.mousePosition, oldLevel);
let newMouse = zoomThisPoint(mouseNoZoom, newLevel);
offset.x = offset.x - newMouse.x + thisObject.mousePosition.x;
offset.y = offset.y - newMouse.y + thisObject.mousePosition.y;
targetOffset.x = offset.x
targetOffset.y = offset.y ;
offsetIncrement = {
x: 0,
y: 0
};
if (thisObject.zoomTargetLevel > 10) {
amount = amount * 3
}
if (thisObject.zoomTargetLevel > 15) {
amount = amount * 4
}
}
if (amount < 0) {
if (thisObject.zoomTargetLevel > -4) {
amount = amount * 2
}
function zoomFontSize(baseSize, level) {
if (thisObject.zoomTargetLevel > 13) {
amount = amount * 3
}
let zoomFactor = increment; // + increment * thisObject.zoomLevel / 100;
if (level === undefined) {
baseSize = baseSize * (1 + zoomFactor * thisObject.zoomLevel);
} else {
baseSize = baseSize * (1 + zoomFactor * level);
}
return baseSize;
if (thisObject.zoomTargetLevel > 19) {
amount = amount * 4
}
}
function fitIntoVisibleArea(point) {
if (thisObject.zoomTargetLevel + amount > 1000) {
return false
}
if (thisObject.zoomTargetLevel <= -27 && amount < 0) {
amount = amount / 4
}
if (thisObject.zoomTargetLevel < -27 && amount > 0) {
amount = amount / 4
}
if (thisObject.zoomTargetLevel + amount < MIN_ZOOM_LEVEL) {
return false
}
thisObject.zoomTargetLevel = thisObject.zoomTargetLevel + amount
ANIMATION_INCREMENT = Math.abs(thisObject.zoomTargetLevel - thisObject.zoomLevel) / 3
let event = {
newLevel: thisObject.zoomTargetLevel,
newOffset: offset,
type: undefined
}
if (amount > 0) {
event.type = 'Zoom In'
} else {
event.type = 'Zoom Out'
}
thisObject.eventHandler.raiseEvent('Zoom Changed', event)
return true
}
function changeZoom (oldLevel, newLevel) {
let mouseNoZoom = unzoomThisPoint(thisObject.mousePosition, oldLevel)
let newMouse = zoomThisPoint(mouseNoZoom, newLevel)
offset.x = offset.x - newMouse.x + thisObject.mousePosition.x
offset.y = offset.y - newMouse.y + thisObject.mousePosition.y
targetOffset.x = offset.x
targetOffset.y = offset.y
offsetIncrement = {
x: 0,
y: 0
}
}
function zoomFontSize (baseSize, level) {
let zoomFactor = increment // + increment * thisObject.zoomLevel / 100;
if (level === undefined) {
baseSize = baseSize * (1 + zoomFactor * thisObject.zoomLevel)
} else {
baseSize = baseSize * (1 + zoomFactor * level)
}
return baseSize
}
function fitIntoVisibleArea (point) {
/* Here we check the boundaries of the resulting points, so they dont go out of the visible area. */
if (point.x > thisObject.visibleArea.bottomRight.x + 1) {
point.x = thisObject.visibleArea.bottomRight.x + 1;
}
if (point.x < thisObject.visibleArea.topLeft.x - 1) {
point.x = thisObject.visibleArea.topLeft.x - 1;
}
if (point.y > thisObject.visibleArea.bottomRight.y + 1) {
point.y = thisObject.visibleArea.bottomRight.y + 1;
}
if (point.y < thisObject.visibleArea.topLeft.y - 1) {
point.y = thisObject.visibleArea.topLeft.y - 1;
}
return point;
if (point.x > thisObject.visibleArea.bottomRight.x + 1) {
point.x = thisObject.visibleArea.bottomRight.x + 1
}
function zoomThisPoint(point, level) {
let zoomFactor = increment; // + increment * thisObject.zoomLevel / 100;
if (level === undefined) {
point.x = point.x * (1 + zoomFactor * thisObject.zoomLevel) + offset.x;
point.y = point.y * (1 + zoomFactor * thisObject.zoomLevel) + offset.y;
} else {
point.x = point.x * (1 + zoomFactor * level) + offset.x;
point.y = point.y * (1 + zoomFactor * level) + offset.y;
}
return point;
if (point.x < thisObject.visibleArea.topLeft.x - 1) {
point.x = thisObject.visibleArea.topLeft.x - 1
}
function unzoomThisPoint(pointWithZoom, level) {
let pointWithoutZoom;
let zoomFactor = increment; // + increment * thisObject.zoomLevel / 100;
if (level === undefined) {
pointWithoutZoom = {
x: (pointWithZoom.x - offset.x) / (1 + zoomFactor * thisObject.zoomLevel),
y: (pointWithZoom.y - offset.y) / (1 + zoomFactor * thisObject.zoomLevel)
};
} else {
pointWithoutZoom = {
x: (pointWithZoom.x - offset.x) / (1 + zoomFactor * level),
y: (pointWithZoom.y - offset.y) / (1 + zoomFactor * level)
};
}
return pointWithoutZoom;
if (point.y > thisObject.visibleArea.bottomRight.y + 1) {
point.y = thisObject.visibleArea.bottomRight.y + 1
}
function isThisPointVisible(point) {
if (visibleArea === undefined) {
getVisibleArea();
}
if (point.x < visibleArea.topLeft.x || point.x > visibleArea.bottomRight.x || point.y < visibleArea.topLeft.y || point.y > visibleArea.bottomRight.y) {
return false;
} else {
return true;
}
if (point.y < thisObject.visibleArea.topLeft.y - 1) {
point.y = thisObject.visibleArea.topLeft.y - 1
}
return point
}
function draw() {
function zoomThisPoint (point, level) {
let zoomFactor = increment // + increment * thisObject.zoomLevel / 100;
if (level === undefined) {
point.x = point.x * (1 + zoomFactor * thisObject.zoomLevel) + offset.x
point.y = point.y * (1 + zoomFactor * thisObject.zoomLevel) + offset.y
} else {
point.x = point.x * (1 + zoomFactor * level) + offset.x
point.y = point.y * (1 + zoomFactor * level) + offset.y
}
return point
}
function unzoomThisPoint (pointWithZoom, level) {
let pointWithoutZoom
let zoomFactor = increment // + increment * thisObject.zoomLevel / 100;
if (level === undefined) {
pointWithoutZoom = {
x: (pointWithZoom.x - offset.x) / (1 + zoomFactor * thisObject.zoomLevel),
y: (pointWithZoom.y - offset.y) / (1 + zoomFactor * thisObject.zoomLevel)
}
} else {
pointWithoutZoom = {
x: (pointWithZoom.x - offset.x) / (1 + zoomFactor * level),
y: (pointWithZoom.y - offset.y) / (1 + zoomFactor * level)
}
}
return pointWithoutZoom
}
function isThisPointVisible (point) {
if (visibleArea === undefined) {
getVisibleArea()
}
if (point.x < visibleArea.topLeft.x || point.x > visibleArea.bottomRight.x || point.y < visibleArea.topLeft.y || point.y > visibleArea.bottomRight.y) {
return false
} else {
return true
}
}
function draw () {
/*
drawGrid(10);
drawGrid(1);
drawGrid(0.1);
*/
}
function drawGrid (step) {
let squareWidth = (thisObject.visibleArea.bottomRight.x - thisObject.visibleArea.bottomLeft.x) / step
squareWidth = squareWidth + squareWidth * increment * thisObject.zoomLevel
let startingX = offset.x - Math.trunc(offset.x / squareWidth) * squareWidth
let startingY = offset.y - Math.trunc(offset.y / squareWidth) * squareWidth
let lineWidth = 10 / step + 10 / step * increment * thisObject.zoomLevel
if (lineWidth < 0.5) {
return
}
function drawGrid(step) {
let squareWidth = (thisObject.visibleArea.bottomRight.x - thisObject.visibleArea.bottomLeft.x) / step;
squareWidth = squareWidth + squareWidth * increment * thisObject.zoomLevel;
let startingX = offset.x - Math.trunc(offset.x / squareWidth) * squareWidth;
let startingY = offset.y - Math.trunc(offset.y / squareWidth) * squareWidth;
let lineWidth = 10 / step + 10 / step * increment * thisObject.zoomLevel;
if (lineWidth < 0.5) {
return;
}
if (lineWidth > 2) {
lineWidth = 2;
}
browserCanvasContext.beginPath();
for (var i = startingX; i < thisObject.visibleArea.bottomRight.x; i = i + squareWidth) {
for (var j = startingY; j < thisObject.visibleArea.bottomRight.y; j = j + squareWidth) {
let point1 = {
x: thisObject.visibleArea.bottomLeft.x,
y: j
};
let point2 = {
x: thisObject.visibleArea.bottomRight.x,
y: j
};
browserCanvasContext.moveTo(point1.x, point1.y);
browserCanvasContext.lineTo(point2.x, point2.y);
}
let point3 = {
x: i,
y: thisObject.visibleArea.topLeft.y
};
let point4 = {
x: i,
y: thisObject.visibleArea.bottomLeft.y
};
browserCanvasContext.moveTo(point3.x, point3.y);
browserCanvasContext.lineTo(point4.x, point4.y);
}
browserCanvasContext.closePath();
browserCanvasContext.strokeStyle = 'rgba(150, 150, 150, 0.' + Math.trunc(lineWidth + 1) + ')';
browserCanvasContext.lineWidth = lineWidth;
browserCanvasContext.stroke();
if (lineWidth > 2) {
lineWidth = 2
}
browserCanvasContext.beginPath()
for (var i = startingX; i < thisObject.visibleArea.bottomRight.x; i = i + squareWidth) {
for (var j = startingY; j < thisObject.visibleArea.bottomRight.y; j = j + squareWidth) {
let point1 = {
x: thisObject.visibleArea.bottomLeft.x,
y: j
}
let point2 = {
x: thisObject.visibleArea.bottomRight.x,
y: j
}
browserCanvasContext.moveTo(point1.x, point1.y)
browserCanvasContext.lineTo(point2.x, point2.y)
}
let point3 = {
x: i,
y: thisObject.visibleArea.topLeft.y
}
let point4 = {
x: i,
y: thisObject.visibleArea.bottomLeft.y
}
browserCanvasContext.moveTo(point3.x, point3.y)
browserCanvasContext.lineTo(point4.x, point4.y)
}
browserCanvasContext.closePath()
browserCanvasContext.strokeStyle = 'rgba(150, 150, 150, 0.' + Math.trunc(lineWidth + 1) + ')'
browserCanvasContext.lineWidth = lineWidth
browserCanvasContext.stroke()
}
}
VolumeBar.js
+9 -11
View File
@@ -1,12 +1,10 @@
function newVolumeBar() {
function newVolumeBar () {
var volumeBar = {
amountBuy: 0,
amountSell: 0,
begin: undefined,
end: undefined
}
var volumeBar = {
amountBuy: 0,
amountSell: 0,
begin: undefined,
end: undefined
};
return volumeBar;
}
return volumeBar
}
WebDebugLog.js
+16 -18
View File
@@ -1,20 +1,18 @@

function newWebDebugLog() {

function newWebDebugLog () {
let thisObject = {
write: write,
fileName: undefined
}
let thisObject = {
write: write,
fileName: undefined
return thisObject
function write (pText) {
console.log(spacePad(thisObject.fileName, 50) + ' : ' + pText)
function spacePad (str, max) {
str = str.toString()
return str.length < max ? spacePad(' ' + str, max) : str
}
return thisObject;
function write(pText) {
console.log(spacePad(thisObject.fileName, 50) + " : " + pText);
function spacePad(str, max) {
str = str.toString();
return str.length < max ? spacePad(" " + str, max) : str;
}
}
}
}
}