integration/cauldron/ConceptTreeGenerator.js

  1. /**
  2.  *  ConceptDecorator - decorates Concept nodes in TreeBrowser trees
  3.  *  
  4.  *  This code is licensed under the MIT License (MIT).
  5.  *  
  6.  *  Copyright 2020, 2021, 2022 Rolf Bagge, Janus B. Kristensen, CAVI,
  7.  *  Center for Advanced Visualization and Interaction, Aarhus University
  8.  *  
  9.  *  Permission is hereby granted, free of charge, to any person obtaining a copy
  10.  *  of this software and associated documentation files (the “Software”), to deal
  11.  *  in the Software without restriction, including without limitation the rights 
  12.  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
  13.  *  copies of the Software, and to permit persons to whom the Software is 
  14.  *  furnished to do so, subject to the following conditions:
  15.  *  
  16.  *  The above copyright notice and this permission notice shall be included in 
  17.  *  all copies or substantial portions of the Software.
  18.  *  
  19.  *  THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
  20.  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  21.  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
  22.  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
  23.  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
  24.  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
  25.  *  THE SOFTWARE.
  26.  *  
  27.  */
  29. /**
  30.  *
  31.  */
  32. class ConceptTreeGenerator extends TreeGenerator {
  33.     constructor(parentNode) {
  34.         super();
  36.         this.rootNode = new TreeNode({
  37.             type: "ConceptRootNode",
  38.             context: null
  39.         });
  40.         TreeGenerator.decorateNode(this.rootNode);
  41.         parentNode.addNode(this.rootNode);
  42.     }
  43.     
  44.     onAddDatastore(datastore){
  45.         let activeElement = document.activeElement;
  47.         let self = this;
  48.         let datastoreNode = new TreeNode({
  49.             type: "DatastoreNode",
  50.             lookupKey: datastore.name,
  51.             context: datastore
  52.         });
  53.         TreeGenerator.decorateNode(datastoreNode);
  54.         this.rootNode.addNode(datastoreNode);
  55.         this.rootNode.unfold();
  56.         
  57.         datastore.registerDestroyCallback(()=>{
  58.             self.destroyNode(datastoreNode);
  59.         });
  60.         
  61.         // Concepts
  62.         datastore.registerConceptAddedCallback((concept)=>{
  63.             datastoreNode.unfold();
  64.             
  65.             let conceptNode = new TreeNode({
  66.                 type: "ConceptNode",
  67.                 lookupKey: concept.name,
  68.                 context: concept
  69.             });
  70.             
  71.             // Instances
  72.             let instanceAddedCallback = datastore.registerConceptInstanceAddedCallback(concept, (uuid)=>{
  73.                 let node = self.addInstanceNode(datastore, conceptNode, concept, uuid);
  74.                 let instanceRemovedCallback = datastore.registerConceptInstanceRemovedCallback(concept, (removedUUID)=>{
  75.                     if (removedUUID===uuid){
  76.                         self.destroyNode(node);
  77.                     }
  78.                 });
  79.                 node.cleanup = [()=>{
  80.                     datastore.removeConceptInstanceRemovedCallback(concept, instanceRemovedCallback);
  81.                 }];
  82.             });
  83.             
  84.             TreeGenerator.decorateNode(conceptNode);
  85.             datastoreNode.addNode(conceptNode);
  86.         });
  88.         // STUB: Concepts cannot be removed right now but should be cleaned up here
  89.         // datastore.removeConceptInstanceAddedCallback(concept, instanceAddedCallback);
  90.         
  91.     }    
  92.     
  93.     destroyNode(node){
  94.         node.parentNode.removeNode(node);
  95.         
  96.         // Run cleanup
  97.         if (node.cleanup){
  98.             for (let entry of node.cleanup){
  99.                 entry();
  100.             }
  101.         }
  102.         
  103.         // Destroy children
  104.         for (let child of Array.from(node.childNodes)){ // copy to avoid concurrent mods
  105.             this.destroyNode(child);
  106.         }
  107.     }
  108.     
  109.     addInstanceNode(datastore, parentNode, concept, uuid){
  110.         let instanceNode = new TreeNode({
  111.             type: "ConceptInstanceNode",
  112.             lookupKey: uuid,
  113.             context: {concept, uuid, datastore}
  114.         });    
  115.         TreeGenerator.decorateNode(instanceNode);
  116.         parentNode.addNode(instanceNode);
  117.         return instanceNode;
  118.     }
  119. }
  122. EventSystem.registerEventCallback("Cauldron.TreeBrowserSpawned", ({detail: {root: rootNode}})=>{
  123.     let generator = new ConceptTreeGenerator(rootNode);
  124.     EventSystem.triggerEvent("Varv.ConceptTreeGeneratorSpawned", generator);
  125.     window.ConceptTreeGenerator.instances.push(generator);    
  126. });
  128. window.ConceptTreeGenerator = ConceptTreeGenerator;
  129. window.ConceptTreeGenerator.instances = [];