Skip to content
GitLab
Commit ecd6316a authored by Riegel's avatar Riegel
Browse files

Refactor: Simplify Feature-TreeList construction

parent 38c8db7d
Hide whitespace changes
Inline Side-by-side
CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/CityDoctorController.java
View file @ ecd6316a
...@@ -24,6 +24,7 @@ import javafx.scene.control.ButtonType; ...@@ -24,6 +24,7 @@ import javafx.scene.control.ButtonType;
import javafx.scene.control.Dialog; import javafx.scene.control.Dialog;
import javafx.scene.control.TreeItem; import javafx.scene.control.TreeItem;
import javafx.scene.control.TreeView; import javafx.scene.control.TreeView;
import javafx.scene.paint.Color;
import javafx.stage.FileChooser; import javafx.stage.FileChooser;
import javafx.stage.FileChooser.ExtensionFilter; import javafx.stage.FileChooser.ExtensionFilter;
import org.apache.commons.io.FileUtils; import org.apache.commons.io.FileUtils;
...@@ -462,9 +463,10 @@ public class CityDoctorController { ...@@ -462,9 +463,10 @@ public class CityDoctorController {
TreeView<Renderable> buildingsView = mainWindow.getBuildingsView(); TreeView<Renderable> buildingsView = mainWindow.getBuildingsView();
TreeItem<Renderable> root = new TreeItem<>(new AllBuildingsNode(model.getBuildings())); TreeItem<Renderable> root = new TreeItem<>(new AllBuildingsNode(model.getBuildings()));
root.setExpanded(true); root.setExpanded(true);
buildingsView.setRoot(root);
buildBuildingTreeFromList(model.getBuildings(), root); buildBuildingTreeFromList(model.getBuildings(), root);
addMoreButtonToBuildingsIfNecessary(model.getBuildings(), buildingsView, root, buildingChunkNr); addMoreButtonToBuildingsIfNecessary(model.getBuildings(), buildingsView, root, buildingChunkNr);
buildingsView.setRoot(root);
} }
private void addMoreButtonToBuildingsIfNecessary(List<Building> list, TreeView<Renderable> view, private void addMoreButtonToBuildingsIfNecessary(List<Building> list, TreeView<Renderable> view,
...@@ -557,17 +559,46 @@ public class CityDoctorController { ...@@ -557,17 +559,46 @@ public class CityDoctorController {
mainWindow.getVertexView().getRoot().getChildren().clear(); mainWindow.getVertexView().getRoot().getChildren().clear();
} }
private TreeItem<Renderable> buildTopLevelCityObjectNode(CityObject co, TreeItem<Renderable> root) {
return buildTopLevelCityObjectNode(co, root, Collections.emptyList());
}
private TreeItem<Renderable> buildTopLevelCityObjectNode(CityObject co, TreeItem<Renderable> root,
List<BoundarySurface> surfaces) {
TopLevelCityObjectNode node = new TopLevelCityObjectNode(co);
TreeItem<Renderable> nodeItem = new TreeItem<>(node);
nodeItem.setExpanded(true);
root.getChildren().add(nodeItem);
createGeometryNodes(co, nodeItem);
if (!surfaces.isEmpty()) {
createBoundarySurfaceNodes(surfaces, nodeItem);
}
return nodeItem;
}
private TreeItem<Renderable> buildCityObjectNode(CityObject co, TreeItem<Renderable> root) {
return buildCityObjectNode(co, root, Collections.emptyList());
}
private TreeItem<Renderable> buildCityObjectNode(CityObject co, TreeItem<Renderable> root, List<BoundarySurface> surfaces) {
CityObjectNode node = new CityObjectNode(co);
TreeItem<Renderable> nodeItem = new TreeItem<>(node);
nodeItem.setExpanded(false);
root.getChildren().add(nodeItem);
createGeometryNodes(co, nodeItem);
if (!surfaces.isEmpty()) {
createBoundarySurfaceNodes(surfaces, nodeItem);
}
return nodeItem;
}
private void buildBuildingTreeFromList(List<Building> list, TreeItem<Renderable> root) { private void buildBuildingTreeFromList(List<Building> list, TreeItem<Renderable> root) {
int buildingChunk = buildingChunkNr.get(); int buildingChunk = buildingChunkNr.get();
for (int i = buildingChunk * MAX_FEATURES_PER_CHUNK; i < (buildingChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = buildingChunk * MAX_FEATURES_PER_CHUNK; i < (buildingChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
Building b = list.get(i); Building b = list.get(i);
BuildingNode node = new BuildingNode(b); TreeItem<Renderable> item = buildTopLevelCityObjectNode(b, root, b.getBoundarySurfaces());
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(b, item);
createBoundarySurfaceNodes(b.getBoundarySurfaces(), item);
createBuildingInstallationNodes(b, item); createBuildingInstallationNodes(b, item);
createBuildingRoomNodes(b, item); createBuildingRoomNodes(b, item);
createBuildingFurnitureNodes(b, item); createBuildingFurnitureNodes(b, item);
...@@ -582,12 +613,8 @@ public class CityDoctorController { ...@@ -582,12 +613,8 @@ public class CityDoctorController {
for (int i = bridgeChunk * MAX_FEATURES_PER_CHUNK; i < (bridgeChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = bridgeChunk * MAX_FEATURES_PER_CHUNK; i < (bridgeChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
BridgeObject bridge = list.get(i); BridgeObject bridge = list.get(i);
BridgeNode node = new BridgeNode(bridge); TreeItem<Renderable> item = buildTopLevelCityObjectNode(bridge, root, bridge.getBoundarySurfaces());
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(bridge, item);
createBoundarySurfaceNodes(bridge.getBoundarySurfaces(), item);
createBridgeRoomNodes(bridge, item); createBridgeRoomNodes(bridge, item);
createBridgeInstallationNodes(bridge, item); createBridgeInstallationNodes(bridge, item);
createBridgeFurnitureNodes(bridge, item); createBridgeFurnitureNodes(bridge, item);
...@@ -602,11 +629,7 @@ public class CityDoctorController { ...@@ -602,11 +629,7 @@ public class CityDoctorController {
for (int i = transportChunk * MAX_FEATURES_PER_CHUNK; i < (transportChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = transportChunk * MAX_FEATURES_PER_CHUNK; i < (transportChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
TransportationObject t = list.get(i); TransportationObject t = list.get(i);
TransportationObjectNode node = new TransportationObjectNode(t); TreeItem<Renderable> item = buildTopLevelCityObjectNode(t, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(t, item);
createTransportSectionNodes(t, item); createTransportSectionNodes(t, item);
createTrafficSpacesNodes(t, item); createTrafficSpacesNodes(t, item);
} }
...@@ -617,11 +640,7 @@ public class CityDoctorController { ...@@ -617,11 +640,7 @@ public class CityDoctorController {
for (int i = vegetationChunk * MAX_FEATURES_PER_CHUNK; i < (vegetationChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = vegetationChunk * MAX_FEATURES_PER_CHUNK; i < (vegetationChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
Vegetation v = list.get(i); Vegetation v = list.get(i);
VegetationNode node = new VegetationNode(v); buildTopLevelCityObjectNode(v, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(v, item);
} }
} }
...@@ -630,11 +649,7 @@ public class CityDoctorController { ...@@ -630,11 +649,7 @@ public class CityDoctorController {
for (int i = waterChunk * MAX_FEATURES_PER_CHUNK; i < (waterChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = waterChunk * MAX_FEATURES_PER_CHUNK; i < (waterChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
WaterObject w = list.get(i); WaterObject w = list.get(i);
CityObjectNode node = new CityObjectNode(w); buildTopLevelCityObjectNode(w, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(w, item);
} }
} }
...@@ -643,11 +658,7 @@ public class CityDoctorController { ...@@ -643,11 +658,7 @@ public class CityDoctorController {
for (int i = cityFurnChunk * MAX_FEATURES_PER_CHUNK; i < (cityFurnChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = cityFurnChunk * MAX_FEATURES_PER_CHUNK; i < (cityFurnChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
CityFurniture cf = list.get(i); CityFurniture cf = list.get(i);
CityObjectNode node = new CityObjectNode(cf); buildTopLevelCityObjectNode(cf, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(cf, item);
} }
} }
...@@ -656,44 +667,32 @@ public class CityDoctorController { ...@@ -656,44 +667,32 @@ public class CityDoctorController {
for (int i = genericObjectChunk * MAX_FEATURES_PER_CHUNK; i < (genericObjectChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = genericObjectChunk * MAX_FEATURES_PER_CHUNK; i < (genericObjectChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
GenericCityObject goc = list.get(i); GenericCityObject goc = list.get(i);
CityObjectNode node = new CityObjectNode(goc); buildTopLevelCityObjectNode(goc, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(goc, item);
} }
} }
private void createTransportSectionNodes(TransportationObject t, TreeItem<Renderable> root) { private void createTransportSectionNodes(TransportationObject t, TreeItem<Renderable> root) {
if (t instanceof TopLevelTransportFeature top) { if (t instanceof TopLevelTransportFeature top) {
if (!top.getSections().isEmpty()) { if (!top.getSections().isEmpty()) {
AllTransportSectionNode allSectionsNode = new AllTransportSectionNode(top.getSections(), CityObjectGroupNode sectionsGroupNode = new CityObjectGroupNode(top.getSections(),
TransportSection.SectionType.SECTION); "Sections", Color.YELLOW);
TreeItem<Renderable> allSectionsNodeTextItem = new TreeItem<>(allSectionsNode); TreeItem<Renderable> sectionsGroupItem = new TreeItem<>(sectionsGroupNode);
root.getChildren().add(allSectionsNodeTextItem); root.getChildren().add(sectionsGroupItem);
for (TransportSection ts : top.getSections()) { for (TransportSection ts : top.getSections()) {
TransportationObjectNode tsNode = new TransportationObjectNode(ts); TreeItem<Renderable> tsNodeItem = buildCityObjectNode(ts, sectionsGroupItem);
TreeItem<Renderable> tsNodeItem = new TreeItem<>(tsNode);
tsNodeItem.setExpanded(false);
allSectionsNodeTextItem.getChildren().add(tsNodeItem);
createGeometryNodes(ts, tsNodeItem);
createTrafficSpacesNodes(ts, tsNodeItem); createTrafficSpacesNodes(ts, tsNodeItem);
} }
} }
if (!top.getIntersections().isEmpty()) { if (!top.getIntersections().isEmpty()) {
AllTransportSectionNode allIntersectionsNode = new AllTransportSectionNode(top.getIntersections(), CityObjectGroupNode intersectionsGroupNode = new CityObjectGroupNode(top.getSections(),
TransportSection.SectionType.INTERSECTION); "Intersections", Color.YELLOW);
TreeItem<Renderable> allIntersectionsNodeTextItem = new TreeItem<>(allIntersectionsNode); TreeItem<Renderable> intersectionsGroupItem = new TreeItem<>(intersectionsGroupNode);
root.getChildren().add(allIntersectionsNodeTextItem); root.getChildren().add(intersectionsGroupItem);
for (TransportSection ts : top.getIntersections()) { for (TransportSection ts : top.getIntersections()) {
TransportationObjectNode tsNode = new TransportationObjectNode(ts); TreeItem<Renderable> tsNodeItem = buildCityObjectNode(ts, intersectionsGroupItem);
TreeItem<Renderable> tsNodeItem = new TreeItem<>(tsNode);
tsNodeItem.setExpanded(false);
allIntersectionsNodeTextItem.getChildren().add(tsNodeItem);
createGeometryNodes(ts, tsNodeItem);
createTrafficSpacesNodes(ts, tsNodeItem); createTrafficSpacesNodes(ts, tsNodeItem);
} }
} }
...@@ -703,34 +702,26 @@ public class CityDoctorController { ...@@ -703,34 +702,26 @@ public class CityDoctorController {
private void createTrafficSpacesNodes(TransportationObject t, TreeItem<Renderable> root) { private void createTrafficSpacesNodes(TransportationObject t, TreeItem<Renderable> root) {
if (t instanceof TransportationSpace space) { if (t instanceof TransportationSpace space) {
if (!space.getTrafficSpaces().isEmpty()) { if (!space.getTrafficSpaces().isEmpty()) {
AllTrafficSpacesNode allTSNode = new AllTrafficSpacesNode(space.getTrafficSpaces(), CityObjectGroupNode trafficSpacesGroupNode = new CityObjectGroupNode(space.getTrafficSpaces(),
TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE); "TRAFFIC_SPACE", Color.YELLOW);
TreeItem<Renderable> allTSNodeTextItem = new TreeItem<>(allTSNode); TreeItem<Renderable> trafficSpacesGroupItem = new TreeItem<>(trafficSpacesGroupNode);
root.getChildren().add(allTSNodeTextItem); root.getChildren().add(trafficSpacesGroupItem);
allTSNodeTextItem.setExpanded(true); trafficSpacesGroupItem.setExpanded(true);
for (TrafficSpaceObject tso : space.getTrafficSpaces()) { for (TrafficSpaceObject tso : space.getTrafficSpaces()) {
TransportationObjectNode tsoNode = new TransportationObjectNode(tso); TreeItem<Renderable> tsoNodeItem = buildCityObjectNode(tso, trafficSpacesGroupItem);
TreeItem<Renderable> tsoNodeItem = new TreeItem<>(tsoNode);
tsoNodeItem.setExpanded(false);
allTSNodeTextItem.getChildren().add(tsoNodeItem);
createGeometryNodes(tso, tsoNodeItem);
createTrafficAreaNodes(tso, tsoNodeItem, TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA); createTrafficAreaNodes(tso, tsoNodeItem, TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
} }
} }
if (!space.getAuxTrafficSpaces().isEmpty()) { if (!space.getAuxTrafficSpaces().isEmpty()) {
AllTrafficSpacesNode allTSNode = new AllTrafficSpacesNode(space.getAuxTrafficSpaces(), CityObjectGroupNode auxTrafficSpacesGroupNode = new CityObjectGroupNode(space.getTrafficSpaces(),
TrafficSpaceObject.TrafficSpaceType.AUXILIARY_TRAFFIC_SPACE); "AUXILIARY_TRAFFIC_SPACE", Color.YELLOW);
TreeItem<Renderable> allTSNodeTextItem = new TreeItem<>(allTSNode); TreeItem<Renderable> auxTrafficSpacesGroupItem = new TreeItem<>(auxTrafficSpacesGroupNode);
root.getChildren().add(allTSNodeTextItem); root.getChildren().add(auxTrafficSpacesGroupItem);
allTSNodeTextItem.setExpanded(true); auxTrafficSpacesGroupItem.setExpanded(true);
for (TrafficSpaceObject atso : space.getAuxTrafficSpaces()) { for (TrafficSpaceObject atso : space.getAuxTrafficSpaces()) {
TransportationObjectNode atsoNode = new TransportationObjectNode(atso); TreeItem<Renderable> atsoNodeItem = buildCityObjectNode(atso, auxTrafficSpacesGroupItem);
TreeItem<Renderable> atsoNodeItem = new TreeItem<>(atsoNode);
atsoNodeItem.setExpanded(false);
allTSNodeTextItem.getChildren().add(atsoNodeItem);
createGeometryNodes(atso, atsoNodeItem);
createTrafficAreaNodes(atso, atsoNodeItem, TrafficAreaObject.TrafficAreaType.AUXILIARY_TRAFFIC_AREA); createTrafficAreaNodes(atso, atsoNodeItem, TrafficAreaObject.TrafficAreaType.AUXILIARY_TRAFFIC_AREA);
} }
} }
...@@ -739,16 +730,13 @@ public class CityDoctorController { ...@@ -739,16 +730,13 @@ public class CityDoctorController {
public void createTrafficAreaNodes(TransportationObject t, TreeItem<Renderable> root, TrafficAreaObject.TrafficAreaType type) { public void createTrafficAreaNodes(TransportationObject t, TreeItem<Renderable> root, TrafficAreaObject.TrafficAreaType type) {
if (t instanceof TrafficSpaceObject space && !space.getTrafficAreas().isEmpty()) { if (t instanceof TrafficSpaceObject space && !space.getTrafficAreas().isEmpty()) {
AllTrafficAreaNode allTANode = new AllTrafficAreaNode(space.getTrafficAreas(), type); CityObjectGroupNode trafficAreaGroupNode = new CityObjectGroupNode(space.getTrafficAreas(), type.toString(), Color.YELLOW);
TreeItem<Renderable> allTANodeTextItem = new TreeItem<>(allTANode); TreeItem<Renderable> trafficAreaGroupItem = new TreeItem<>(trafficAreaGroupNode);
root.getChildren().add(allTANodeTextItem); root.getChildren().add(trafficAreaGroupItem);
allTANodeTextItem.setExpanded(true); trafficAreaGroupItem.setExpanded(true);
for (TrafficAreaObject tao : space.getTrafficAreas()) { for (TrafficAreaObject tao : space.getTrafficAreas()) {
TransportationObjectNode taoNode = new TransportationObjectNode(tao); buildCityObjectNode(tao, trafficAreaGroupItem);
TreeItem<Renderable> taoNodeTextItem = new TreeItem<>(taoNode);
taoNodeTextItem.setExpanded(true);
allTANodeTextItem.getChildren().add(taoNodeTextItem);
createGeometryNodes(tao, taoNodeTextItem);
} }
} }
...@@ -758,12 +746,8 @@ public class CityDoctorController { ...@@ -758,12 +746,8 @@ public class CityDoctorController {
int tunnelChunk = tunnelChunkNr.get(); int tunnelChunk = tunnelChunkNr.get();
for (int i = tunnelChunk * MAX_FEATURES_PER_CHUNK; i < (tunnelChunk + 1) * MAX_FEATURES_PER_CHUNK && i < list.size(); i++) { for (int i = tunnelChunk * MAX_FEATURES_PER_CHUNK; i < (tunnelChunk + 1) * MAX_FEATURES_PER_CHUNK && i < list.size(); i++) {
Tunnel tunnel = list.get(i); Tunnel tunnel = list.get(i);
TunnelNode node = new TunnelNode(tunnel); TreeItem<Renderable> item = buildTopLevelCityObjectNode(tunnel, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(tunnel, item);
createBoundarySurfaceNodes(tunnel.getBoundarySurfaces(), item);
createTunnelHollowNodes(tunnel, item); createTunnelHollowNodes(tunnel, item);
createTunnelInstallationNodes(tunnel, item); createTunnelInstallationNodes(tunnel, item);
createTunnelFurnitureNodes(tunnel, item); createTunnelFurnitureNodes(tunnel, item);
...@@ -788,17 +772,14 @@ public class CityDoctorController { ...@@ -788,17 +772,14 @@ public class CityDoctorController {
if (tunnel.getTunnelConstructiveElements().isEmpty()){ if (tunnel.getTunnelConstructiveElements().isEmpty()){
return; return;
} }
AllTunnelConstructiveElementsNode allTceNode = new AllTunnelConstructiveElementsNode(tunnel.getTunnelConstructiveElements());
TreeItem<Renderable> allTceNodeTextItem = new TreeItem<>(allTceNode); CityObjectGroupNode constructiveElementsGroupNode = new CityObjectGroupNode(tunnel.getTunnelConstructiveElements(),
root.getChildren().add(allTceNodeTextItem); "Constructive Elements", Color.DARKGRAY);
TreeItem<Renderable> constructiveElementsGroupItem = new TreeItem<>(constructiveElementsGroupNode);
root.getChildren().add(constructiveElementsGroupItem);
for (TunnelConstructiveElement tce : tunnel.getTunnelConstructiveElements()) { for (TunnelConstructiveElement tce : tunnel.getTunnelConstructiveElements()) {
TunnelConstructiveElementNode tceNode = new TunnelConstructiveElementNode(tce); buildCityObjectNode(tce, constructiveElementsGroupItem, tce.getBoundarySurfaces());
TreeItem<Renderable> tceNodeItem = new TreeItem<>(tceNode);
tceNodeItem.setExpanded(true);
allTceNodeTextItem.getChildren().add(tceNodeItem);
createGeometryNodes(tce, tceNodeItem);
createBoundarySurfaceNodes(tce.getBoundarySurfaces(), tceNodeItem);
} }
} }
...@@ -806,17 +787,18 @@ public class CityDoctorController { ...@@ -806,17 +787,18 @@ public class CityDoctorController {
if (tunnel.getTunnelParts().isEmpty()) { if (tunnel.getTunnelParts().isEmpty()) {
return; return;
} }
AllTunnelPartsNode allTpsText = new AllTunnelPartsNode(tunnel.getTunnelParts());
TreeItem<Renderable> allTpsTextItem = new TreeItem<>(allTpsText); CityObjectGroupNode tunnelPartsGroupNode = new CityObjectGroupNode(tunnel.getTunnelParts(), "Tunnel parts", Color.DARKGRAY);
root.getChildren().add(allTpsTextItem); TreeItem<Renderable> tunnelPartsGroupItem = new TreeItem<>(tunnelPartsGroupNode);
root.getChildren().add(tunnelPartsGroupItem);
for (TunnelPart tp : tunnel.getTunnelParts()) { for (TunnelPart tp : tunnel.getTunnelParts()) {
TunnelPartNode tpNode = new TunnelPartNode(tp); TreeItem<Renderable> tpNodeItem = buildCityObjectNode(tp, tunnelPartsGroupItem, tp.getBoundarySurfaces());
TreeItem<Renderable> tpNodeItem = new TreeItem<>(tpNode);
tpNodeItem.setExpanded(true); createTunnelHollowNodes(tunnel, tpNodeItem);
allTpsTextItem.getChildren().add(tpNodeItem); createTunnelInstallationNodes(tunnel, tpNodeItem);
createGeometryNodes(tp, tpNodeItem); createTunnelFurnitureNodes(tunnel, tpNodeItem);
createBoundarySurfaceNodes(tp.getBoundarySurfaces(), tpNodeItem); createTunnelConstructiveElementsNodes(tunnel, tpNodeItem);
} }
} }
...@@ -836,18 +818,14 @@ public class CityDoctorController { ...@@ -836,18 +818,14 @@ public class CityDoctorController {
if (bridge.getConstructiveElements().isEmpty()) { if (bridge.getConstructiveElements().isEmpty()) {
return; return;
} }
AllBridgeConstructiveElementsNode allBceNode = new AllBridgeConstructiveElementsNode(
bridge.getConstructiveElements()); CityObjectGroupNode constructiveElementsGroupNode = new CityObjectGroupNode(
TreeItem<Renderable> allBceNodeTextItem = new TreeItem<>(allBceNode); bridge.getConstructiveElements(), "Constructive Elements", Color.CORAL);
item.getChildren().add(allBceNodeTextItem); TreeItem<Renderable> constructiveElementsGroupItem = new TreeItem<>(constructiveElementsGroupNode);
item.getChildren().add(constructiveElementsGroupItem);
for (BridgeConstructiveElement bce : bridge.getConstructiveElements()) { for (BridgeConstructiveElement bce : bridge.getConstructiveElements()) {
BridgeConstructiveElementNode bceNode = new BridgeConstructiveElementNode(bce); buildCityObjectNode(bce, constructiveElementsGroupItem, bce.getBoundarySurfaces());
TreeItem<Renderable> bceNodeItem = new TreeItem<>(bceNode);
bceNodeItem.setExpanded(true);
allBceNodeTextItem.getChildren().add(bceNodeItem);
createGeometryNodes(bce, bceNodeItem);
createBoundarySurfaceNodes(bce.getBoundarySurfaces(), bceNodeItem);
} }
} }
...@@ -855,21 +833,22 @@ public class CityDoctorController { ...@@ -855,21 +833,22 @@ public class CityDoctorController {
if (bridge.getParts().isEmpty()) { if (bridge.getParts().isEmpty()) {
return; return;
} }
AllBridgePartsNode allBpsText = new AllBridgePartsNode(bridge.getParts());
TreeItem<Renderable> allBpsTextItem = new TreeItem<>(allBpsText); CityObjectGroupNode bridgePartsGroupNode = new CityObjectGroupNode(bridge.getParts(), "Bridge Parts", Color.CORAL);
item.getChildren().add(allBpsTextItem); TreeItem<Renderable> bridgePartsGroupItem = new TreeItem<>(bridgePartsGroupNode);
item.getChildren().add(bridgePartsGroupItem);
for (BridgeObject bp : bridge.getParts()) { for (BridgeObject bp : bridge.getParts()) {
BridgeNode bpNode = new BridgeNode(bp); TreeItem<Renderable> bpNodeItem = buildCityObjectNode(bp, bridgePartsGroupItem, bp.getBoundarySurfaces());
TreeItem<Renderable> bpNodeItem = new TreeItem<>(bpNode);
bpNodeItem.setExpanded(true); createBridgeRoomNodes(bp, bpNodeItem);
allBpsTextItem.getChildren().add(bpNodeItem); createBridgeInstallationNodes(bp, bpNodeItem);
createGeometryNodes(bp, bpNodeItem); createBridgeFurnitureNodes(bp, bpNodeItem);
createBoundarySurfaceNodes(bp.getBoundarySurfaces(), bpNodeItem); createBridgeConstructiveElementsNodes(bp, bpNodeItem);
} }
} }
private void createBuildingInstallationNodes(Building ab, TreeItem<Renderable> root) { private void createBuildingInstallationNodes(AbstractBuilding ab, TreeItem<Renderable> root) {
createInstallationNodes(ab.getBuildingInstallations(), root); createInstallationNodes(ab.getBuildingInstallations(), root);
} }
...@@ -878,20 +857,16 @@ public class CityDoctorController { ...@@ -878,20 +857,16 @@ public class CityDoctorController {
return; return;
} }
AllInstallationsNode allBiNode = new AllInstallationsNode(installations); CityObjectGroupNode installationsGroupNode = new CityObjectGroupNode(installations, "Installations", null);
TreeItem<Renderable> allBpsTextItem = new TreeItem<>(allBiNode); TreeItem<Renderable> installationsGroupItem = new TreeItem<>(installationsGroupNode);
root.getChildren().add(allBpsTextItem); root.getChildren().add(installationsGroupItem);
for (Installation bi : installations) { for (Installation bi : installations) {
InstallationNode biNode = new InstallationNode(bi); buildCityObjectNode(bi, installationsGroupItem, bi.getBoundarySurfaces());
TreeItem<Renderable> biItem = new TreeItem<>(biNode);
biItem.setExpanded(true);
allBpsTextItem.getChildren().add(biItem);
createGeometryNodes(bi, biItem);
createBoundarySurfaceNodes(bi.getBoundarySurfaces(), biItem);
} }
} }
private void createBuildingRoomNodes(Building ab, TreeItem<Renderable> root) { private void createBuildingRoomNodes(AbstractBuilding ab, TreeItem<Renderable> root) {
createRoomNodes(ab.getBuildingRooms(), root); createRoomNodes(ab.getBuildingRooms(), root);
} }
...@@ -900,58 +875,48 @@ public class CityDoctorController { ...@@ -900,58 +875,48 @@ public class CityDoctorController {
return; return;
} }
AllRoomsNode allRoNode = new AllRoomsNode(rooms); CityObjectGroupNode roomsGroupNode = new CityObjectGroupNode(rooms, "Rooms", null);
TreeItem<Renderable> allRoNodeTextItem = new TreeItem<>(allRoNode); TreeItem<Renderable> roomsGroupItem = new TreeItem<>(roomsGroupNode);
root.getChildren().add(allRoNodeTextItem); root.getChildren().add(roomsGroupItem);
for (AbstractRoom room : rooms) { for (AbstractRoom room : rooms) {
RoomNode roomNode = new RoomNode(room); buildCityObjectNode(room, roomsGroupItem, room.getBoundarySurfaces());
TreeItem<Renderable> roomNodeTextItem = new TreeItem<>(roomNode);
roomNodeTextItem.setExpanded(true);
allRoNodeTextItem.getChildren().add(roomNodeTextItem);
createGeometryNodes(room, roomNodeTextItem);
createBoundarySurfaceNodes(room.getBoundarySurfaces(), roomNodeTextItem);
} }
} }
private void createBuildingStoreyNodes(Building ab, TreeItem<Renderable> root) { private void createBuildingStoreyNodes(AbstractBuilding ab, TreeItem<Renderable> root) {
List<Storey> storeys = ab.getBuildingStoreys(); List<Storey> storeys = ab.getBuildingStoreys();
if (storeys.isEmpty()) { if (storeys.isEmpty()) {
return; return;
} }
AllStoreysNode allSNode = new AllStoreysNode(storeys);
TreeItem<Renderable> allSNodeTextItem = new TreeItem<>(allSNode); CityObjectGroupNode storeysGroupNode = new CityObjectGroupNode(storeys, "Storeys", null);
root.getChildren().add(allSNodeTextItem); TreeItem<Renderable> storeysGroupItem = new TreeItem<>(storeysGroupNode);
root.getChildren().add(storeysGroupItem);
for (Storey storey : storeys) { for (Storey storey : storeys) {
StoreyNode storeyNode = new StoreyNode(storey); buildCityObjectNode(storey, storeysGroupItem, storey.getBoundarySurfaces());
TreeItem<Renderable> storeyNodeTextItem = new TreeItem<>(storeyNode);
storeyNodeTextItem.setExpanded(true);
allSNodeTextItem.getChildren().add(storeyNodeTextItem);
createGeometryNodes(storey, storeyNodeTextItem);
createBoundarySurfaceNodes(storey.getBoundarySurfaces(), storeyNodeTextItem);
} }
} }
public void createBuildingUnitNodes(Building ab, TreeItem<Renderable> root) { public void createBuildingUnitNodes(AbstractBuilding ab, TreeItem<Renderable> root) {
List<BuildingUnit> buildingUnits = ab.getBuildingUnits(); List<BuildingUnit> buildingUnits = ab.getBuildingUnits();
if (buildingUnits.isEmpty()) { if (buildingUnits.isEmpty()) {
return; return;
} }
AllBuildingUnitsNode allSNode = new AllBuildingUnitsNode(buildingUnits);
TreeItem<Renderable> allSNodeTextItem = new TreeItem<>(allSNode); CityObjectGroupNode buildingUnitsGroupNode = new CityObjectGroupNode(buildingUnits, "Building Units", null);
root.getChildren().add(allSNodeTextItem); TreeItem<Renderable> buildingUnitsGroupItem = new TreeItem<>(buildingUnitsGroupNode);
root.getChildren().add(buildingUnitsGroupItem);
for (BuildingUnit buildingUnit : buildingUnits) { for (BuildingUnit buildingUnit : buildingUnits) {
BuildingUnitNode buildingUnitNode = new BuildingUnitNode(buildingUnit); buildCityObjectNode(buildingUnit, buildingUnitsGroupItem, buildingUnit.getBoundarySurfaces());
TreeItem<Renderable> storeyNodeTextItem = new TreeItem<>(buildingUnitNode);
storeyNodeTextItem.setExpanded(true);
allSNodeTextItem.getChildren().add(storeyNodeTextItem);
createGeometryNodes(buildingUnit, storeyNodeTextItem);
createBoundarySurfaceNodes(buildingUnit.getBoundarySurfaces(), storeyNodeTextItem);
} }
} }
private void createBuildingFurnitureNodes(Building ab, TreeItem<Renderable> root) { private void createBuildingFurnitureNodes(AbstractBuilding ab, TreeItem<Renderable> root) {
createFurnitureNodes(ab.getBuildingRoomFurnitureList(), root); createFurnitureNodes(ab.getBuildingRoomFurnitureList(), root);
} }
...@@ -960,16 +925,12 @@ public class CityDoctorController { ...@@ -960,16 +925,12 @@ public class CityDoctorController {
return; return;
} }
AllFurnitureNode allFnNode = new AllFurnitureNode(furniture); CityObjectGroupNode furnitureGroupNode = new CityObjectGroupNode(furniture, "Furniture", null);
TreeItem<Renderable> allFnNodeTextItem = new TreeItem<>(allFnNode); TreeItem<Renderable> furnitureGroupItem = new TreeItem<>(furnitureGroupNode);
root.getChildren().add(allFnNodeTextItem); root.getChildren().add(furnitureGroupItem);
for (AbstractFurniture fn : furniture) { for (AbstractFurniture fn : furniture) {
FurnitureNode fnNode = new FurnitureNode(fn); buildCityObjectNode(fn, furnitureGroupItem, fn.getBoundarySurfaceList());
TreeItem<Renderable> fnNodeTextItem = new TreeItem<>(fnNode);
fnNodeTextItem.setExpanded(true);
allFnNodeTextItem.getChildren().add(fnNodeTextItem);
createGeometryNodes(fn, fnNodeTextItem);
createBoundarySurfaceNodes(fn.getBoundarySurfaceList(), fnNodeTextItem);
} }
} }
...@@ -977,25 +938,26 @@ public class CityDoctorController { ...@@ -977,25 +938,26 @@ public class CityDoctorController {
if (bsList.isEmpty()) { if (bsList.isEmpty()) {
return; return;
} }
AllBoundarySurfacesNode allBsText = new AllBoundarySurfacesNode(bsList);
TreeItem<Renderable> allBpsTextItem = new TreeItem<>(allBsText);
root.getChildren().add(allBpsTextItem);
allBpsTextItem.getChildren().add(new TreeItem<>()); CityObjectGroupNode boundarySurfacesGroupNode = new CityObjectGroupNode(bsList, "Boundary Surfaces", null);
TreeItem<Renderable> boundarySurfacesGroupItem = new TreeItem<>(boundarySurfacesGroupNode);
root.getChildren().add(boundarySurfacesGroupItem);
allBpsTextItem.expandedProperty().addListener((obs, old, newV) -> { boundarySurfacesGroupItem.getChildren().add(new TreeItem<>());
if (Boolean.TRUE.equals(newV) && allBpsTextItem.getChildren().size() == 1) {
boundarySurfacesGroupItem.expandedProperty().addListener((obs, old, newV) -> {
if (Boolean.TRUE.equals(newV) && boundarySurfacesGroupItem.getChildren().size() == 1) {
Platform.runLater(() -> { Platform.runLater(() -> {
allBpsTextItem.getChildren().clear(); boundarySurfacesGroupItem.getChildren().clear();
for (BoundarySurface bs : bsList) { for (BoundarySurface bs : bsList) {
BoundarySurfaceNode bsText = new BoundarySurfaceNode(bs); CityObjectNode bsText = new CityObjectNode(bs);
TreeItem<Renderable> bsTextItem = new TreeItem<>(bsText); TreeItem<Renderable> bsTextItem = new TreeItem<>(bsText);
bsTextItem.setExpanded(true); bsTextItem.setExpanded(true);
allBpsTextItem.getChildren().add(bsTextItem); boundarySurfacesGroupItem.getChildren().add(bsTextItem);
createGeometryNodes(bs, bsTextItem); createGeometryNodes(bs, bsTextItem);
createOpeningNodes(bs.getOpenings(), bsTextItem); createOpeningNodes(bs.getOpenings(), bsTextItem);
} }
updateTree(allBpsTextItem); updateTree(boundarySurfacesGroupItem);
}); });
} }
}); });
...@@ -1005,31 +967,35 @@ public class CityDoctorController { ...@@ -1005,31 +967,35 @@ public class CityDoctorController {
if (openings == null || openings.isEmpty()) { if (openings == null || openings.isEmpty()) {
return; return;
} }
AllOpeningsNode allOpeningsNode = new AllOpeningsNode(openings);
TreeItem<Renderable> allOpeningsItem = new TreeItem<>(allOpeningsNode); CityObjectGroupNode openingsGroupNode = new CityObjectGroupNode(openings, "Openings", null);
TreeItem<Renderable> openingsGroupItem = new TreeItem<>(openingsGroupNode);
root.getChildren().add(openingsGroupItem);
for (Opening o : openings) { for (Opening o : openings) {
OpeningNode openingNode = new OpeningNode(o); OpeningNode openingNode = new OpeningNode(o);
TreeItem<Renderable> openingsItem = new TreeItem<>(openingNode); TreeItem<Renderable> openingItem = new TreeItem<>(openingNode);
allOpeningsItem.getChildren().add(openingsItem); openingsGroupItem.getChildren().add(openingItem);
} }
root.getChildren().add(allOpeningsItem);
} }
private void createBuildingPartNodes(Building ab, TreeItem<Renderable> item) { private void createBuildingPartNodes(Building ab, TreeItem<Renderable> item) {
if (ab.getBuildingParts().isEmpty()) { if (ab.getBuildingParts().isEmpty()) {
return; return;
} }
AllBuildingPartsNode allBpsText = new AllBuildingPartsNode(ab.getBuildingParts()); CityObjectGroupNode buildingPartsGroupNode = new CityObjectGroupNode(ab.getBuildingParts(), "Building Parts", null);
TreeItem<Renderable> allBpsTextItem = new TreeItem<>(allBpsText); TreeItem<Renderable> buildingPartsGroupItem = new TreeItem<>(buildingPartsGroupNode);
item.getChildren().add(allBpsTextItem); item.getChildren().add(buildingPartsGroupItem);
for (BuildingPart bp : ab.getBuildingParts()) { for (BuildingPart bp : ab.getBuildingParts()) {
BuildingPartNode bpNode = new BuildingPartNode(bp); TreeItem<Renderable> bpNodeItem = buildCityObjectNode(bp, buildingPartsGroupItem, bp.getBoundarySurfaces());
TreeItem<Renderable> bpNodeItem = new TreeItem<>(bpNode);
bpNodeItem.setExpanded(true); createBuildingInstallationNodes(bp, bpNodeItem);
allBpsTextItem.getChildren().add(bpNodeItem); createBuildingRoomNodes(bp, bpNodeItem);
createGeometryNodes(bp, bpNodeItem); createBuildingFurnitureNodes(bp, bpNodeItem);
createBoundarySurfaceNodes(bp.getBoundarySurfaces(), bpNodeItem); createBuildingStoreyNodes(bp, bpNodeItem);
createBuildingUnitNodes(bp, bpNodeItem);
} }
} }
...@@ -1043,11 +1009,15 @@ public class CityDoctorController { ...@@ -1043,11 +1009,15 @@ public class CityDoctorController {
public void startChecks(ValidationConfiguration config, ProgressListener l) { public void startChecks(ValidationConfiguration config, ProgressListener l) {
if (model == null) { if (model == null) {
logger.warn(Localization.getText("CityDoctorController.noDatamodel")); if (logger.isWarnEnabled()) {
logger.warn(Localization.getText("CityDoctorController.noDatamodel"));
}
return; return;
} }
if (sourceFile == null) { if (sourceFile == null) {
logger.warn(Localization.getText("CityDoctorController.noSourceFile")); if (logger.isWarnEnabled()) {
logger.warn(Localization.getText("CityDoctorController.noSourceFile"));
}
return; return;
} }
try { try {
...@@ -1083,9 +1053,10 @@ public class CityDoctorController { ...@@ -1083,9 +1053,10 @@ public class CityDoctorController {
public void startZipFileChecks(ValidationConfiguration config, ProgressListener l, boolean lowMemoryMode, public void startZipFileChecks(ValidationConfiguration config, ProgressListener l, boolean lowMemoryMode,
Path outputPath, boolean pdfReports, boolean xmlReports) { Path outputPath, boolean pdfReports, boolean xmlReports) {
if (zipArchive == null) { if (zipArchive == null && logger.isWarnEnabled()) {
logger.warn(Localization.getText("CityDoctorController.noZipFile")); logger.warn(Localization.getText("CityDoctorController.noZipFile"));
} }
if (lowMemoryMode) { if (lowMemoryMode) {
startZipFileCheckStream(config, outputPath, pdfReports, xmlReports); startZipFileCheckStream(config, outputPath, pdfReports, xmlReports);
return; return;
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Dies ist die Gitlab-Instanz des Transferportals der Hochschule für Technik Stuttgart. Hier geht es zurück zum Portal