Refactor: Adjust Controller to new node implementation

CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/CityDoctorController.java

@@ -274,15 +274,15 @@ public class CityDoctorController {
     public void buildTrees() {
         resetFeatureChunks();
         buildBuildings(model);
-        buildVegetation(model.getVegetation());
-        buildTransportation(model.getTransportation());
-        buildTunnel(model.getTunnels());
+        buildVegetation(model);
+        buildTransportation(model);
+        buildTunnel(model);
         buildBridges(model);
         buildWater(model);
         buildLand(model);
         buildCityFurniture(model);
         buildOtherCityObjects(model);
-        buildTunnel(model.getTunnels());
+        buildTunnel(model);
     }
 
     private void resetFeatureChunks() {
@@ -302,7 +302,8 @@ public class CityDoctorController {
             return;
         }
         TreeView<Renderable> landView = mainWindow.getTerrainView();
-        TreeItem<Renderable> landRoot = new TreeItem<>(new AllTerrainNode(model.getLand()));
+        TreeItem<Renderable> landRoot = new TreeItem<>(new CityObjectGroupNode(model.getLand(), "Land",
+                Color.BROWN));
         landRoot.setExpanded(true);
         landView.setRoot(landRoot);
         buildLandFromList(model.getLand(), landView.getRoot());
@@ -314,50 +315,26 @@ public class CityDoctorController {
         for (int i = landChunk * MAX_FEATURES_PER_CHUNK; i < (landChunk + 1) * MAX_FEATURES_PER_CHUNK
                 && i < list.size(); i++) {
             CityObject land = list.get(i);
-            Renderable node;
-            if (land instanceof ReliefObject relief) {
-                node = new ReliefNode(relief);
-            } else if (land instanceof TinObject tin) {
-                node = new TinNode(tin);
-            } else {
-                node = new LandUseNode((LandObject) land);
-            }
+            CityObjectNode node = new CityObjectNode(land);
             TreeItem<Renderable> item = new TreeItem<>(node);
             item.setExpanded(true);
             root.getChildren().add(item);
             createGeometryNodes(land, item);
-            if (land instanceof ReliefObject relief) {
-                createTinNodes(relief, item);
-            }
-        }
-    }
-
-    private void createTinNodes(ReliefObject relief, TreeItem<Renderable> item) {
-        if (relief.getComponents().isEmpty()) {
-            return;
-        }
-        AllTinNode allTinText = new AllTinNode(relief.getComponents());
-        TreeItem<Renderable> allBpsTextItem = new TreeItem<>(allTinText);
-        item.getChildren().add(allBpsTextItem);
 
-        for (TinObject tin : relief.getComponents()) {
-            TinNode tinNode = new TinNode(tin);
-            TreeItem<Renderable> tinNodeItem = new TreeItem<>(tinNode);
-            tinNodeItem.setExpanded(true);
-            allBpsTextItem.getChildren().add(tinNodeItem);
-            createGeometryNodes(tin, tinNodeItem);
         }
     }
 
+
     private void buildCityFurniture(CityDoctorModel model) {
         if (model.getCityFurniture().isEmpty()) {
             return;
         }
         TreeView<Renderable> cityFurnitureView = mainWindow.getCityFurnitureView();
-        TreeItem<Renderable> cityFurnitureRoot = new TreeItem<>(new AllCityFurnitureNode(model.getCityFurniture()));
+        TreeItem<Renderable> cityFurnitureRoot = new TreeItem<>(new CityObjectGroupNode(model.getCityFurniture(),
+                "City Furniture", Color.BLUEVIOLET));
         cityFurnitureRoot.setExpanded(true);
         cityFurnitureView.setRoot(cityFurnitureRoot);
-        buildTreeFromList(model.getCityFurniture(), cityFurnitureView.getRoot(), cityFurnitureChunkNr);
+        buildCityFurnitureTreeFromList(model.getCityFurniture(), cityFurnitureView.getRoot());
         addMoreButtonIfNecessary(model.getCityFurniture(), cityFurnitureView, cityFurnitureRoot, cityFurnitureChunkNr);
     }
 
@@ -366,10 +343,11 @@ public class CityDoctorController {
             return;
         }
         TreeView<Renderable> otherObjectsView = mainWindow.getGenericCityObjectView();
-        TreeItem<Renderable> otherObjectsRoot = new TreeItem<>(new AllOtherObjectsNode(model.getGenericCityObjects()));
+        TreeItem<Renderable> otherObjectsRoot = new TreeItem<>(new CityObjectGroupNode(model.getGenericCityObjects(),
+                "Generic CityObjects", Color.DARKGRAY));
         otherObjectsRoot.setExpanded(true);
         otherObjectsView.setRoot(otherObjectsRoot);
-        buildTreeFromList(model.getGenericCityObjects(), otherObjectsView.getRoot(), genericCityObjectsChunkNr);
+        buildGenericCityObjectTreeFromList(model.getGenericCityObjects(), otherObjectsView.getRoot());
         addMoreButtonIfNecessary(model.getGenericCityObjects(), otherObjectsView, otherObjectsRoot, genericCityObjectsChunkNr);
     }
 
@@ -378,10 +356,11 @@ public class CityDoctorController {
             return;
         }
         TreeView<Renderable> waterView = mainWindow.getWaterView();
-        TreeItem<Renderable> waterRoot = new TreeItem<>(new AllWaterNode(model.getWater()));
+        TreeItem<Renderable> waterRoot = new TreeItem<>(new CityObjectGroupNode(model.getWater(), "Water",
+                Color.LIGHTSKYBLUE));
         waterRoot.setExpanded(true);
         waterView.setRoot(waterRoot);
-        buildTreeFromList(model.getWater(), waterView.getRoot(), waterChunkNr);
+        buildWaterTreeFromList(model.getWater(), waterRoot);
         addMoreButtonIfNecessary(model.getWater(), waterView, waterRoot, waterChunkNr);
     }
 
@@ -390,47 +369,51 @@ public class CityDoctorController {
             return;
         }
         TreeView<Renderable> bridgeView = mainWindow.getBridgeView();
-        TreeItem<Renderable> bridgeRoot = new TreeItem<>(new AllBridgesNode(model.getBridges()));
+        TreeItem<Renderable> bridgeRoot = new TreeItem<>(new CityObjectGroupNode(model.getBridges(), "Bridges",
+                Color.CORAL));
         bridgeRoot.setExpanded(true);
         bridgeView.setRoot(bridgeRoot);
         buildBridgeTreeFromList(model.getBridges(), bridgeView.getRoot());
         addMoreButtonIfNecessary(model.getBridges(), bridgeView, bridgeRoot, bridgeChunkNr);
     }
 
-    private void buildTransportation(List<TransportationObject> trans) {
-        if (trans.isEmpty()) {
+    private void buildTransportation(CityDoctorModel model) {
+        if (model.getTransportation().isEmpty()) {
             return;
         }
         TreeView<Renderable> transView = mainWindow.getTransportationView();
-        TreeItem<Renderable> transRoot = new TreeItem<>(new AllTransportationNode(model.getTransportation()));
+        TreeItem<Renderable> transRoot = new TreeItem<>(new CityObjectGroupNode(model.getTransportation(),
+                "Transportation", Color.YELLOW));
         transRoot.setExpanded(true);
         transView.setRoot(transRoot);
-        buildTransportationTreeFromList(trans, transView.getRoot());
-        addMoreButtonIfNecessary(trans, transView, transRoot, transportationChunkNr);
+        buildTransportationTreeFromList(model.getTransportation(), transView.getRoot());
+        addMoreButtonIfNecessary(model.getTransportation(), transView, transRoot, transportationChunkNr);
     }
 
-    private void buildTunnel(List<Tunnel> tunnels) {
-        if (tunnels.isEmpty()) {
+    private void buildTunnel(CityDoctorModel model) {
+        if (model.getTunnels().isEmpty()) {
             return;
         }
-        TreeView<Renderable> transView = mainWindow.getTunnelView();
-        TreeItem<Renderable> transRoot = new TreeItem<>(new AllTunnelsNode(model.getTunnels()));
-        transRoot.setExpanded(true);
-        transView.setRoot(transRoot);
-        buildTreeFromList(tunnels, transView.getRoot(), tunnelChunkNr);
-        addMoreButtonIfNecessary(tunnels, transView, transRoot, tunnelChunkNr);
+        TreeView<Renderable> tunnelView = mainWindow.getTunnelView();
+        TreeItem<Renderable> tunnelRoot = new TreeItem<>(new CityObjectGroupNode(model.getTunnels(), "Tunnel",
+                Color.SLATEGRAY));
+        tunnelRoot.setExpanded(true);
+        tunnelView.setRoot(tunnelRoot);
+        buildTunnelTreeFromList(model.getTunnels(), tunnelRoot);
+        addMoreButtonIfNecessary(model.getTunnels(), tunnelView, tunnelRoot, tunnelChunkNr);
     }
 
-    private void buildVegetation(List<Vegetation> veg) {
-        if (veg.isEmpty()) {
+    private void buildVegetation(CityDoctorModel model) {
+        if (model.getVegetation().isEmpty()) {
             return;
         }
         TreeView<Renderable> vegetationsView = mainWindow.getVegetationView();
-        TreeItem<Renderable> vegRoot = new TreeItem<>(new AllVegetationNode(model.getVegetation()));
+        TreeItem<Renderable> vegRoot = new TreeItem<>(new CityObjectGroupNode(model.getVegetation(),
+                "Vegetation", Color.LIGHTGREEN));
         vegRoot.setExpanded(true);
         vegetationsView.setRoot(vegRoot);
-        buildTreeFromListWithProducer(veg, vegetationsView.getRoot(), vegetationChunkNr, VegetationNode::new);
-        addMoreButtonIfNecessary(veg, vegetationsView, vegRoot, vegetationChunkNr);
+        buildVegetationTreeFromList(model.getVegetation(), vegRoot);
+        addMoreButtonIfNecessary(model.getVegetation(), vegetationsView, vegRoot, vegetationChunkNr);
     }
 
     private void addMoreButtonIfNecessary(List<? extends CityObject> list, TreeView<Renderable> view,
@@ -466,7 +449,8 @@ public class CityDoctorController {
             return;
         }
         TreeView<Renderable> buildingsView = mainWindow.getBuildingsView();
-        TreeItem<Renderable> root = new TreeItem<>(new AllBuildingsNode(model.getBuildings()));
+        TreeItem<Renderable> root = new TreeItem<>(new CityObjectGroupNode(model.getBuildings(), "Buildings",
+                Color.WHITE));
         root.setExpanded(true);
         buildingsView.setRoot(root);
         buildBuildingTreeFromList(model.getBuildings(), root);
@@ -1554,7 +1538,7 @@ public class CityDoctorController {
                 updateTree(mainWindow.getBuildingsView().getRoot());
                 break;
             case VEGETATION:
-                buildVegetation(model.getVegetation());
+                buildVegetation(model);
                 updateTree(mainWindow.getVegetationView().getRoot());
                 break;
             case BRIDGE:
@@ -1566,15 +1550,14 @@ public class CityDoctorController {
                 updateTree(mainWindow.getTerrainView().getRoot());
                 break;
             case TRANSPORTATION:
-                buildTransportation(model.getTransportation());
+                buildTransportation(model);
                 updateTree(mainWindow.getTransportationView().getRoot());
                 break;
             case TUNNEL:
-                buildTunnel(model.getTunnels());
+                buildTunnel(model);
                 updateTree(mainWindow.getTunnelView().getRoot());
                 break;
             case WATER:
-
                 buildWater(model);
                 updateTree(mainWindow.getWaterView().getRoot());
                 break;
@@ -1640,12 +1623,13 @@ public class CityDoctorController {
     public void delete(TreeItem<Renderable> selectedItem) {
         if (model == null) {
             return;
-        }
+        }/* TODO: Rework this properly via Renderable implementation
         Renderable render = selectedItem.getValue();
         if (render instanceof BuildingNode node) {
             model.getBuildings().remove(node.getBuilding());
             mainWindow.getBuildingsView().getRoot().getChildren().remove(selectedItem);
         }
+        */
 
     }