Reorg of Worlspace, not tested

FloatingSpace/StrategyPart.js

@@ -213,7 +213,7 @@ function newStrategyPart () {
         compatibleType = 'Trigger Stage'
         compatibleSubType = undefined
         break
-      case 'Initial Information':
+      case 'Initial Definition':
         compatibleType = 'Open Stage'
         compatibleSubType = undefined
         break

FloatingSpace/StrategyPartConstructor.js

@@ -483,7 +483,7 @@ function newStrategyPartConstructor () {
           }]
         break
       }
-      case 'Initial Information': {
+      case 'Initial Definition': {
         menuItemsInitialValues = [
           {
             action: 'Pin / Unpin',
@@ -500,7 +500,7 @@ function newStrategyPartConstructor () {
             angle: -135
           },
           {
-            action: 'Delete Initial Information',
+            action: 'Delete Initial Definition',
             actionFunction: payload.onMenuItemClick,
             label: 'Delete This Stage',
             visible: false,
@@ -847,7 +847,7 @@ function newStrategyPartConstructor () {
         level_2()
         break
       }
-      case 'Initial Information': {
+      case 'Initial Definition': {
         level_2()
         break
       }

FloatingSpace/StrategyPartTitle.js

@@ -77,7 +77,7 @@ function newStrategyPartTitle () {
       case 'Take Position Event': {
         break
       }
-      case 'Initial Information': {
+      case 'Initial Definition': {
         break
       }
       case 'Stop': {
@@ -277,4 +277,3 @@ function newStrategyPartTitle () {
     return title
   }
 }
-

Spaces/StrategySpace.js

@@ -49,7 +49,7 @@ function newStrategySpace () {
       ['Trigger On Event', 'startup'],
       ['Trigger Off Event', 'support'],
       ['Take Position Event', 'compass'],
-      ['Initial Information', 'task'],
+      ['Initial Definition', 'task'],
       ['Stop', 'pixel'],
       ['Take Profit', 'competition'],
       ['Phase', 'placeholder'],

StrategySpace/Workspace/FunctionLibraries/AttachDetach.js

@@ -0,0 +1,195 @@
+function newDetachAttach () {
+  thisObject = {
+    detachNode: detachNode,
+    attachNode: attachNode
+  }
+
+  return thisObject
+
+  function detachNode (node) {
+    switch (node.type) {
+      case 'Trading System': {
+        return
+      }
+      case 'Strategy': {
+        let payload = node.payload
+        for (let i = 0; i < payload.parentNode.strategies.length; i++) {
+          let strategy = payload.parentNode.strategies[i]
+          if (strategy.id === node.id) {
+            payload.parentNode.strategies.splice(i, 1)
+          }
+          completeDetachment(node)
+        }
+      }
+        break
+      case 'Trigger Stage': {
+        return
+      }
+      case 'Open Stage': {
+        return
+      }
+      case 'Manage Stage': {
+        return
+      }
+      case 'Close Stage': {
+        return
+      }
+      case 'Trigger On Event': {
+        return
+      }
+        break
+      case 'Trigger Off Event': {
+        return
+      }
+        break
+      case 'Take Position Event': {
+        return
+      }
+      case 'Initial Definition': {
+        return
+      }
+        break
+      case 'Stop': {
+        return
+      }
+        break
+      case 'Take Profit': {
+        return
+      }
+        break
+      case 'Condition': {
+        let payload = node.payload
+        for (let i = 0; i < payload.parentNode.conditions.length; i++) {
+          let condition = payload.parentNode.conditions[i]
+          if (condition.id === node.id) {
+            payload.parentNode.conditions.splice(i, 1)
+          }
+        }
+        completeDetachment(node)
+      }
+        break
+      case 'Situation': {
+        let payload = node.payload
+        for (let i = 0; i < payload.parentNode.situations.length; i++) {
+          let situation = payload.parentNode.situations[i]
+          if (situation.id === node.id) {
+            payload.parentNode.situations.splice(i, 1)
+          }
+        }
+        completeDetachment(node)
+      }
+        break
+      case 'Phase': {
+        let payload = node.payload
+        for (let i = 0; i < payload.parentNode.phases.length; i++) {
+          let phase = payload.parentNode.phases[i]
+          if (phase.id === node.id) {
+            if (i < payload.parentNode.phases.length - 1) {
+              let nextPhase = payload.parentNode.phases[i + 1]
+              if (i > 0) {
+                let previousPhase = payload.parentNode.phases[i - 1]
+                nextPhase.payload.chainParent = previousPhase
+              } else {
+                nextPhase.payload.chainParent = payload.parentNode
+              }
+            }
+            payload.parentNode.phases.splice(i, 1)
+            completeDetachment(node)
+            return
+          }
+        }
+      }
+    }
+  }
+
+  function attachNode (node, attachToNode) {
+    switch (node.type) {
+      case 'Strategy': {
+        node.payload.parentNode = attachToNode
+        node.payload.chainParent = attachToNode
+        node.payload.parentNode.strategies.push(node)
+        completeAttachment(node)
+      }
+        break
+      case 'Phase': {
+        switch (attachToNode.type) {
+          case 'Stop': {
+            node.payload.parentNode = attachToNode
+            if (attachToNode.phases.length > 0) {
+              let phase = attachToNode.phases[attachToNode.phases.length - 1]
+              node.payload.chainParent = phase
+            } else {
+              node.payload.chainParent = attachToNode
+            }
+            attachToNode.phases.push(node)
+            completeAttachment(node)
+          }
+            break
+          case 'Take Profit': {
+            node.payload.parentNode = attachToNode
+            if (attachToNode.phases.length > 0) {
+              let phase = attachToNode.phases[attachToNode.phases.length - 1]
+              node.payload.chainParent = phase
+            } else {
+              node.payload.chainParent = attachToNode
+            }
+            attachToNode.phases.push(node)
+            completeAttachment(node)
+          }
+            break
+          case 'Phase': {
+            node.payload.parentNode = attachToNode.payload.parentNode
+            for (let i = 0; i < node.payload.parentNode.phases.length; i++) {
+              let phase = node.payload.parentNode.phases[i]
+              if (attachToNode.id === phase.id) {
+                if (i === node.payload.parentNode.phases.length - 1) {
+                  node.payload.chainParent = attachToNode
+                  node.payload.parentNode.phases.push(node)
+                  completeAttachment(node)
+                } else {
+                  node.payload.chainParent = attachToNode
+                  let nextPhase = node.payload.parentNode.phases[i + 1]
+                  nextPhase.payload.chainParent = node
+                  node.payload.parentNode.phases.splice(i + 1, 0, node)
+                  completeAttachment(node)
+                  return
+                }
+              }
+            }
+          }
+        }
+      }
+        break
+      case 'Situation': {
+        node.payload.parentNode = attachToNode
+        node.payload.chainParent = attachToNode
+        node.payload.parentNode.situations.push(node)
+        completeAttachment(node)
+      }
+        break
+      case 'Condition': {
+        node.payload.parentNode = attachToNode
+        node.payload.chainParent = attachToNode
+        node.payload.parentNode.conditions.push(node)
+        completeAttachment(node)
+      }
+        break
+    }
+  }
+
+  function completeDetachment (node) {
+    node.payload.parentNode = undefined
+    node.payload.chainParent = undefined
+    rootNodes.push(node)
+  }
+
+  function completeAttachment (node) {
+    for (let i = 0; i < rootNodes.length; i++) {
+      let rootNode = rootNodes[i]
+      if (rootNode.id === node.id) {
+        rootNodes.splice(i, 1)
+        return
+      }
+    }
+  }
+}

StrategySpace/Workspace/FunctionLibraries/Delete.js

@@ -0,0 +1,218 @@
+function destroyPart (node) {
+  canvas.floatingSpace.strategyPartConstructor.destroyStrategyPart(node.payload)
+}
+
+function deleteStrategy (node) {
+  let payload = node.payload
+  if (payload.parentNode !== undefined) {
+    for (let j = 0; j < payload.parentNode.strategies.length; j++) {
+      let strategy = payload.parentNode.strategies[j]
+      if (strategy.id === node.id) {
+        payload.parentNode.strategies.splice(j, 1)
+      }
+    }
+  }
+  deleteTriggerStage(node.triggerStage)
+  deleteOpenStage(node.openStage)
+  deleteManageStage(node.manageStage)
+  deleteCloseStage(node.closeStage)
+  destroyPart(node)
+  cleanNode(node)
+}
+
+function deleteTriggerStage (node) {
+  let payload = node.payload
+  if (payload.parentNode !== undefined) {
+    payload.parentNode.triggerStage = undefined
+  }
+  deleteEvent(node.entryPoint)
+  deleteEvent(node.exitPoint)
+  deleteEvent(node.sellPoint)
+
+  destroyPart(node)
+  cleanNode(node)
+}
+
+function deleteOpenStage (node) {
+  let payload = node.payload
+  if (payload.parentNode !== undefined) {
+    payload.parentNode.openStage = undefined
+  }
+  deleteInitialDefinition(node.initialDefinition)
+
+  destroyPart(node)
+  cleanNode(node)
+}
+
+function deleteManageStage (node) {
+  let payload = node.payload
+  if (payload.parentNode !== undefined) {
+    payload.parentNode.manageStage = undefined
+  }
+  deleteManagedItem(node.stopLoss)
+  deleteManagedItem(node.buyOrder)
+
+  destroyPart(node)
+  cleanNode(node)
+}
+
+function deleteCloseStage (node) {
+  let payload = node.payload
+  if (payload.parentNode !== undefined) {
+    payload.parentNode.closeStage = undefined
+  }
+  destroyPart(node)
+  cleanNode(node)
+}
+
+function deleteInitialDefinition (node) {
+  let payload = node.payload
+  if (payload.parentNode !== undefined) {
+    payload.parentNode.initialDefinition = undefined
+  }
+
+  destroyPart(node)
+  cleanNode(node)
+}
+
+function deleteEvent (node) {
+  let payload = node.payload
+  if (payload.parentNode !== undefined) {
+    switch (node.type) {
+      case 'Trigger On Event': {
+        payload.parentNode.entryPoint = undefined
+        break
+      }
+      case 'Trigger Off Event': {
+        payload.parentNode.exitPoint = undefined
+        break
+      }
+      case 'Take Position Event': {
+        payload.parentNode.sellPoint = undefined
+        break
+      }
+    }
+  }
+
+  while (node.situations.length > 0) {
+    deleteSituation(node.situations[0])
+  }
+  destroyPart(node)
+  cleanNode(node)
+}
+
+function deleteManagedItem (node) {
+  let payload = node.payload
+  if (payload.parentNode !== undefined) {
+    switch (node.type) {
+      case 'Stop Loss': {
+        payload.parentNode.stopLoss = undefined
+        break
+      }
+      case 'Take Profit': {
+        payload.parentNode.buyOrder = undefined
+        break
+      }
+    }
+  }
+
+  while (node.phases.length > 0) {
+    deletePhase(node.phases[0])
+  }
+  destroyPart(node)
+  cleanNode(node)
+}
+
+function deletePhase (node) {
+  let payload = node.payload
+  if (payload.parentNode !== undefined) {
+    for (let k = 0; k < payload.parentNode.phases.length; k++) {
+      let phase = payload.parentNode.phases[k]
+      if (phase.id === node.id) {
+        while (phase.situations.length > 0) {
+          let situation = phase.situations[0]
+          deleteSituation(situation)
+        }
+        phase.situations = []
+      /* Before deleting this phase we need to give its chainParent to the next phase down the chain */
+        if (k < payload.parentNode.phases.length - 1) {
+          payload.parentNode.phases[k + 1].payload.chainParent = payload.chainParent
+        }
+      /* Continue destroying this phase */
+        payload.parentNode.phases.splice(k, 1)
+        destroyPart(phase)
+        cleanNode(phase)
+        return
+      }
+    }
+  } else {
+    while (node.situations.length > 0) {
+      let situation = node.situations[0]
+      deleteSituation(situation)
+    }
+    node.situations = []
+    destroyPart(node)
+    cleanNode(node)
+  }
+}
+
+function deleteSituation (node) {
+  let payload = node.payload
+  if (payload.parentNode !== undefined) {
+    for (let j = 0; j < payload.parentNode.situations.length; j++) {
+      let situation = payload.parentNode.situations[j]
+      if (situation.id === node.id) {
+        while (situation.conditions.length > 0) {
+          let condition = situation.conditions[0]
+          deleteCondition(condition)
+        }
+        situation.conditions = []
+        payload.parentNode.situations.splice(j, 1)
+        destroyPart(situation)
+        cleanNode(situation)
+        return
+      }
+    }
+  } else {
+    while (node.conditions.length > 0) {
+      let condition = node.conditions[0]
+      deleteCondition(condition)
+    }
+    node.conditions = []
+    destroyPart(node)
+    cleanNode(node)
+  }
+}
+
+function deleteCondition (node) {
+  let payload = node.payload
+  if (payload.parentNode !== undefined) {
+    for (let i = 0; i < payload.parentNode.conditions.length; i++) {
+      let condition = payload.parentNode.conditions[i]
+      if (condition.id === node.id) {
+        payload.parentNode.conditions.splice(i, 1)
+        destroyPart(node)
+        cleanNode(condition)
+        return
+      }
+    }
+  } else {
+    destroyPart(node)
+    cleanNode(node)
+  }
+}
+
+function cleanNode (node) {
+  node.payload.targetPosition.x = undefined
+  node.payload.targetPosition.y = undefined
+  node.payload.visible = undefined
+  node.payload.subTitle = undefined
+  node.payload.title = undefined
+  node.payload.node = undefined
+  node.payload.parentNode = undefined
+  node.payload.chainParent = undefined
+  node.payload.onMenuItemClick = undefined
+  node.handle = undefined
+  node.payload = undefined
+  node.cleaned = true
+}

StrategySpace/Workspace/FunctionLibraries/PartsConstructor.js

@@ -0,0 +1,205 @@
+function createPartFromNode (node, parentNode, chainParent) {
+  switch (node.type) {
+    case 'Condition':
+      {
+        let condition = node
+        createPart('Condition', condition.name, condition, parentNode, chainParent, 'Condition')
+        return
+      }
+    case 'Situation': {
+      let situation = node
+      createPart('Situation', situation.name, situation, parentNode, chainParent, 'Situation')
+      for (let m = 0; m < node.conditions.length; m++) {
+        let condition = node.conditions[m]
+        createPartFromNode(condition, situation, situation)
+      }
+      return
+    }
+    case 'Phase': {
+      let phase = node
+      createPart('Phase', phase.name, phase, parentNode, chainParent, phase.subType)
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = node.situations[m]
+        createPartFromNode(situation, phase, phase)
+      }
+      return
+    }
+    case 'Stop': {
+      let lastPhase
+      let stop = node
+      createPart('Stop', stop.name, stop, parentNode, chainParent, 'Stop')
+      for (let m = 0; m < node.phases.length; m++) {
+        let phase = node.phases[m]
+        let thisChainParent
+        if (m === 0) {
+          thisChainParent = node
+        } else {
+          thisChainParent = lastPhase
+        }
+        lastPhase = phase
+        createPartFromNode(phase, stop, thisChainParent)
+      }
+      return
+    }
+    case 'Take Profit': {
+      let lastPhase
+      let takeProfit = node
+      createPart('Take Profit', takeProfit.name, takeProfit, parentNode, chainParent, 'Take Profit')
+      for (let m = 0; m < node.phases.length; m++) {
+        let phase = node.phases[m]
+        let thisChainParent
+        if (m === 0) {
+          thisChainParent = node
+        } else {
+          thisChainParent = lastPhase
+        }
+        lastPhase = phase
+        createPartFromNode(phase, takeProfit, thisChainParent)
+      }
+      return
+    }
+    case 'Initial Definition': {
+      createPart('Initial Definition', node.name, node, parentNode, chainParent, 'Initial Definition')
+      return
+    }
+    case 'Take Position Event': {
+      let event = node
+      createPart('Take Position Event', event.name, event, parentNode, chainParent, 'Take Position Event')
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = node.situations[m]
+        createPartFromNode(situation, event, event)
+      }
+      return
+    }
+    case 'Trigger On Event': {
+      let event = node
+      createPart('Trigger On Event', event.name, event, parentNode, chainParent, 'Trigger On Event')
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = node.situations[m]
+        createPartFromNode(situation, event, event)
+      }
+      return
+    }
+    case 'Trigger Off Event': {
+      let event = node
+      createPart('Trigger Off Event', event.name, event, parentNode, chainParent, 'Trigger Off Event')
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = node.situations[m]
+        createPartFromNode(situation, event, event)
+      }
+      return
+    }
+    case 'Trigger Stage': {
+      let stage = node
+      createPart('Trigger Stage', stage.name, stage, parentNode, chainParent, 'Trigger Stage')
+
+      if (node.entryPoint !== undefined) {
+        createPartFromNode(node.entryPoint, stage, stage)
+      }
+      if (node.exitPoint !== undefined) {
+        createPartFromNode(node.exitPoint, stage, stage)
+      }
+      if (node.sellPoint !== undefined) {
+        createPartFromNode(node.sellPoint, stage, stage)
+      }
+      return
+    }
+    case 'Open Stage': {
+      let stage = node
+      createPart('Open Stage', stage.name, stage, parentNode, chainParent, 'Open Stage')
+
+      if (node.initialDefinition !== undefined) {
+        createPartFromNode(node.initialDefinition, stage, stage)
+      }
+      return
+    }
+    case 'Manage Stage': {
+      let stage = node
+      createPart('Manage Stage', stage.name, stage, parentNode, chainParent, 'Manage Stage')
+
+      if (node.stopLoss !== undefined) {
+        createPartFromNode(node.stopLoss, stage, stage)
+      }
+      if (node.buyOrder !== undefined) {
+        createPartFromNode(node.buyOrder, stage, stage)
+      }
+      return
+    }
+    case 'Close Stage': {
+      let stage = node
+      createPart('Close Stage', stage.name, stage, parentNode, chainParent, 'Close Stage')
+      return
+    }
+    case 'Strategy': {
+      let strategy = node
+      createPart('Strategy', strategy.name, strategy, parentNode, chainParent, 'Strategy')
+      if (node.triggerStage !== undefined) {
+        createPartFromNode(node.triggerStage, strategy, strategy)
+      }
+      if (node.openStage !== undefined) {
+        createPartFromNode(node.openStage, strategy, strategy)
+      }
+      if (node.manageStage !== undefined) {
+        createPartFromNode(node.manageStage, strategy, strategy)
+      }
+      if (node.closeStage !== undefined) {
+        createPartFromNode(node.closeStage, strategy, strategy)
+      }
+      return
+    }
+    case 'Trading System': {
+      let tradingSystem = node
+      createPart('Trading System', tradingSystem.name, tradingSystem, parentNode, chainParent, 'Trading System')
+      for (let m = 0; m < node.strategies.length; m++) {
+        let strategy = node.strategies[m]
+        createPartFromNode(strategy, tradingSystem, tradingSystem)
+      }
+      return
+    }
+  }
+}
+
+function createPart (partType, name, node, parentNode, chainParent, title) {
+  let payload = {}
+
+  if (name === '' || name === undefined) { name = 'My ' + partType }
+  if (node.savedPayload !== undefined) {
+    payload.targetPosition = {
+      x: node.savedPayload.targetPosition.x,
+      y: node.savedPayload.targetPosition.y
+    }
+    node.savedPayload.targetPosition = undefined
+  } else {
+    if (chainParent === undefined) {
+      payload.targetPosition = {
+        x: spawnPosition.x,
+        y: spawnPosition.y
+      }
+    } else {
+      payload.targetPosition = {
+        x: chainParent.payload.position.x,
+        y: chainParent.payload.position.y
+      }
+    }
+  }
+
+  if (title !== undefined) {
+    payload.subTitle = title
+  } else {
+    payload.subTitle = partType
+  }
+
+  payload.visible = true
+  payload.title = name
+  payload.node = node
+  payload.parentNode = parentNode
+  payload.chainParent = chainParent
+  payload.onMenuItemClick = onMenuItemClick
+
+  if (node.id === undefined) {
+    node.id = newUniqueId()
+  }
+  node.payload = payload
+  node.type = partType
+  canvas.floatingSpace.strategyPartConstructor.createStrategyPart(payload)
+}

StrategySpace/Workspace/FunctionLibraries/ProtocolNode.js

@@ -0,0 +1,195 @@
+function getProtocolNode (node) {
+  switch (node.type) {
+    case 'Condition':
+      {
+        let condition = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          code: node.code
+        }
+        return condition
+      }
+    case 'Situation': {
+      let situation = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        conditions: []
+      }
+
+      for (let m = 0; m < node.conditions.length; m++) {
+        let condition = getProtocolNode(node.conditions[m])
+        situation.conditions.push(condition)
+      }
+      return situation
+    }
+    case 'Phase': {
+      let phase = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        code: node.code,
+        situations: []
+      }
+
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = getProtocolNode(node.situations[m])
+        phase.situations.push(situation)
+      }
+      return phase
+    }
+    case 'Stop': {
+      if (node === undefined) { return }
+      let stop = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        phases: []
+      }
+
+      for (let m = 0; m < node.phases.length; m++) {
+        let phase = getProtocolNode(node.phases[m])
+        stop.phases.push(phase)
+      }
+      return stop
+    }
+    case 'Take Profit': {
+      if (node === undefined) { return }
+      let takeProfit = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        phases: []
+      }
+
+      for (let m = 0; m < node.phases.length; m++) {
+        let phase = getProtocolNode(node.phases[m])
+        takeProfit.phases.push(phase)
+      }
+      return takeProfit
+    }
+    case 'Take Position Event': {
+      if (node === undefined) { return }
+      let event = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        situations: []
+      }
+
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = getProtocolNode(node.situations[m])
+        event.situations.push(situation)
+      }
+      return event
+    }
+    case 'Trigger On Event': {
+      if (node === undefined) { return }
+      let event = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        situations: []
+      }
+
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = getProtocolNode(node.situations[m])
+        event.situations.push(situation)
+      }
+      return event
+    }
+    case 'Trigger Off Event': {
+      if (node === undefined) { return }
+      let event = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        situations: []
+      }
+
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = getProtocolNode(node.situations[m])
+        event.situations.push(situation)
+      }
+      return event
+    }
+    case 'Initial Definition': {
+      if (node === undefined) { return }
+      let object = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name
+      }
+      return object
+    }
+    case 'Trigger Stage': {
+      if (node === undefined) { return }
+      let stage = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        entryPoint: getProtocolNode(node.entryPoint),
+        exitPoint: getProtocolNode(node.exitPoint),
+        sellPoint: getProtocolNode(node.sellPoint)
+      }
+      return stage
+    }
+    case 'Open Stage': {
+      if (node === undefined) { return }
+      let stage = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        initialDefinition: getProtocolNode(node.initialDefinition)
+      }
+      return stage
+    }
+    case 'Manage Stage': {
+      if (node === undefined) { return }
+      let stage = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        stopLoss: getProtocolNode(node.stopLoss),
+        buyOrder: getProtocolNode(node.buyOrder)
+      }
+      return stage
+    }
+    case 'Close Stage': {
+      if (node === undefined) { return }
+      let stage = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name
+      }
+      return stage
+    }
+    case 'Strategy': {
+      let strategy = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        triggerStage: getProtocolNode(node.triggerStage),
+        openStage: getProtocolNode(node.openStage),
+        manageStage: getProtocolNode(node.manageStage),
+        closeStage: getProtocolNode(node.closeStage)
+      }
+      return strategy
+    }
+    case 'Trading System': {
+      let tradingSystem = {
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        strategies: []
+      }
+
+      for (let m = 0; m < node.strategies.length; m++) {
+        let strategy = getProtocolNode(node.strategies[m])
+        tradingSystem.strategies.push(strategy)
+      }
+      return tradingSystem
+    }
+  }
+}

StrategySpace/Workspace/FunctionLibraries/WorkspaceNode.js

@@ -0,0 +1,246 @@
+function getWorkspaceNode (node) {
+  switch (node.type) {
+    case 'Condition':
+      {
+        let condition = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          code: node.code,
+          savedPayload: getSavedPayload(node)
+        }
+        return condition
+      }
+    case 'Situation': {
+      let situation = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        conditions: [],
+        savedPayload: getSavedPayload(node)
+      }
+
+      for (let m = 0; m < node.conditions.length; m++) {
+        let condition = getWorkspaceNode(node.conditions[m])
+        situation.conditions.push(condition)
+      }
+      return situation
+    }
+    case 'Phase': {
+      let phase = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        code: node.code,
+        situations: [],
+        savedPayload: getSavedPayload(node)
+      }
+
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = getWorkspaceNode(node.situations[m])
+        phase.situations.push(situation)
+      }
+      return phase
+    }
+    case 'Stop': {
+      if (node === undefined) { return }
+      let stop = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        phases: [],
+        savedPayload: getSavedPayload(node)
+      }
+
+      for (let m = 0; m < node.phases.length; m++) {
+        let phase = getWorkspaceNode(node.phases[m])
+        stop.phases.push(phase)
+      }
+      return stop
+    }
+    case 'Take Profit': {
+      if (node === undefined) { return }
+      let takeProfit = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        phases: [],
+        savedPayload: getSavedPayload(node)
+      }
+
+      for (let m = 0; m < node.phases.length; m++) {
+        let phase = getWorkspaceNode(node.phases[m])
+        takeProfit.phases.push(phase)
+      }
+      return takeProfit
+    }
+    case 'Take Position Event': {
+      if (node === undefined) { return }
+      let event = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        situations: [],
+        savedPayload: getSavedPayload(node)
+      }
+
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = getWorkspaceNode(node.situations[m])
+        event.situations.push(situation)
+      }
+      return event
+    }
+    case 'Trigger On Event': {
+      if (node === undefined) { return }
+      let event = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        situations: [],
+        savedPayload: getSavedPayload(node)
+      }
+
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = getWorkspaceNode(node.situations[m])
+        event.situations.push(situation)
+      }
+      return event
+    }
+    case 'Trigger Off Event': {
+      if (node === undefined) { return }
+      let event = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        situations: [],
+        savedPayload: getSavedPayload(node)
+      }
+
+      for (let m = 0; m < node.situations.length; m++) {
+        let situation = getWorkspaceNode(node.situations[m])
+        event.situations.push(situation)
+      }
+      return event
+    }
+    case 'Initial Definition': {
+      if (node === undefined) { return }
+      let object = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        savedPayload: getSavedPayload(node)
+      }
+      return object
+    }
+    case 'Trigger Stage': {
+      if (node === undefined) { return }
+      let stage = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        entryPoint: getWorkspaceNode(node.entryPoint),
+        exitPoint: getWorkspaceNode(node.exitPoint),
+        sellPoint: getWorkspaceNode(node.sellPoint),
+        savedPayload: getSavedPayload(node)
+      }
+      return stage
+    }
+    case 'Open Stage': {
+      if (node === undefined) { return }
+      let stage = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        initialDefinition: getWorkspaceNode(node.initialDefinition),
+        savedPayload: getSavedPayload(node)
+      }
+      return stage
+    }
+    case 'Manage Stage': {
+      if (node === undefined) { return }
+      let stage = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        stopLoss: getWorkspaceNode(node.stopLoss),
+        buyOrder: getWorkspaceNode(node.buyOrder),
+        savedPayload: getSavedPayload(node)
+      }
+      return stage
+    }
+    case 'Close Stage': {
+      if (node === undefined) { return }
+      let stage = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        savedPayload: getSavedPayload(node)
+      }
+      return stage
+    }
+    case 'Strategy': {
+      let strategy = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        entryPoint: getWorkspaceNode(node.entryPoint),
+        exitPoint: getWorkspaceNode(node.exitPoint),
+        sellPoint: getWorkspaceNode(node.sellPoint),
+        stopLoss: getWorkspaceNode(node.stopLoss),
+        buyOrder: getWorkspaceNode(node.buyOrder),
+        savedPayload: getSavedPayload(node)
+      }
+      return strategy
+    }
+    case 'Trading System': {
+      let tradingSystem = {
+        id: node.id,
+        type: node.type,
+        subType: node.subType,
+        name: node.name,
+        strategies: [],
+        savedPayload: getSavedPayload(node)
+      }
+
+      for (let m = 0; m < node.strategies.length; m++) {
+        let strategy = getWorkspaceNode(node.strategies[m])
+        tradingSystem.strategies.push(strategy)
+      }
+      return tradingSystem
+    }
+  }
+}
+
+function getSavedPayload (node) {
+  let savedPayload = {
+    position: {
+      x: node.payload.position.x,
+      y: node.payload.position.y
+    },
+    targetPosition: {
+      x: node.payload.targetPosition.x,
+      y: node.payload.targetPosition.y
+    },
+    floatingObject: {
+      isPinned: node.payload.floatingObject.isPinned
+    },
+    uiObject: {
+      isRunning: node.payload.uiObject.isRunning
+    }
+  }
+  return savedPayload
+}

StrategySpace/Workspace/Workspace.js

@@ -0,0 +1,374 @@
+
+function newWorkspace () {
+  const MODULE_NAME = 'Workspace'
+
+  let thisObject = {
+    tradingSystem: undefined,
+    container: undefined,
+    idAtStrategizer: undefined,
+    physics: physics,
+    spawn: spawn,
+    detachNode: detachNode,
+    attachNode: attachNode,
+    getContainer: getContainer,
+    initialize: initialize,
+    finalize: finalize
+  }
+
+  thisObject.container = newContainer()
+  thisObject.container.initialize(MODULE_NAME)
+  thisObject.container.isClickeable = false
+  thisObject.container.isDraggeable = false
+  thisObject.container.isWheelable = false
+  thisObject.container.detectMouseOver = false
+  thisObject.container.frame.radius = 0
+  thisObject.container.frame.position.x = 0
+  thisObject.container.frame.position.y = 0
+  thisObject.container.frame.width = 0
+  thisObject.container.frame.height = 0
+
+  spawnPosition = {
+    x: canvas.floatingSpace.container.frame.width / 2,
+    y: canvas.floatingSpace.container.frame.height / 2
+  }
+
+  let rootNodes = []
+
+  return thisObject
+
+  function finalize () {
+    thisObject.tradingSystem = undefined
+    thisObject.container.finalize()
+    thisObject.container = undefined
+  }
+
+  async function initialize () {
+    let savedWorkspace = window.localStorage.getItem('workspace')
+    if (savedWorkspace === null) {
+      initializeLoadingFromStrategizer()
+    } else {
+      workspace = JSON.parse(savedWorkspace)
+      rootNodes = workspace.rootNodes
+      thisObject.idAtStrategizer = workspace.idAtStrategizer
+      if (thisObject.idAtStrategizer === undefined) {
+        initializeLoadingFromStrategizer()
+      } else {
+        for (let i = 0; i < rootNodes.length; i++) {
+          let rootNode = rootNodes[i]
+          createPartFromNode(rootNode, undefined, undefined)
+        }
+      }
+    }
+  }
+
+  async function initializeLoadingFromStrategizer () {
+    await canvas.strategySpace.strategizerGateway.loadFromStrategyzer()
+    let tradingSystem = canvas.strategySpace.strategizerGateway.strategizerData
+    if (tradingSystem !== undefined) {
+      let adaptedTradingSystem = {
+        strategies: tradingSystem.subStrategies
+      }
+      thisObject.idAtStrategizer = tradingSystem.id
+      rootNodes.push(adaptedTradingSystem)
+      generateStrategyParts(adaptedTradingSystem)
+      thisObject.tradingSystem = adaptedTradingSystem
+      thisObject.tradingSystem.payload.uiObject.setRunningStatus()
+    }
+  }
+
+  function getContainer (point) {
+
+  }
+
+  function detachNode (node) {
+    let functionsLibrary = newDetachAttach()
+    functionsLibrary.detachNode(node)
+  }
+
+  function attachNode (node) {
+    let functionsLibrary = newDetachAttach()
+    functionsLibrary.attachNode(node)
+  }
+
+  function physics () {
+    /* Here we will save all the workspace related objects into the local storage */
+    let stringifyReadyNodes = []
+    for (let i = 0; i < rootNodes.length; i++) {
+      let rootNode = rootNodes[i]
+      let workspaceNode = getWorkspaceNode(rootNode)
+      stringifyReadyNodes.push(workspaceNode)
+    }
+    let workspace = {
+      idAtStrategizer: thisObject.idAtStrategizer,
+      rootNodes: stringifyReadyNodes
+    }
+    let textToSave = JSON.stringify(workspace)
+    // window.localStorage.setItem('workspace', textToSave)
+  }
+
+  function spawn (nodeText, point) {
+    point = canvas.floatingSpace.container.frame.unframeThisPoint(point)
+    spawnPosition.x = point.x
+    spawnPosition.y = point.y
+
+    let dirtyNode = JSON.parse(nodeText)
+    let rootNode = getProtocolNode(dirtyNode)
+    rootNodes.push(rootNode)
+    createPartFromNode(rootNode, undefined, undefined)
+  }
+
+  function generateStrategyParts (node) {
+    let lastPhase
+    let tradingSystem = node
+
+    createPart('Trading System', tradingSystem.name, tradingSystem, undefined, undefined)
+
+    for (m = 0; m < tradingSystem.strategies.length; m++) {
+      let strategy = tradingSystem.strategies[m]
+      createPart('Strategy', strategy.name, strategy, tradingSystem, tradingSystem)
+
+      createPart('Trigger On Event', '', strategy.entryPoint, strategy, strategy)
+      for (let k = 0; k < strategy.entryPoint.situations.length; k++) {
+        let situation = strategy.entryPoint.situations[k]
+        createPart('Situation', situation.name, situation, strategy.entryPoint, strategy.entryPoint, 'Trigger On' + ' ' + 'Situation')
+
+        for (let m = 0; m < situation.conditions.length; m++) {
+          let condition = situation.conditions[m]
+          createPart('Condition', condition.name, condition, situation, situation, 'Condition')
+        }
+      }
+
+      createPart('Trigger Off Event', '', strategy.exitPoint, strategy, strategy)
+      for (let k = 0; k < strategy.exitPoint.situations.length; k++) {
+        let situation = strategy.exitPoint.situations[k]
+        createPart('Situation', situation.name, situation, strategy.exitPoint, strategy.exitPoint, 'Trigger Off' + ' ' + 'Situation')
+
+        for (let m = 0; m < situation.conditions.length; m++) {
+          let condition = situation.conditions[m]
+          createPart('Condition', condition.name, condition, situation, situation, 'Condition')
+        }
+      }
+
+      createPart('Take Position Event', '', strategy.sellPoint, strategy, strategy)
+      for (let k = 0; k < strategy.sellPoint.situations.length; k++) {
+        let situation = strategy.sellPoint.situations[k]
+        createPart('Situation', situation.name, situation, strategy.sellPoint, strategy.sellPoint, 'Take Position' + ' ' + 'Situation')
+
+        for (let m = 0; m < situation.conditions.length; m++) {
+          let condition = situation.conditions[m]
+          createPart('Condition', condition.name, condition, situation, situation, 'Condition')
+        }
+      }
+
+      createPart('Stop', '', strategy.stopLoss, strategy, strategy)
+      for (let p = 0; p < strategy.stopLoss.phases.length; p++) {
+        let phase = strategy.stopLoss.phases[p]
+
+        let chainParent
+        if (p === 0) {
+          chainParent = strategy.stopLoss
+        } else {
+          chainParent = lastPhase
+        }
+        lastPhase = phase
+        createPart('Phase', phase.name, phase, strategy.stopLoss, chainParent, 'Stop Phase')
+
+        for (let k = 0; k < phase.situations.length; k++) {
+          let situation = phase.situations[k]
+          createPart('Situation', situation.name, situation, phase, phase, 'Situation')
+
+          for (let m = 0; m < situation.conditions.length; m++) {
+            let condition = situation.conditions[m]
+            createPart('Condition', condition.name, condition, situation, situation, 'Condition')
+          }
+        }
+      }
+
+      createPart('Take Profit', '', strategy.buyOrder, strategy, strategy)
+      for (let p = 0; p < strategy.buyOrder.phases.length; p++) {
+        let phase = strategy.buyOrder.phases[p]
+        let chainParent
+        if (p === 0) {
+          chainParent = strategy.buyOrder
+        } else {
+          chainParent = lastPhase
+        }
+        lastPhase = phase
+        createPart('Phase', phase.name, phase, strategy.buyOrder, chainParent, 'Take Profit Phase')
+
+        for (let k = 0; k < phase.situations.length; k++) {
+          let situation = phase.situations[k]
+          createPart('Situation', situation.name, situation, phase, phase, 'Situation')
+
+          for (let m = 0; m < situation.conditions.length; m++) {
+            let condition = situation.conditions[m]
+            createPart('Condition', condition.name, condition, situation, situation, 'Condition')
+          }
+        }
+      }
+    }
+  }
+
+  async function onMenuItemClick (payload, action) {
+    switch (action) {
+      case 'Save Trading System':
+        {
+          let result = await canvas.strategySpace.strategizerGateway.saveToStrategyzer()
+          return result
+          break
+        }
+
+      case 'Edit Code':
+
+        break
+      case 'Download':
+
+        let text = JSON.stringify(getProtocolNode(payload.node))
+        let nodeName = payload.node.name
+        if (nodeName === undefined) {
+          nodeName = ''
+        } else {
+          nodeName = '.' + nodeName
+        }
+        let fileName = payload.node.type + nodeName + '.json'
+        download(fileName, text)
+
+        break
+
+      case 'New Strategy':
+        {
+          let strategyParent = payload.node
+
+          let strategy = {
+            name: 'New Strategy',
+            active: true,
+            triggerStage: {
+              entryPoint: {
+                situations: []
+              },
+              exitPoint: {
+                situations: []
+              },
+              sellPoint: {
+                situations: []
+              }
+            },
+            openStage: {
+              initialDefinition: {}
+            },
+            manageStage: {
+              stopLoss: {
+                phases: []
+              },
+              buyOrder: {
+                phases: []
+              }
+            },
+            closeStage: {
+            }
+          }
+
+          strategyParent.strategies.push(strategy)
+          createPart('Strategy', strategy.name, strategy, strategyParent, strategyParent, 'Strategy')
+          createPart('Trigger Stage', '', strategy.triggerStage, strategy, strategy, 'Trigger Stage')
+          createPart('Open Stage', '', strategy.openStage, strategy, strategy, 'Open Stage')
+          createPart('Manage Stage', '', strategy.manageStage, strategy, strategy, 'Manage Stage')
+          createPart('Close Stage', '', strategy.closeStage, strategy, strategy, 'Close Stage')
+          createPart('Trigger On Event', '', strategy.triggerStage.entryPoint, strategy.triggerStage, strategy.triggerStage)
+          createPart('Trigger Off Event', '', strategy.triggerStage.exitPoint, strategy.triggerStage, strategy.triggerStage)
+          createPart('Take Position Event', '', strategy.triggerStage.sellPoint, strategy.triggerStage, strategy.triggerStage)
+          createPart('Initial Definition', '', strategy.openStage.initialDefinition, strategy.openStage, strategy.openStage)
+          createPart('Stop', '', strategy.manageStage.stopLoss, strategy.manageStage, strategy.manageStage)
+          createPart('Take Profit', '', strategy.manageStage.buyOrder, strategy.manageStage, strategy.manageStage)
+        }
+        break
+      case 'Add Phase':
+        {
+          let phaseParent = payload.node
+          let m = phaseParent.phases.length
+          let phase = {
+            name: 'New Phase',
+            code: '',
+            situations: []
+          }
+          phaseParent.phases.push(phase)
+          let phaseChainParent
+          if (m > 0) {
+            phaseChainParent = phaseParent.phases[m - 1]
+          } else {
+            phaseChainParent = phaseParent
+          }
+          createPart('Phase', phase.name, phase, phaseParent, phaseChainParent, 'Phase')
+        }
+        break
+      case 'Add Situation':
+        {
+          let phase = payload.node
+          let m = phase.situations.length
+          let situation = {
+            name: 'New Situation',
+            conditions: []
+          }
+          phase.situations.push(situation)
+          createPart('Situation', situation.name, situation, phase, phase, 'Situation')
+        }
+        break
+      case 'Add Condition':
+        {
+          let situation = payload.node
+          let m = situation.conditions.length
+          let condition = {
+            name: 'New Condition',
+            code: ''
+          }
+          situation.conditions.push(condition)
+          createPart('Condition', condition.name, condition, situation, situation, 'Condition')
+        }
+        break
+      case 'Delete Strategy': {
+        deleteStrategy(payload.node)
+        break
+      }
+      case 'Delete Trigger Stage': {
+        deleteTriggerStage(payload.node)
+        break
+      }
+      case 'Delete Open Stage': {
+        deleteOpenStage(payload.node)
+        break
+      }
+      case 'Delete Manage Stage': {
+        deleteManageStage(payload.node)
+        break
+      }
+      case 'Delete Close Stage': {
+        deleteClose(payload.node)
+        break
+      }
+      case 'Delete Phase': {
+        deletePhase(payload.node)
+        break
+      }
+      case 'Delete Situation': {
+        deleteSituation(payload.node)
+        break
+      }
+      case 'Delete Condition': {
+        deleteCondition(payload.node)
+        break
+      }
+      default:
+
+    }
+  }
+
+  function download (filename, text) {
+    let element = document.createElement('a')
+    element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(text))
+    element.setAttribute('download', filename)
+    element.style.display = 'none'
+    document.body.appendChild(element)
+    element.click()
+    document.body.removeChild(element)
+  }
+}