Backup and Share main structures with state of inner objects

DesignerSpace/Workspace/FunctionLibraries/UiObjectsFromNodes.js

@@ -108,74 +108,74 @@ function newUiObjectsFromNodes () {
     return
   }
 
-  function createUiObjectFromNode (node, parentNode, chainParent) {
+  function createUiObjectFromNode (node, parentNode, chainParent, positionOffset) {
     switch (node.type) {
       case 'Code':
         {
-          createUiObject('Code', node.name, node, parentNode, chainParent, 'Code')
+          createUiObject('Code', node.name, node, parentNode, chainParent, 'Code', positionOffset)
           return
         }
       case 'Condition':
         {
-          createUiObject('Condition', node.name, node, parentNode, chainParent, 'Condition')
+          createUiObject('Condition', node.name, node, parentNode, chainParent, 'Condition', positionOffset)
           if (node.code !== undefined) {
-            createUiObjectFromNode(node.code, node, node)
+            createUiObjectFromNode(node.code, node, node, positionOffset)
           }
           return
         }
       case 'Situation': {
         let situation = node
-        createUiObject('Situation', situation.name, situation, parentNode, chainParent, 'Situation')
+        createUiObject('Situation', situation.name, situation, parentNode, chainParent, 'Situation', positionOffset)
         for (let m = 0; m < node.conditions.length; m++) {
           let condition = node.conditions[m]
-          createUiObjectFromNode(condition, situation, situation)
+          createUiObjectFromNode(condition, situation, situation, positionOffset)
         }
         return
       }
       case 'Formula':
         {
-          createUiObject('Formula', node.name, node, parentNode, chainParent, 'Formula')
+          createUiObject('Formula', node.name, node, parentNode, chainParent, 'Formula', positionOffset)
           return
         }
       case 'Next Phase Event':
         {
-          createUiObject('Next Phase Event', node.name, node, parentNode, chainParent, 'Next Phase Event')
+          createUiObject('Next Phase Event', node.name, node, parentNode, chainParent, 'Next Phase Event', positionOffset)
           for (let m = 0; m < node.situations.length; m++) {
             let situation = node.situations[m]
-            createUiObjectFromNode(situation, node, node)
+            createUiObjectFromNode(situation, node, node, positionOffset)
           }
           if (node.announcements === undefined) {
             node.announcements = []
           }
           for (let m = 0; m < node.announcements.length; m++) {
             let announcement = node.announcements[m]
-            createUiObjectFromNode(announcement, node, node)
+            createUiObjectFromNode(announcement, node, node, positionOffset)
           }
           return
         }
       case 'Phase': {
         let phase = node
-        createUiObject('Phase', phase.name, phase, parentNode, chainParent, phase.subType)
+        createUiObject('Phase', phase.name, phase, parentNode, chainParent, phase.subType, positionOffset)
 
         if (node.formula !== undefined) {
-          createUiObjectFromNode(node.formula, phase, phase)
+          createUiObjectFromNode(node.formula, phase, phase, positionOffset)
         }
         if (node.nextPhaseEvent !== undefined) {
-          createUiObjectFromNode(node.nextPhaseEvent, phase, phase)
+          createUiObjectFromNode(node.nextPhaseEvent, phase, phase, positionOffset)
         }
         if (node.announcements === undefined) {
           node.announcements = []
         }
         for (let m = 0; m < node.announcements.length; m++) {
           let announcement = node.announcements[m]
-          createUiObjectFromNode(announcement, node, node)
+          createUiObjectFromNode(announcement, node, node, positionOffset)
         }
         return
       }
       case 'Stop': {
         let lastPhase
         let stop = node
-        createUiObject('Stop', stop.name, stop, parentNode, chainParent, 'Stop')
+        createUiObject('Stop', stop.name, stop, parentNode, chainParent, 'Stop', positionOffset)
         for (let m = 0; m < node.phases.length; m++) {
           let phase = node.phases[m]
           let thisChainParent
@@ -185,14 +185,14 @@ function newUiObjectsFromNodes () {
             thisChainParent = lastPhase
           }
           lastPhase = phase
-          createUiObjectFromNode(phase, stop, thisChainParent)
+          createUiObjectFromNode(phase, stop, thisChainParent, positionOffset)
         }
         return
       }
       case 'Take Profit': {
         let lastPhase
         let takeProfit = node
-        createUiObject('Take Profit', takeProfit.name, takeProfit, parentNode, chainParent, 'Take Profit')
+        createUiObject('Take Profit', takeProfit.name, takeProfit, parentNode, chainParent, 'Take Profit', positionOffset)
         for (let m = 0; m < node.phases.length; m++) {
           let phase = node.phases[m]
           let thisChainParent
@@ -202,244 +202,244 @@ function newUiObjectsFromNodes () {
             thisChainParent = lastPhase
           }
           lastPhase = phase
-          createUiObjectFromNode(phase, takeProfit, thisChainParent)
+          createUiObjectFromNode(phase, takeProfit, thisChainParent, positionOffset)
         }
         return
       }
       case 'Open Execution':
         {
-          createUiObject('Open Execution', node.name, node, parentNode, chainParent, 'Open Execution')
+          createUiObject('Open Execution', node.name, node, parentNode, chainParent, 'Open Execution', positionOffset)
           return
         }
       case 'Close Execution':
         {
-          createUiObject('Close Execution', node.name, node, parentNode, chainParent, 'Close Execution')
+          createUiObject('Close Execution', node.name, node, parentNode, chainParent, 'Close Execution', positionOffset)
           return
         }
       case 'Initial Definition': {
-        createUiObject('Initial Definition', node.name, node, parentNode, chainParent, 'Initial Definition')
+        createUiObject('Initial Definition', node.name, node, parentNode, chainParent, 'Initial Definition', positionOffset)
 
         if (node.stopLoss !== undefined) {
-          createUiObjectFromNode(node.stopLoss, node, node)
+          createUiObjectFromNode(node.stopLoss, node, node, positionOffset)
         }
         if (node.takeProfit !== undefined) {
-          createUiObjectFromNode(node.takeProfit, node, node)
+          createUiObjectFromNode(node.takeProfit, node, node, positionOffset)
         }
         if (node.positionSize !== undefined) {
-          createUiObjectFromNode(node.positionSize, node, node)
+          createUiObjectFromNode(node.positionSize, node, node, positionOffset)
         }
         if (node.positionRate !== undefined) {
-          createUiObjectFromNode(node.positionRate, node, node)
+          createUiObjectFromNode(node.positionRate, node, node, positionOffset)
         }
         return
       }
       case 'Take Position Event': {
         let event = node
-        createUiObject('Take Position Event', event.name, event, parentNode, chainParent, 'Take Position Event')
+        createUiObject('Take Position Event', event.name, event, parentNode, chainParent, 'Take Position Event', positionOffset)
         for (let m = 0; m < node.situations.length; m++) {
           let situation = node.situations[m]
-          createUiObjectFromNode(situation, event, event)
+          createUiObjectFromNode(situation, event, event, positionOffset)
         }
         if (node.announcements === undefined) {
           node.announcements = []
         }
         for (let m = 0; m < node.announcements.length; m++) {
           let announcement = node.announcements[m]
-          createUiObjectFromNode(announcement, node, node)
+          createUiObjectFromNode(announcement, node, node, positionOffset)
         }
         return
       }
       case 'Trigger On Event': {
         let event = node
-        createUiObject('Trigger On Event', event.name, event, parentNode, chainParent, 'Trigger On Event')
+        createUiObject('Trigger On Event', event.name, event, parentNode, chainParent, 'Trigger On Event', positionOffset)
         for (let m = 0; m < node.situations.length; m++) {
           let situation = node.situations[m]
-          createUiObjectFromNode(situation, event, event)
+          createUiObjectFromNode(situation, event, event, positionOffset)
         }
         if (node.announcements === undefined) {
           node.announcements = []
         }
         for (let m = 0; m < node.announcements.length; m++) {
           let announcement = node.announcements[m]
-          createUiObjectFromNode(announcement, node, node)
+          createUiObjectFromNode(announcement, node, node, positionOffset)
         }
         return
       }
       case 'Trigger Off Event': {
         let event = node
-        createUiObject('Trigger Off Event', event.name, event, parentNode, chainParent, 'Trigger Off Event')
+        createUiObject('Trigger Off Event', event.name, event, parentNode, chainParent, 'Trigger Off Event', positionOffset)
         for (let m = 0; m < node.situations.length; m++) {
           let situation = node.situations[m]
-          createUiObjectFromNode(situation, event, event)
+          createUiObjectFromNode(situation, event, event, positionOffset)
         }
         if (node.announcements === undefined) {
           node.announcements = []
         }
         for (let m = 0; m < node.announcements.length; m++) {
           let announcement = node.announcements[m]
-          createUiObjectFromNode(announcement, node, node)
+          createUiObjectFromNode(announcement, node, node, positionOffset)
         }
         return
       }
       case 'Position Size': {
-        createUiObject('Position Size', node.name, node, parentNode, chainParent, 'Position Size')
+        createUiObject('Position Size', node.name, node, parentNode, chainParent, 'Position Size', positionOffset)
         if (node.formula !== undefined) {
-          createUiObjectFromNode(node.formula, node, node)
+          createUiObjectFromNode(node.formula, node, node, positionOffset)
         }
         return
       }
       case 'Position Rate': {
-        createUiObject('Position Rate', node.name, node, parentNode, chainParent, 'Position Rate')
+        createUiObject('Position Rate', node.name, node, parentNode, chainParent, 'Position Rate', positionOffset)
         if (node.formula !== undefined) {
-          createUiObjectFromNode(node.formula, node, node)
+          createUiObjectFromNode(node.formula, node, node, positionOffset)
         }
         return
       }
       case 'Trigger Stage': {
         let stage = node
-        createUiObject('Trigger Stage', stage.name, stage, parentNode, chainParent, 'Trigger Stage')
+        createUiObject('Trigger Stage', stage.name, stage, parentNode, chainParent, 'Trigger Stage', positionOffset)
 
         if (node.triggerOn !== undefined) {
-          createUiObjectFromNode(node.triggerOn, stage, stage)
+          createUiObjectFromNode(node.triggerOn, stage, stage, positionOffset)
         }
         if (node.triggerOff !== undefined) {
-          createUiObjectFromNode(node.triggerOff, stage, stage)
+          createUiObjectFromNode(node.triggerOff, stage, stage, positionOffset)
         }
         if (node.takePosition !== undefined) {
-          createUiObjectFromNode(node.takePosition, stage, stage)
+          createUiObjectFromNode(node.takePosition, stage, stage, positionOffset)
         }
         return
       }
       case 'Open Stage': {
         let stage = node
-        createUiObject('Open Stage', stage.name, stage, parentNode, chainParent, 'Open Stage')
+        createUiObject('Open Stage', stage.name, stage, parentNode, chainParent, 'Open Stage', positionOffset)
 
         if (node.initialDefinition !== undefined) {
-          createUiObjectFromNode(node.initialDefinition, stage, stage)
+          createUiObjectFromNode(node.initialDefinition, stage, stage, positionOffset)
         }
         if (node.openExecution !== undefined) {
-          createUiObjectFromNode(node.openExecution, stage, stage)
+          createUiObjectFromNode(node.openExecution, stage, stage, positionOffset)
         }
         return
       }
       case 'Manage Stage': {
         let stage = node
-        createUiObject('Manage Stage', stage.name, stage, parentNode, chainParent, 'Manage Stage')
+        createUiObject('Manage Stage', stage.name, stage, parentNode, chainParent, 'Manage Stage', positionOffset)
 
         if (node.stopLoss !== undefined) {
-          createUiObjectFromNode(node.stopLoss, stage, stage)
+          createUiObjectFromNode(node.stopLoss, stage, stage, positionOffset)
         }
         if (node.takeProfit !== undefined) {
-          createUiObjectFromNode(node.takeProfit, stage, stage)
+          createUiObjectFromNode(node.takeProfit, stage, stage, positionOffset)
         }
         return
       }
       case 'Close Stage': {
         let stage = node
-        createUiObject('Close Stage', stage.name, stage, parentNode, chainParent, 'Close Stage')
+        createUiObject('Close Stage', stage.name, stage, parentNode, chainParent, 'Close Stage', positionOffset)
 
         if (node.closeExecution !== undefined) {
-          createUiObjectFromNode(node.closeExecution, stage, stage)
+          createUiObjectFromNode(node.closeExecution, stage, stage, positionOffset)
         }
         return
       }
       case 'Strategy': {
         let strategy = node
-        createUiObject('Strategy', strategy.name, strategy, parentNode, chainParent, 'Strategy')
+        createUiObject('Strategy', strategy.name, strategy, parentNode, chainParent, 'Strategy', positionOffset)
         if (node.triggerStage !== undefined) {
-          createUiObjectFromNode(node.triggerStage, strategy, strategy)
+          createUiObjectFromNode(node.triggerStage, strategy, strategy, positionOffset)
         }
         if (node.openStage !== undefined) {
-          createUiObjectFromNode(node.openStage, strategy, strategy)
+          createUiObjectFromNode(node.openStage, strategy, strategy, positionOffset)
         }
         if (node.manageStage !== undefined) {
-          createUiObjectFromNode(node.manageStage, strategy, strategy)
+          createUiObjectFromNode(node.manageStage, strategy, strategy, positionOffset)
         }
         if (node.closeStage !== undefined) {
-          createUiObjectFromNode(node.closeStage, strategy, strategy)
+          createUiObjectFromNode(node.closeStage, strategy, strategy, positionOffset)
         }
         return
       }
       case 'Base Asset': {
-        createUiObject('Base Asset', node.name, node, parentNode, chainParent, 'Base Asset')
+        createUiObject('Base Asset', node.name, node, parentNode, chainParent, 'Base Asset', positionOffset)
         return
       }
       case 'Time Range': {
-        createUiObject('Time Range', node.name, node, parentNode, chainParent, 'Time Range')
+        createUiObject('Time Range', node.name, node, parentNode, chainParent, 'Time Range', positionOffset)
         return
       }
       case 'Time Period': {
-        createUiObject('Time Period', node.name, node, parentNode, chainParent, 'Time Period')
+        createUiObject('Time Period', node.name, node, parentNode, chainParent, 'Time Period', positionOffset)
         return
       }
       case 'Slippage': {
-        createUiObject('Slippage', node.name, node, parentNode, chainParent, 'Slippage')
+        createUiObject('Slippage', node.name, node, parentNode, chainParent, 'Slippage', positionOffset)
         return
       }
       case 'Fee Structure': {
-        createUiObject('Fee Structure', node.name, node, parentNode, chainParent, 'Fee Structure')
+        createUiObject('Fee Structure', node.name, node, parentNode, chainParent, 'Fee Structure', positionOffset)
         return
       }
       case 'Parameters': {
-        createUiObject('Parameters', node.name, node, parentNode, chainParent, 'Parameters')
+        createUiObject('Parameters', node.name, node, parentNode, chainParent, 'Parameters', positionOffset)
         if (node.baseAsset !== undefined) {
-          createUiObjectFromNode(node.baseAsset, node, node)
+          createUiObjectFromNode(node.baseAsset, node, node, positionOffset)
         }
         if (node.timeRange !== undefined) {
-          createUiObjectFromNode(node.timeRange, node, node)
+          createUiObjectFromNode(node.timeRange, node, node, positionOffset)
         }
         if (node.timePeriod !== undefined) {
-          createUiObjectFromNode(node.timePeriod, node, node)
+          createUiObjectFromNode(node.timePeriod, node, node, positionOffset)
         }
         if (node.slippage !== undefined) {
-          createUiObjectFromNode(node.slippage, node, node)
+          createUiObjectFromNode(node.slippage, node, node, positionOffset)
         }
         if (node.feeStructure !== undefined) {
-          createUiObjectFromNode(node.feeStructure, node, node)
+          createUiObjectFromNode(node.feeStructure, node, node, positionOffset)
         }
         if (node.key !== undefined) {
-          createUiObjectFromNode(node.key, node, node)
+          createUiObjectFromNode(node.key, node, node, positionOffset)
         }
         return
       }
       case 'Trading System': {
         let tradingSystem = node
-        createUiObject('Trading System', tradingSystem.name, tradingSystem, parentNode, chainParent, 'Trading System')
+        createUiObject('Trading System', tradingSystem.name, tradingSystem, parentNode, chainParent, 'Trading System', positionOffset)
         for (let m = 0; m < node.strategies.length; m++) {
           let strategy = node.strategies[m]
-          createUiObjectFromNode(strategy, tradingSystem, tradingSystem)
+          createUiObjectFromNode(strategy, tradingSystem, tradingSystem, positionOffset)
         }
         if (node.parameters !== undefined) {
-          createUiObjectFromNode(node.parameters, node, node)
+          createUiObjectFromNode(node.parameters, node, node, positionOffset)
         }
         return
       }
       case 'Personal Data': {
-        createUiObject('Personal Data', node.name, node, parentNode, chainParent, 'Personal Data')
+        createUiObject('Personal Data', node.name, node, parentNode, chainParent, 'Personal Data', positionOffset)
         for (let m = 0; m < node.exchangeAccounts.length; m++) {
           let exchangeAccount = node.exchangeAccounts[m]
-          createUiObjectFromNode(exchangeAccount, node, node)
+          createUiObjectFromNode(exchangeAccount, node, node, positionOffset)
         }
         return
       }
       case 'Exchange Account': {
-        createUiObject('Exchange Account', node.name, node, parentNode, chainParent, 'Exchange Account')
+        createUiObject('Exchange Account', node.name, node, parentNode, chainParent, 'Exchange Account', positionOffset)
         for (let m = 0; m < node.assets.length; m++) {
           let asset = node.assets[m]
-          createUiObjectFromNode(asset, node, node)
+          createUiObjectFromNode(asset, node, node, positionOffset)
         }
         for (let m = 0; m < node.keys.length; m++) {
           let key = node.keys[m]
-          createUiObjectFromNode(key, node, node)
+          createUiObjectFromNode(key, node, node, positionOffset)
         }
         return
       }
       case 'Exchange Account Asset': {
-        createUiObject('Exchange Account Asset', node.name, node, parentNode, chainParent, 'Exchange Account Asset')
+        createUiObject('Exchange Account Asset', node.name, node, parentNode, chainParent, 'Exchange Account Asset', positionOffset)
         return
       }
       case 'Exchange Account Key': {
-        createUiObject('Exchange Account Key', node.name, node, parentNode, chainParent, 'Exchange Account Key')
+        createUiObject('Exchange Account Key', node.name, node, parentNode, chainParent, 'Exchange Account Key', positionOffset)
         return
       }
       case 'Definition': {
@@ -451,12 +451,12 @@ function newUiObjectsFromNodes () {
             referenceChildren = node.savedPayload.referenceChildren
           }
         }
-        createUiObject('Definition', node.name, node, parentNode, chainParent, 'Definition')
+        createUiObject('Definition', node.name, node, parentNode, chainParent, 'Definition', positionOffset)
         if (node.tradingSystem !== undefined) {
-          createUiObjectFromNode(node.tradingSystem, node, node)
+          createUiObjectFromNode(node.tradingSystem, node, node, positionOffset)
         }
         if (node.personalData !== undefined) {
-          createUiObjectFromNode(node.personalData, node, node)
+          createUiObjectFromNode(node.personalData, node, node, positionOffset)
         }
         if (node.referenceChildren === undefined) {
           node.referenceChildren = []
@@ -469,96 +469,96 @@ function newUiObjectsFromNodes () {
         return
       }
       case 'Network': {
-        createUiObject('Network', node.name, node, parentNode, chainParent, 'Network')
+        createUiObject('Network', node.name, node, parentNode, chainParent, 'Network', positionOffset)
         if (node.networkNodes !== undefined) {
           for (let m = 0; m < node.networkNodes.length; m++) {
             let networkNode = node.networkNodes[m]
-            createUiObjectFromNode(networkNode, node, node)
+            createUiObjectFromNode(networkNode, node, node, positionOffset)
           }
         }
         return
       }
       case 'Network Node': {
-        createUiObject('Network Node', node.name, node, parentNode, chainParent, 'Network Node')
+        createUiObject('Network Node', node.name, node, parentNode, chainParent, 'Network Node', positionOffset)
         if (node.taskManagers !== undefined) {
           for (let m = 0; m < node.taskManagers.length; m++) {
             let taskManager = node.taskManagers[m]
-            createUiObjectFromNode(taskManager, node, node)
+            createUiObjectFromNode(taskManager, node, node, positionOffset)
           }
         }
         return
       }
       case 'Social Bots': {
-        createUiObject('Social Bots', node.name, node, parentNode, chainParent, 'Social Bots')
+        createUiObject('Social Bots', node.name, node, parentNode, chainParent, 'Social Bots', positionOffset)
         for (let m = 0; m < node.bots.length; m++) {
           let bot = node.bots[m]
-          createUiObjectFromNode(bot, node, node)
+          createUiObjectFromNode(bot, node, node, positionOffset)
         }
         return
       }
       case 'Telegram Bot': {
-        createUiObject('Telegram Bot', node.name, node, parentNode, chainParent, 'Telegram Bot')
+        createUiObject('Telegram Bot', node.name, node, parentNode, chainParent, 'Telegram Bot', positionOffset)
         for (let m = 0; m < node.announcements.length; m++) {
           let announcement = node.announcements[m]
-          createUiObjectFromNode(announcement, node, node)
+          createUiObjectFromNode(announcement, node, node, positionOffset)
         }
         return
       }
       case 'Announcement': {
-        createUiObject('Announcement', node.name, node, parentNode, chainParent, 'Announcement')
+        createUiObject('Announcement', node.name, node, parentNode, chainParent, 'Announcement', positionOffset)
         if (node.formula !== undefined) {
-          createUiObjectFromNode(node.formula, node, node)
+          createUiObjectFromNode(node.formula, node, node, positionOffset)
         }
         return
       }
       case 'Layer Manager': {
-        createUiObject('Layer Manager', node.name, node, parentNode, chainParent, 'Layer Manager')
+        createUiObject('Layer Manager', node.name, node, parentNode, chainParent, 'Layer Manager', positionOffset)
         for (let m = 0; m < node.layers.length; m++) {
           let layer = node.layers[m]
-          createUiObjectFromNode(layer, node, node)
+          createUiObjectFromNode(layer, node, node, positionOffset)
         }
         return
       }
       case 'Layer': {
-        createUiObject('Layer', node.name, node, parentNode, chainParent, 'Layer')
+        createUiObject('Layer', node.name, node, parentNode, chainParent, 'Layer', positionOffset)
         return
       }
       case 'Task Manager': {
-        createUiObject('Task Manager', node.name, node, parentNode, chainParent, 'Task Manager')
+        createUiObject('Task Manager', node.name, node, parentNode, chainParent, 'Task Manager', positionOffset)
         for (let m = 0; m < node.tasks.length; m++) {
           let task = node.tasks[m]
-          createUiObjectFromNode(task, node, node)
+          createUiObjectFromNode(task, node, node, positionOffset)
         }
         return
       }
       case 'Task': {
-        createUiObject('Task', node.name, node, parentNode, chainParent, 'Task')
+        createUiObject('Task', node.name, node, parentNode, chainParent, 'Task', positionOffset)
         if (node.bot !== undefined) {
-          createUiObjectFromNode(node.bot, node, node)
+          createUiObjectFromNode(node.bot, node, node, positionOffset)
         }
         return
       }
       case 'Sensor Bot Instance': {
-        createUiObject('Sensor Bot Instance', node.name, node, parentNode, chainParent, 'Sensor Bot Instance')
+        createUiObject('Sensor Bot Instance', node.name, node, parentNode, chainParent, 'Sensor Bot Instance', positionOffset)
         for (let m = 0; m < node.processes.length; m++) {
           let process = node.processes[m]
-          createUiObjectFromNode(process, node, node)
+          createUiObjectFromNode(process, node, node, positionOffset)
         }
         return
       }
       case 'Indicator Bot Instance': {
-        createUiObject('Indicator Bot Instance', node.name, node, parentNode, chainParent, 'Indicator Bot Instance')
+        createUiObject('Indicator Bot Instance', node.name, node, parentNode, chainParent, 'Indicator Bot Instance', positionOffset)
         for (let m = 0; m < node.processes.length; m++) {
           let process = node.processes[m]
-          createUiObjectFromNode(process, node, node)
+          createUiObjectFromNode(process, node, node, positionOffset)
         }
         return
       }
       case 'Trading Bot Instance': {
-        createUiObject('Trading Bot Instance', node.name, node, parentNode, chainParent, 'Trading Bot Instance')
+        createUiObject('Trading Bot Instance', node.name, node, parentNode, chainParent, 'Trading Bot Instance', positionOffset)
         for (let m = 0; m < node.processes.length; m++) {
           let process = node.processes[m]
-          createUiObjectFromNode(process, node, node)
+          createUiObjectFromNode(process, node, node, positionOffset)
         }
         return
       }
@@ -588,9 +588,9 @@ function newUiObjectsFromNodes () {
             }
           }
         }
-        createUiObject('Process Instance', node.name, node, parentNode, chainParent, 'Process Instance')
+        createUiObject('Process Instance', node.name, node, parentNode, chainParent, 'Process Instance', positionOffset)
         if (node.session !== undefined) {
-          createUiObjectFromNode(node.session, node, node)
+          createUiObjectFromNode(node.session, node, node, positionOffset)
         }
         if (referenceParent !== undefined) {
           node.savedPayload = {
@@ -609,15 +609,15 @@ function newUiObjectsFromNodes () {
             }
           }
         }
-        createUiObject('Backtesting Session', node.name, node, parentNode, chainParent, 'Backtesting Session')
+        createUiObject('Backtesting Session', node.name, node, parentNode, chainParent, 'Backtesting Session', positionOffset)
         if (node.parameters !== undefined) {
-          createUiObjectFromNode(node.parameters, node, node)
+          createUiObjectFromNode(node.parameters, node, node, positionOffset)
         }
         if (node.layerManager !== undefined) {
-          createUiObjectFromNode(node.layerManager, node, node)
+          createUiObjectFromNode(node.layerManager, node, node, positionOffset)
         }
         if (node.socialBots !== undefined) {
-          createUiObjectFromNode(node.socialBots, node, node)
+          createUiObjectFromNode(node.socialBots, node, node, positionOffset)
         }
         if (referenceParent !== undefined) {
           node.savedPayload = {
@@ -636,15 +636,15 @@ function newUiObjectsFromNodes () {
             }
           }
         }
-        createUiObject('Live Trading Session', node.name, node, parentNode, chainParent, 'Live Trading Session')
+        createUiObject('Live Trading Session', node.name, node, parentNode, chainParent, 'Live Trading Session', positionOffset)
         if (node.parameters !== undefined) {
-          createUiObjectFromNode(node.parameters, node, node)
+          createUiObjectFromNode(node.parameters, node, node, positionOffset)
         }
         if (node.layerManager !== undefined) {
-          createUiObjectFromNode(node.layerManager, node, node)
+          createUiObjectFromNode(node.layerManager, node, node, positionOffset)
         }
         if (node.socialBots !== undefined) {
-          createUiObjectFromNode(node.socialBots, node, node)
+          createUiObjectFromNode(node.socialBots, node, node, positionOffset)
         }
         if (referenceParent !== undefined) {
           node.savedPayload = {
@@ -663,15 +663,15 @@ function newUiObjectsFromNodes () {
             }
           }
         }
-        createUiObject('Fordward Testing Session', node.name, node, parentNode, chainParent, 'Fordward Testing Session')
+        createUiObject('Fordward Testing Session', node.name, node, parentNode, chainParent, 'Fordward Testing Session', positionOffset)
         if (node.parameters !== undefined) {
-          createUiObjectFromNode(node.parameters, node, node)
+          createUiObjectFromNode(node.parameters, node, node, positionOffset)
         }
         if (node.layerManager !== undefined) {
-          createUiObjectFromNode(node.layerManager, node, node)
+          createUiObjectFromNode(node.layerManager, node, node, positionOffset)
         }
         if (node.socialBots !== undefined) {
-          createUiObjectFromNode(node.socialBots, node, node)
+          createUiObjectFromNode(node.socialBots, node, node, positionOffset)
         }
         if (referenceParent !== undefined) {
           node.savedPayload = {
@@ -690,15 +690,15 @@ function newUiObjectsFromNodes () {
             }
           }
         }
-        createUiObject('Paper Trading Session', node.name, node, parentNode, chainParent, 'Paper Trading Session')
+        createUiObject('Paper Trading Session', node.name, node, parentNode, chainParent, 'Paper Trading Session', positionOffset)
         if (node.parameters !== undefined) {
-          createUiObjectFromNode(node.parameters, node, node)
+          createUiObjectFromNode(node.parameters, node, node, positionOffset)
         }
         if (node.layerManager !== undefined) {
-          createUiObjectFromNode(node.layerManager, node, node)
+          createUiObjectFromNode(node.layerManager, node, node, positionOffset)
         }
         if (node.socialBots !== undefined) {
-          createUiObjectFromNode(node.socialBots, node, node)
+          createUiObjectFromNode(node.socialBots, node, node, positionOffset)
         }
         if (referenceParent !== undefined) {
           node.savedPayload = {
@@ -709,58 +709,58 @@ function newUiObjectsFromNodes () {
       }
 
       case 'Team': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         for (let m = 0; m < node.sensorBots.length; m++) {
           let sensorBot = node.sensorBots[m]
-          createUiObjectFromNode(sensorBot, node, node)
+          createUiObjectFromNode(sensorBot, node, node, positionOffset)
         }
         for (let m = 0; m < node.indicatorBots.length; m++) {
           let indicatorBot = node.indicatorBots[m]
-          createUiObjectFromNode(indicatorBot, node, node)
+          createUiObjectFromNode(indicatorBot, node, node, positionOffset)
         }
         for (let m = 0; m < node.tradingBots.length; m++) {
           let tradingBot = node.tradingBots[m]
-          createUiObjectFromNode(tradingBot, node, node)
+          createUiObjectFromNode(tradingBot, node, node, positionOffset)
         }
         for (let m = 0; m < node.plotters.length; m++) {
           let plotter = node.plotters[m]
-          createUiObjectFromNode(plotter, node, node)
+          createUiObjectFromNode(plotter, node, node, positionOffset)
         }
         return
       }
       case 'Sensor Bot': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         for (let m = 0; m < node.processes.length; m++) {
           let process = node.processes[m]
-          createUiObjectFromNode(process, node, node)
+          createUiObjectFromNode(process, node, node, positionOffset)
         }
         for (let m = 0; m < node.products.length; m++) {
           let product = node.products[m]
-          createUiObjectFromNode(product, node, node)
+          createUiObjectFromNode(product, node, node, positionOffset)
         }
         return
       }
       case 'Indicator Bot': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         for (let m = 0; m < node.processes.length; m++) {
           let process = node.processes[m]
-          createUiObjectFromNode(process, node, node)
+          createUiObjectFromNode(process, node, node, positionOffset)
         }
         for (let m = 0; m < node.products.length; m++) {
           let product = node.products[m]
-          createUiObjectFromNode(product, node, node)
+          createUiObjectFromNode(product, node, node, positionOffset)
         }
         return
       }
       case 'Trading Bot': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         for (let m = 0; m < node.processes.length; m++) {
           let process = node.processes[m]
-          createUiObjectFromNode(process, node, node)
+          createUiObjectFromNode(process, node, node, positionOffset)
         }
         for (let m = 0; m < node.products.length; m++) {
           let product = node.products[m]
-          createUiObjectFromNode(product, node, node)
+          createUiObjectFromNode(product, node, node, positionOffset)
         }
         return
       }
@@ -773,21 +773,21 @@ function newUiObjectsFromNodes () {
             referenceChildren = node.savedPayload.referenceChildren
           }
         }
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (node.processOutput !== undefined) {
-          createUiObjectFromNode(node.processOutput, node, node)
+          createUiObjectFromNode(node.processOutput, node, node, positionOffset)
         }
         if (node.processDependencies !== undefined) {
-          createUiObjectFromNode(node.processDependencies, node, node)
+          createUiObjectFromNode(node.processDependencies, node, node, positionOffset)
         }
         if (node.statusReport !== undefined) {
-          createUiObjectFromNode(node.statusReport, node, node)
+          createUiObjectFromNode(node.statusReport, node, node, positionOffset)
         }
         if (node.executionStartedEvent !== undefined) {
-          createUiObjectFromNode(node.executionStartedEvent, node, node)
+          createUiObjectFromNode(node.executionStartedEvent, node, node, positionOffset)
         }
         if (node.executionFinishedEvent !== undefined) {
-          createUiObjectFromNode(node.executionFinishedEvent, node, node)
+          createUiObjectFromNode(node.executionFinishedEvent, node, node, positionOffset)
         }
         if (referenceChildren !== undefined) {
           node.savedPayload = {
@@ -797,22 +797,22 @@ function newUiObjectsFromNodes () {
         return
       }
       case 'Process Output': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         for (let m = 0; m < node.outputDatasets.length; m++) {
           let outputDataset = node.outputDatasets[m]
-          createUiObjectFromNode(outputDataset, node, node)
+          createUiObjectFromNode(outputDataset, node, node, positionOffset)
         }
         return
       }
       case 'Process Dependencies': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         for (let m = 0; m < node.statusDependencies.length; m++) {
           let statusDependency = node.statusDependencies[m]
-          createUiObjectFromNode(statusDependency, node, node)
+          createUiObjectFromNode(statusDependency, node, node, positionOffset)
         }
         for (let m = 0; m < node.dataDependencies.length; m++) {
           let dataDependency = node.dataDependencies[m]
-          createUiObjectFromNode(dataDependency, node, node)
+          createUiObjectFromNode(dataDependency, node, node, positionOffset)
         }
         return
       }
@@ -825,7 +825,7 @@ function newUiObjectsFromNodes () {
             referenceChildren = node.savedPayload.referenceChildren
           }
         }
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (referenceChildren !== undefined) {
           node.savedPayload = {
             referenceChildren: referenceChildren
@@ -843,7 +843,7 @@ function newUiObjectsFromNodes () {
             }
           }
         }
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (referenceParent !== undefined) {
           node.savedPayload = {
             referenceParent: referenceParent
@@ -860,7 +860,7 @@ function newUiObjectsFromNodes () {
             referenceChildren = node.savedPayload.referenceChildren
           }
         }
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (referenceChildren !== undefined) {
           node.savedPayload = {
             referenceChildren: referenceChildren
@@ -869,36 +869,36 @@ function newUiObjectsFromNodes () {
         return
       }
       case 'Calculations Procedure': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (node.initialization !== undefined) {
-          createUiObjectFromNode(node.initialization, node, node)
+          createUiObjectFromNode(node.initialization, node, node, positionOffset)
         }
         if (node.loop !== undefined) {
-          createUiObjectFromNode(node.loop, node, node)
+          createUiObjectFromNode(node.loop, node, node, positionOffset)
         }
         return
       }
       case 'Data Building Procedure': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (node.initialization !== undefined) {
-          createUiObjectFromNode(node.initialization, node, node)
+          createUiObjectFromNode(node.initialization, node, node, positionOffset)
         }
         if (node.loop !== undefined) {
-          createUiObjectFromNode(node.loop, node, node)
+          createUiObjectFromNode(node.loop, node, node, positionOffset)
         }
         return
       }
       case 'Procedure Initialization': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (node.code !== undefined) {
-          createUiObjectFromNode(node.code, node, node)
+          createUiObjectFromNode(node.code, node, node, positionOffset)
         }
         return
       }
       case 'Procedure Loop': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (node.code !== undefined) {
-          createUiObjectFromNode(node.code, node, node)
+          createUiObjectFromNode(node.code, node, node, positionOffset)
         }
         return
       }
@@ -912,7 +912,7 @@ function newUiObjectsFromNodes () {
             }
           }
         }
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (referenceParent !== undefined) {
           node.savedPayload = {
             referenceParent: referenceParent
@@ -930,7 +930,7 @@ function newUiObjectsFromNodes () {
             }
           }
         }
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (referenceParent !== undefined) {
           node.savedPayload = {
             referenceParent: referenceParent
@@ -948,7 +948,7 @@ function newUiObjectsFromNodes () {
             }
           }
         }
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (referenceParent !== undefined) {
           node.savedPayload = {
             referenceParent: referenceParent
@@ -957,34 +957,34 @@ function newUiObjectsFromNodes () {
         return
       }
       case 'Product Definition': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (node.record !== undefined) {
-          createUiObjectFromNode(node.record, node, node)
+          createUiObjectFromNode(node.record, node, node, positionOffset)
         }
         for (let m = 0; m < node.datasets.length; m++) {
           let dataset = node.datasets[m]
-          createUiObjectFromNode(dataset, node, node)
+          createUiObjectFromNode(dataset, node, node, positionOffset)
         }
         if (node.calculations !== undefined) {
-          createUiObjectFromNode(node.calculations, node, node)
+          createUiObjectFromNode(node.calculations, node, node, positionOffset)
         }
         if (node.dataBuilding !== undefined) {
-          createUiObjectFromNode(node.dataBuilding, node, node)
+          createUiObjectFromNode(node.dataBuilding, node, node, positionOffset)
         }
         return
       }
       case 'Record Definition': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         for (let m = 0; m < node.properties.length; m++) {
           let property = node.properties[m]
-          createUiObjectFromNode(property, node, node)
+          createUiObjectFromNode(property, node, node, positionOffset)
         }
         return
       }
       case 'Record Property': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (node.formula !== undefined) {
-          createUiObjectFromNode(node.formula, node, node)
+          createUiObjectFromNode(node.formula, node, node, positionOffset)
         }
         return
       }
@@ -997,7 +997,7 @@ function newUiObjectsFromNodes () {
             referenceChildren = node.savedPayload.referenceChildren
           }
         }
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (referenceChildren !== undefined) {
           node.savedPayload = {
             referenceChildren: referenceChildren
@@ -1006,28 +1006,28 @@ function newUiObjectsFromNodes () {
         return
       }
       case 'Plotter': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         for (let m = 0; m < node.modules.length; m++) {
           let module = node.modules[m]
-          createUiObjectFromNode(module, node, node)
+          createUiObjectFromNode(module, node, node, positionOffset)
         }
         return
       }
       case 'Plotter Module': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (node.code !== undefined) {
-          createUiObjectFromNode(node.code, node, node)
+          createUiObjectFromNode(node.code, node, node, positionOffset)
         }
         for (let m = 0; m < node.panels.length; m++) {
           let panel = node.panels[m]
-          createUiObjectFromNode(panel, node, node)
+          createUiObjectFromNode(panel, node, node, positionOffset)
         }
         return
       }
       case 'Plotter Panel': {
-        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type)
+        createUiObject(node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
         if (node.code !== undefined) {
-          createUiObjectFromNode(node.code, node, node)
+          createUiObjectFromNode(node.code, node, node, positionOffset)
         }
         return
       }
@@ -2059,15 +2059,24 @@ function newUiObjectsFromNodes () {
     return condition
   }
 
-  function createUiObject (uiObjectType, name, node, parentNode, chainParent, title) {
+  function createUiObject (uiObjectType, name, node, parentNode, chainParent, title, positionOffset) {
     let payload = {}
 
     if (name === '' || name === undefined) { name = 'My ' + uiObjectType }
     if (node.savedPayload !== undefined) {
+      /* If there is a position offset, we apply it here. */
+      if (positionOffset !== undefined) {
+        node.savedPayload.targetPosition.x = node.savedPayload.targetPosition.x + positionOffset.x
+        node.savedPayload.targetPosition.y = node.savedPayload.targetPosition.y + positionOffset.y
+        node.savedPayload.position.x = node.savedPayload.position.x + positionOffset.x
+        node.savedPayload.position.y = node.savedPayload.position.y + positionOffset.y
+      }
+
       payload.targetPosition = {
         x: node.savedPayload.targetPosition.x,
         y: node.savedPayload.targetPosition.y
       }
+
       node.savedPayload.targetPosition = undefined
 
       if (payload.targetPosition.x === null) { payload.targetPosition.x = spawnPosition.x }

DesignerSpace/Workspace/Workspace.js

@@ -224,11 +224,39 @@ function newWorkspace () {
         functionLibraryNodeDeleter.deleteWorkspace(thisObject.workspaceNode, thisObject.workspaceNode.rootNodes)
         thisObject.workspaceNode = droppedNode
         functionLibraryUiObjectsFromNodes.recreateWorkspace(thisObject.workspaceNode)
+        return
       } else {
-        let rootNode = functionLibraryProtocolNode.getProtocolNode(droppedNode)
-        thisObject.workspaceNode.rootNodes.push(rootNode)
-        functionLibraryUiObjectsFromNodes.createUiObjectFromNode(rootNode, undefined, undefined)
+        if (
+          droppedNode.type === 'Definition' ||
+          droppedNode.type === 'Network' ||
+          droppedNode.type === 'Team'
+        ) {
+          /* We will only respect the state of each object on these structures, if the structure does not yet exist inside the workspace */
+          let alreadyExists = false
+          for (let i = 0; i < thisObject.workspaceNode.rootNodes.length; i++) {
+            let rootNode = thisObject.workspaceNode.rootNodes[i]
+            if (droppedNode.id === rootNode.id) {
+              alreadyExists = true
+            }
+          }
+          if (alreadyExists === false) {
+            /* It does not exist, so we recreeate it respecting the inner state of each object. */
+            let positionOffset = {
+              x: spawnPosition.x - droppedNode.savedPayload.targetPosition.x,
+              y: spawnPosition.y - droppedNode.savedPayload.targetPosition.y
+            }
+
+            thisObject.workspaceNode.rootNodes.push(droppedNode)
+            functionLibraryUiObjectsFromNodes.createUiObjectFromNode(droppedNode, undefined, undefined, positionOffset)
+            return
+          }
+        }
       }
+
+      /* This is the default behaviour, which consists of cleaning all nodes that are not supported and then creating the UIObjects that remains on the data structure. */
+      let rootNode = functionLibraryProtocolNode.getProtocolNode(droppedNode)
+      thisObject.workspaceNode.rootNodes.push(rootNode)
+      functionLibraryUiObjectsFromNodes.createUiObjectFromNode(rootNode, undefined, undefined)
     } catch (err) {
       if (ERROR_LOG === true) { logger.write('[ERROR] spawn -> err = ' + err.stack) }
     }
@@ -255,7 +283,17 @@ function newWorkspace () {
         break
       case 'Share':
         {
-          let text = JSON.stringify(functionLibraryProtocolNode.getProtocolNode(payload.node, true))
+          let text
+          if (
+            payload.node.type === 'Definition' ||
+            payload.node.type === 'Network' ||
+            payload.node.type === 'Team'
+          ) {
+            text = JSON.stringify(functionLibraryProtocolNode.getProtocolNode(payload.node, true, false, true, true, true))
+          } else {
+            text = JSON.stringify(functionLibraryProtocolNode.getProtocolNode(payload.node, true))
+          }
+
           let nodeName = payload.node.name
           if (nodeName === undefined) {
             nodeName = ''
@@ -269,7 +307,17 @@ function newWorkspace () {
         break
       case 'Backup':
         {
-          let text = JSON.stringify(functionLibraryProtocolNode.getProtocolNode(payload.node, false))
+          let text
+          if (
+            payload.node.type === 'Definition' ||
+            payload.node.type === 'Network' ||
+            payload.node.type === 'Team'
+          ) {
+            text = JSON.stringify(functionLibraryProtocolNode.getProtocolNode(payload.node, false, false, true, true, true))
+          } else {
+            text = JSON.stringify(functionLibraryProtocolNode.getProtocolNode(payload.node, false))
+          }
+
           let nodeName = payload.node.name
           if (nodeName === undefined) {
             nodeName = ''