From efaac36f5dd23375d8373969c17c4a893efa53aa Mon Sep 17 00:00:00 2001
From: Amanda Ghassaei <amandaghassaei@gmail.com>
Date: Wed, 28 Oct 2015 17:53:44 -0400
Subject: [PATCH] working

---
 js/materials/DMACompositeMaterial.js |  90 +++++++-
 js/materials/DMAMaterials.js         | 321 ++++++++++++---------------
 2 files changed, 224 insertions(+), 187 deletions(-)

diff --git a/js/materials/DMACompositeMaterial.js b/js/materials/DMACompositeMaterial.js
index 6a195953..d2b7657e 100644
--- a/js/materials/DMACompositeMaterial.js
+++ b/js/materials/DMACompositeMaterial.js
@@ -35,15 +35,82 @@ define(['material'], function(DMAMaterial){
 
         var edited = false;
         if (data.sparseCells){
-            edited |= !(_.isEqual(data.sparseCells, this.sparseCells));
+            edited |= !(_.isEqual(data.sparseCells, this.sparseCells));//must be comparing json
             this.sparseCells = data.sparseCells;
-            this.cells = this.parseSparseCells(this.sparseCells);
+        }
+
+        if (edited){
+            console.log("composite material edited");
+            var self = this;
+            require(['materials'], function(materials){
+                var compositeChildren = [];
+                var elementaryChildren = [];
+
+                var firstGen = self.getFirstGenChildMaterials(materials);
+                elementaryChildren = _.clone(firstGen.elementaryCells);
+                compositeChildren = _.clone(firstGen.compositeCells);
+
+                _.each(firstGen.compositeCells, function(compositeID){
+                    var material = materials.getMaterialForId(compositeID);
+                    compositeChildren.concat(material.getCompositeChildren());
+                    elementaryChildren.concat(material.getElementaryChildren());
+                });
+                compositeChildren = _.uniq(compositeChildren);//remove duplicates
+                elementaryChildren = _.uniq(elementaryChildren);
+
+                self.compositeChildren = compositeChildren;
+                self.elementaryChildren = elementaryChildren;
+
+                //getParentComposites
+                if (!_.isEqual(self.getCompositeChildren(), compositeChildren)){
+
+                }
+                if (!_.isEqual(self.getElementaryChildren(), elementaryChildren)){
+                    self.properties = self.getPropertiesFromElements(elementaryChildren)
+                }
+            });
         }
         return edited;
     };
 
-    DMACompositeMaterial.prototype.parseSparseCells = function(sparseCells){
-        return [[[null]]];
+    DMACompositeMaterial.prototype.getFirstGenChildMaterials = function(materials){
+        var compositeChildrenFirstGen = [];
+        var elementaryChildrenFirstGen = [];
+        this.loopCells(function(cell, x, y, z){
+            var materialID = cell.materialID;
+            var material = materials.getMaterialForId(materialID);
+            if (material.isComposite()){
+                if (compositeChildrenFirstGen.indexOf(materialID) == -1) compositeChildren.push(materialID);
+            } else {
+                if (elementaryChildrenFirstGen.indexOf(materialID) == -1) elementaryChildren.push(materialID);
+            }
+        });
+        return {compositeCells:compositeChildrenFirstGen, elementaryCells:elementaryChildrenFirstGen};
+    };
+
+    DMACompositeMaterial.prototype.recalcChildren = function(){
+
+    };
+
+    DMACompositeMaterial.prototype.getPropertiesFromElements = function(elementaryChildren){
+        var properties = [];
+        return properties;
+    };
+
+    DMACompositeMaterial.prototype._setCompositeChildren = function(compositeChildren){
+        this.compositeChildren = compositeChildren;
+    };
+
+    DMACompositeMaterial.prototype.getCompositeChildren = function(){
+        return this.compositeChildren;
+    };
+
+    DMACompositeMaterial.prototype._setElementaryChildren = function(elementaryChildren){
+
+    };
+
+    DMACompositeMaterial.prototype.getElementaryChildren = function(){
+        return this.elementaryChildren;
     };
 
     DMACompositeMaterial.prototype.getDimensions = function(){
@@ -58,12 +125,19 @@ define(['material'], function(DMAMaterial){
         return this.compositeChildren.indexOf(id)>-1;
     };
 
-    DMACompositeMaterial.prototype.getCells = function(){
-        return this.cells;
+    DMACompositeMaterial.prototype.getSparseCells = function(){
+        return this.sparseCells;//json description
     };
 
-    DMACompositeMaterial.prototype.getSparseCells = function(){
-        return this.sparseCells;
+    DMACompositeMaterial.prototype.loopCells = function(callback){
+        var cells = this.sparseCells;
+        for (var x=0;x<cells.length;x++){
+            for (var y=0;y<cells[0].length;y++){
+                for (var z=0;z<cells[0][0].length;z++){
+                    if (cells[x][y][z]) callback(cells[x][y][z], x, y, z);
+                }
+            }
+        }
     };
 
     DMACompositeMaterial.prototype.toJSON = function(){
diff --git a/js/materials/DMAMaterials.js b/js/materials/DMAMaterials.js
index f0dfc8ad..4e6b7148 100644
--- a/js/materials/DMAMaterials.js
+++ b/js/materials/DMAMaterials.js
@@ -3,20 +3,8 @@
  */
 
 //everything is a top level material with a threeMaterial object
-define(['underscore', 'three', 'appState', 'lattice', 'materialsPlist', 'threeModel', 'material', 'compositeMaterial', 'console'],
-    function(_, THREE, appState, lattice, materialsPlist, three, DMAMaterial, DMACompositeMaterial, myConsole){
-
-
-    var materialsList = {};
-    var compositeMaterialsList = {};
-
-    newMaterial({
-        id: "deleteMaterial",
-        name: "Delete",
-        color: "#ff0000",
-        altColor: "#ff0000",
-        noDelete: true
-    }, {silent:true} );
+define(['underscore', 'backbone', 'three', 'appState', 'lattice', 'materialsPlist', 'threeModel', 'material', 'compositeMaterial', 'console'],
+    function(_, Backbone, THREE, appState, lattice, materialsPlist, three, DMAMaterial, DMACompositeMaterial, myConsole){
 
     var compositeID = 1;
     var materialID = 1;
@@ -29,162 +17,188 @@ define(['underscore', 'three', 'appState', 'lattice', 'materialsPlist', 'threeMo
         return "material" + materialID++;
     }
 
-    var listener = {};
-    _.extend(listener, Backbone.Events);
+    return new Backbone.Model.extend({
+
+        initialize: function(){
+            this.materialsList = {};
+            this.compositeMaterialsList = {};
+            this.newMaterial({
+                id: "deleteMaterial",
+                name: "Delete",
+                color: "#ff0000",
+                altColor: "#ff0000",
+                noDelete: true
+            }, {silent:true});
+
+            this.listenTo(appState, "change:realisticColorScheme", this.changeColorScheme);
+            this.listenTo(appState, "change:materialClass", this.loadMaterialClass);
+            this.listenTo(appState, "change:materialType", this.setMaterialDefaults);
+
+            this.loadMaterialClass();
+        },
+
+        loadMaterialClass:function(){
+            var materialClass = appState.get("materialClass");
+            var self = this;
+            _.each(materialsPlist.allMaterials[materialClass], function(json, id){
+                if (self.materialsList[id]) return;
+                json.noDelete = true;
+                json.id = id;
+                self.materialsList[id] = self.newMaterial(json, {silent:true});
+            });
+            this.setToDefaultMaterial();
+        },
+
+        setToDefaultMaterial: function(){
+            var materialClass = appState.get("materialClass");
+            var id = _.keys(materialsPlist.allMaterials[materialClass])[0];
+            if (!this.getMaterialForId(id)) {
+                this.loadMaterialClass();
+                return;
+            }
+            appState.set("materialType", id);
+        },
 
-    listener.listenTo(appState, "change:realisticColorScheme", changeColorScheme);
-    listener.listenTo(appState, "change:materialClass", function(){setToDefaultMaterial()});//pass no params
-//    listener.listenTo(lattice, "change:connectionType cellType", function(){materialClassChanged()});
-    listener.listenTo(appState, "change:materialType", setMaterialDefaults);
 
-    setToDefaultMaterial();
 
 
+        //create/delete materials
 
-    function newMaterial(data, options){
-        options = options || {};
-        data = data || {};
+        newMaterial: function(json, options){
+            options = options || {};
+            json = json || {};
 
-        if (data.sparseCells) {
-            console.warn("you are trying to init a composite material, use newCompositeMaterial()");
-            return newCompositeMaterial(data, options);
-        }
+            if (json.sparseCells) {
+                console.warn("you are trying to init a composite material, use newCompositeMaterial()");
+                return this.newCompositeMaterial(json, options);
+            }
 
-        var id = data.id || getNextMaterialID();
-        var material = new DMAMaterial(data, id);
+            var id = json.id || getNextMaterialID();
+            var material = new DMAMaterial(json, id);
 
-        if (options.noAdd) return material;//in the new material menu, you may init a material before saving changes
+            if (options.noAdd) return material;//in the new material menu, you may init a material before saving changes
 
-        materialsList[id] = material;
-        if (!options.silent) myConsole.write("materials.newMaterial(" + JSON.stringify(material.toJSON()) + "}");
-        return material;
-    }
+            this.materialsList[id] = material;
+            if (!options.silent) myConsole.write("materials.newMaterial(" + JSON.stringify(material.toJSON()) + "}");
+            return material;
+        },
 
-    function newCompositeMaterial(data, options){
-        options = options || {};
-        data = data || {};
+        newCompositeMaterial: function(json, options){
+            options = options || {};
+            json = data || {};
 
-        var id = data.id || getNextMaterialID();
-        var material = new DMAMaterial(data, id);
+            var id = json.id || getNextMaterialID();
+            var material = new DMAMaterial(json, id);
 
-        if (options.noAdd) return material;//in the new material menu, you may init a material before saving changes
+            if (options.noAdd) return material;//in the new material menu, you may init a material before saving changes
 
-        compositeMaterialsList[id] = material;
-        if (!options.silent) myConsole.write("materials.newCompositeMaterial(" + JSON.stringify(material.toJSON()) + "}");
-        return material;
-    }
+            this.compositeMaterialsList[id] = material;
+            if (!options.silent) myConsole.write("materials.newCompositeMaterial(" + JSON.stringify(material.toJSON()) + "}");
+            return material;
+        },
 
-    function deleteMaterialById(id){
-        var material = getMaterialForId(id);
-        if (!material){
-            myConsole.warn("this material was never saved, deleteMaterial operation cancelled");
-            return false;
-        }
-        return deleteMaterial(material);
-    }
+        deleteMaterialById: function(id){
+            var material = getMaterialForId(id);
+            if (!material){
+                myConsole.warn("this material was never saved, deleteMaterial operation cancelled");
+                return false;
+            }
+            return this.deleteMaterial(material);
+        },
 
-    function deleteMaterial(material){
-        if (!material){
-            myConsole.warn("no material provided, deleteMaterial operation cancelled");
-            return false;
-        }
-        if (!material.canDelete()) {
-            myConsole.warn("noDelete flag on this material type, deleteMaterial operation cancelled");
-            return false;
-        }
-        myConsole.write("materials.deleteMaterialById(" + id + "}");
-        myConsole.log(JSON.stringify(material.toJSON()));
-        if (material.isComposite()){
-            compositeMaterialsList[id] = null;
-            delete compositeMaterialsList[id];//todo check if being used first
-        } else {
-            materialsList[id] = null;
-            delete materialsList[id];//todo check if being used first (instances)
-        }
-        material.destroy();
+        deleteMaterial: function(material){
+            if (!material){
+                myConsole.warn("no material provided, deleteMaterial operation cancelled");
+                return false;
+            }
+            if (!material.canDelete()) {
+                myConsole.warn("noDelete flag on this material type, deleteMaterial operation cancelled");
+                return false;
+            }
+            myConsole.write("materials.deleteMaterialById(" + id + "}");
+            myConsole.log(JSON.stringify(material.toJSON()));
+            if (material.isComposite()){
+                this.compositeMaterialsList[id] = null;
+                delete this.compositeMaterialsList[id];//todo check if being used first
+            } else {
+                this.materialsList[id] = null;
+                delete this.materialsList[id];//todo check if being used first (instances)
+            }
+            material.destroy();
 
-        var deleted = true;
-        if (deleted) setToDefaultMaterial();
-        return deleted;
-    }
+            var deleted = true;
+            if (deleted) this.setToDefaultMaterial();
+            return deleted;
+        },
 
-    function getMaterialForId(id){
-        return materialsList[id] || compositeMaterialsList[id];
-    }
+        getMaterialForId: function(id){
+            return this.materialsList[id] || this.compositeMaterialsList[id];
+        },
 
-    function setMaterial(id, data){
 
-        var material = getMaterialForId(id);
-        if (material.isComposite()){
-            console.warn("use setCompositeMaterial()");
-            return setCompositeMaterial(id, data);
-        }
-        if (!material) return newMaterial(data);
 
-        var edited = material.set(data);
-        if (edited) myConsole.write("materials.setMaterial(" + id + ", " + JSON.stringify(material.toJSON()) + "}");
 
-        if (edited){
-            //update properties of all composites containing this element
-            var allChangedMaterialsList = getAllParentComposites(id);
-        }
-    }
+        //edit material
 
-    function setCompositeMaterial(id, data){
+        setMaterial: function(id, data){
 
-        var material = getMaterialForId(id);
-        if (!material) return newCompositeMaterial(data);
+            var material = this.getMaterialForId(id);
+            if (material.isComposite()){
+                console.warn("use setCompositeMaterial()");
+                return this.setCompositeMaterial(id, data);
+            }
+            if (!material) return this.newMaterial(data);
 
-        var edited = material.setMetaData(data);
-        var materialDefinitionEdited = material.setData(data);
-        edited |= materialDefinitionEdited;
+            var edited = material.set(data);
+            if (edited) myConsole.write("materials.setMaterial(" + id + ", " + JSON.stringify(material.toJSON()) + "}");
+            return material;
+        },
 
-        if (edited) myConsole.write("materials.setCompositeMaterial(" + id + ", " + JSON.stringify(material.toJSON()) + "}");
+        setCompositeMaterial: function(id, data){
+            var material = this.getMaterialForId(id);
+            if (!material) return this.newCompositeMaterial(data);
 
-        if (materialDefinitionEdited){
+            var edited = material.set(data);
+            if (edited) myConsole.write("materials.setCompositeMaterial(" + id + ", " + JSON.stringify(material.toJSON()) + "}");
+            return material;
+        },
 
-            //update composite children
-            //update elem children
-            //update properties
+        updateParentProperties: function(parents){
+            //update properties of all composites containing this element
+            var allChangedMaterialsList = getAllParentComposites(id);
+        },
 
+        upDataParentComposition: function(parents){
             var allChangedMaterialsList = getAllParentComposites(id);
             allChangedMaterialsList.push(id);
 
             _.each(allChangedMaterialsList, function(key){
-                materialsList[key].compositeChildren = getChildCellTypes(materialsList[key].sparseCells, false);
-                materialsList[key].elementaryChildren = getChildCellTypes(materialsList[key].sparseCells, true);
+//                materialsList[key].compositeChildren = getChildCellTypes(materialsList[key].sparseCells, false);
+//                materialsList[key].elementaryChildren = getChildCellTypes(materialsList[key].sparseCells, true);
             });
 
             lattice.reinitAllCellsOfTypes(allChangedMaterialsList);
-        }
-    }
+        },
 
+        getDeleteMaterial: function(){
+            return this.getMaterialForId("deleteMaterial").getThreeMaterial();
+        },
 
+        isComposite: function(id){
+            var material = this.getMaterialForId(id);
+            if (!material) {
+                console.warn("no material found with id " + id);
+                return false;
+            }
+            return material.isComposite();
+        }
 
 
+    });
 
 
 
 
-
-    function getDeleteMaterial(){
-        return materialsList.deleteMaterial.threeMaterial;
-    }
-
-
-
-
-
-
-    function isComposite(id){
-        var material = this.getMaterialForId(id);
-        if (!material) {
-            console.warn("no material found with id " + id);
-            return false;
-        }
-        return material.isComposite();
-    }
-
     function getCompositeKeys(){
         return _.keys(compositeMaterialsList);
     }
@@ -236,46 +250,15 @@ define(['underscore', 'three', 'appState', 'lattice', 'materialsPlist', 'threeMo
         return properties;
     }
 
-    function loopCells(cells, callback){
-        for (var x=0;x<cells.length;x++){
-            for (var y=0;y<cells[0].length;y++){
-                for (var z=0;z<cells[0][0].length;z++){
-                    callback(cells[x][y][z], x, y, z);
-                }
-            }
-        }
-    }
-
-
-
-
-
 
 
 
 
+    //events
 
 
-    //events
 
-    function setToDefaultMaterial(triggerEvent){
-        var materialClass = appState.get("materialClass");
-        var newDefaultType = _.keys(materialsPlist.allMaterials[materialClass])[0];
-        if (!materialsList[newDefaultType]) _.extend(materialsList, parseClassFromDefinitions(materialsPlist.allMaterials[materialClass]));
-        if (!materialsList[newDefaultType]) console.warn("material type " + newDefaultType + "  not in definition for " + materialClass);
-        if (triggerEvent === undefined) triggerEvent = false;
-        appState.set("materialType", newDefaultType, {silent:!triggerEvent});
-    }
 
-    function parseClassFromDefinitions(definitions){
-        var newMaterials = {};
-        _.each(definitions, function(data, key){
-            data.noDelete = true;
-            data.id = key;
-            newMaterial(data, {silent:true});
-        });
-        return newMaterials;
-    }
 
     function changeColorScheme(){
         var state = appState.get("realisticColorScheme");
@@ -294,24 +277,4 @@ define(['underscore', 'three', 'appState', 'lattice', 'materialsPlist', 'threeMo
             appState.set("superCellRange", new THREE.Vector3(appState.get("gikLength"), 1, 1));
         }
     }
-
-
-    return {
-        list: materialsList,
-        newMaterial: newMaterial,
-        newCompositeMaterial: newCompositeMaterial,
-        setMaterial: setMaterial,
-        deleteMaterialById: deleteMaterialById,
-        deleteMaterial: deleteMaterial,
-        getMaterialForId: getMaterialForId,
-        isComposite: isComposite,
-
-
-        getCompositeKeys: getCompositeKeys,
-        getVaildAvailableCompositeKeys: getVaildAvailableCompositeKeys,
-        getChildCellTypes:getChildCellTypes,
-        setToDefaultMaterial: setToDefaultMaterial,
-        getDeleteMaterial: getDeleteMaterial,
-        getNextCompositeID: getNextCompositeID
-    };
 });
\ No newline at end of file
-- 
GitLab