X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.district.network.ui%2Fsrc%2Forg%2Fsimantics%2Fdistrict%2Fnetwork%2Fui%2Ffunction%2FFunctions.java;h=04cd94cf46658f2d3c0bbb8431275d06f8640ad0;hb=refs%2Fchanges%2F58%2F2258%2F2;hp=016a1420dba6a4a8b5588c4e8e4a7735633f2ae2;hpb=16ee01dc5a40981c58fd5b478b89552e5814e8bb;p=simantics%2Fdistrict.git diff --git a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java index 016a1420..04cd94cf 100644 --- a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java +++ b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java @@ -1,14 +1,19 @@ package org.simantics.district.network.ui.function; +import java.util.Collection; import java.util.Collections; import java.util.HashMap; +import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Set; import java.util.stream.Collectors; import org.eclipse.jface.dialogs.Dialog; import org.eclipse.jface.layout.GridDataFactory; import org.eclipse.swt.SWT; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Combo; @@ -30,22 +35,27 @@ import org.simantics.db.Resource; import org.simantics.db.Session; import org.simantics.db.WriteGraph; import org.simantics.db.common.request.IndexRoot; +import org.simantics.db.common.request.ObjectsWithType; import org.simantics.db.common.request.ReadRequest; import org.simantics.db.common.request.WriteRequest; import org.simantics.db.exception.DatabaseException; import org.simantics.db.exception.RuntimeDatabaseException; +import org.simantics.db.exception.ServiceException; +import org.simantics.db.layer0.QueryIndexUtils; import org.simantics.db.layer0.variable.Variable; +import org.simantics.db.layer0.variable.Variables; import org.simantics.db.layer0.variable.Variables.Role; import org.simantics.db.procedure.Procedure; -import org.simantics.diagram.stubs.DiagramResource; import org.simantics.district.network.ontology.DistrictNetworkResource; import org.simantics.layer0.Layer0; import org.simantics.modeling.ModelingResources; -import org.simantics.modeling.ModelingUtils; import org.simantics.modeling.adapters.NewCompositeActionFactory; import org.simantics.modeling.typicals.TypicalUtil; +import org.simantics.operation.Layer0X; import org.simantics.scl.reflection.annotations.SCLValue; -import org.simantics.structural.stubs.StructuralResource2; +import org.simantics.scl.runtime.SCLContext; +import org.simantics.scl.runtime.function.Function1; +import org.simantics.scl.runtime.function.FunctionImpl1; import org.simantics.ui.workbench.action.DefaultActions; import org.simantics.utils.ui.SWTUtils; import org.slf4j.Logger; @@ -92,22 +102,33 @@ public class Functions { } public static Map getVertexMappings(ReadGraph graph, Resource resource) throws DatabaseException { - return getNetworkMappingsByType(graph, resource , DistrictNetworkResource.getInstance(graph).Mapping_VertexMapping); + Map second = getNetworkMappingsByType(graph, resource , DistrictNetworkResource.getInstance(graph).Mapping_VertexMapping); + return second; } public static Map getEdgeMappings(ReadGraph graph, Resource resource) throws DatabaseException { - return getNetworkMappingsByType(graph, resource , DistrictNetworkResource.getInstance(graph).Mapping_EdgeMapping); + Map second = getNetworkMappingsByType(graph, resource , DistrictNetworkResource.getInstance(graph).Mapping_EdgeMapping); + return second; + } + + public static Map getCRSs(ReadGraph graph, Resource resource) throws DatabaseException { + Map result = getNetworkMappingsByType(graph, resource, DistrictNetworkResource.getInstance(graph).SpatialRefSystem); + return result; + } public static Map getNetworkMappingsByType(ReadGraph graph, Resource element, Resource mappingType) throws DatabaseException { Resource indexRoot = graph.sync(new IndexRoot(element)); - List mappings = ModelingUtils.searchByType(graph, indexRoot, mappingType); + List mappings = QueryIndexUtils.searchByType(graph, indexRoot, mappingType); Map result = new HashMap<>(mappings.size()); Layer0 L0 = Layer0.getInstance(graph); mappings.forEach(mapping -> { try { String name = graph.getRelatedValue2(mapping, L0.HasName); - result.put(name, mapping); + Resource existing = result.put(name, mapping); + if (existing != null) { + LOGGER.warn("Duplicate mapping name! {} {} and existing is {}", name, mapping, existing); + } } catch (DatabaseException e) { e.printStackTrace(); } @@ -117,7 +138,7 @@ public class Functions { private static Object baseMappingModifier(ReadGraph graph, Resource element, Resource property, Resource mappingType, Variable context) throws DatabaseException { Resource indexRoot = graph.sync(new IndexRoot(element)); - List mappings = ModelingUtils.searchByType(graph, indexRoot, mappingType); + List mappings = QueryIndexUtils.searchByType(graph, indexRoot, mappingType); Enumeration enums = Enumeration .make(mappings.stream().map(m -> createEnumeratedValue(graph, m)).collect(Collectors.toList())); @@ -162,8 +183,11 @@ public class Functions { @SCLValue(type = "ReadGraph -> Resource -> a -> b") public static Object convertToValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException { - return graph.getRelatedValue2(resource, Layer0.getInstance(graph).HasName, Bindings.STRING); -// return null; + Layer0 L0 = Layer0.getInstance(graph); + String label = graph.getPossibleRelatedValue2(resource, L0.HasLabel, Bindings.STRING); + if (label == null) + label = graph.getRelatedValue(resource, L0.HasName, Bindings.STRING); + return label; } @@ -193,9 +217,15 @@ public class Functions { private Resource configuration; private Map vertexMappings = new HashMap<>(); private Map edgeMappings = new HashMap<>(); + private Map composites = new HashMap<>(); + private Map crss = new HashMap<>(); private Resource defaultVertexMapping; private Resource defaultEdgeMapping; + private Resource defaultCRS; + + private Combo compositeMappingCombo; + private Combo componentMappingCombo; protected DefaultMappingsDialog(Shell parentShell, Resource configuration) { super(parentShell); @@ -216,6 +246,7 @@ public class Functions { composite = (Composite) super.createDialogArea(parent); createMappingsGroup(composite); + createExistingCompositeGroup(composite); createCRSSettingsGroup(composite); // compute default values @@ -227,12 +258,25 @@ public class Functions { vertexMappings = getVertexMappings(graph, configuration); edgeMappings = getEdgeMappings(graph, configuration); + composites = getComposites(graph, configuration); + + crss = getCRSs(graph, configuration); + composite.getDisplay().asyncExec(() -> { vertexMappingCombo.setItems(vertexMappings.keySet().toArray(new String[vertexMappings.size()])); edgeMappingCombo.setItems(edgeMappings.keySet().toArray(new String[edgeMappings.size()])); + + crsCombo.setItems(crss.keySet().toArray(new String[crss.size()])); + + compositeMappingCombo.setItems(composites.keySet().toArray(new String[composites.size()])); vertexMappingCombo.select(0); edgeMappingCombo.select(0); + + crsCombo.select(0); + + if (!composites.isEmpty()) + compositeMappingCombo.select(0); }); } @@ -240,6 +284,28 @@ public class Functions { return composite; } + protected Map getComposites(ReadGraph graph, Resource element) throws DatabaseException { + List nonDistrictComposites = composites.values().stream().filter(comp -> { + try { + return !graph.isInstanceOf(comp, DistrictNetworkResource.getInstance(graph).Composite); + } catch (ServiceException e1) { + LOGGER.error("Could not check if composite " + comp + " is instanceOf DistrictNetwork.composite"); + return false; + } + }).collect(Collectors.toList()); + Map result = new HashMap<>(nonDistrictComposites.size()); + Layer0 L0 = Layer0.getInstance(graph); + nonDistrictComposites.forEach(mapping -> { + try { + String name = graph.getRelatedValue2(mapping, L0.HasName); + result.put(name, mapping); + } catch (DatabaseException e) { + LOGGER.error("Could not read name of " + mapping, e); + } + }); + return result; + } + private void createMappingsGroup(Composite parent) { Group group= new Group(parent, SWT.NONE); group.setFont(parent.getFont()); @@ -264,6 +330,52 @@ public class Functions { GridDataFactory.fillDefaults().grab(true, false).applyTo(edgeMappingCombo); } + private void createExistingCompositeGroup(Composite parent) { + Group group= new Group(parent, SWT.NONE); + group.setFont(parent.getFont()); + group.setText("Mapped composite"); + GridDataFactory.fillDefaults().grab(true, false).applyTo(group); + group.setLayout(new GridLayout(1, false)); + + Composite cmposite = new Composite(group, SWT.NONE); + cmposite.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false)); + cmposite.setLayout(new GridLayout(2, false)); + + Label compositeMappingLabel = new Label(cmposite, SWT.NONE); + compositeMappingLabel.setText("Select composite"); + + compositeMappingCombo = new Combo(cmposite, SWT.READ_ONLY | SWT.BORDER); + GridDataFactory.fillDefaults().grab(true, false).applyTo(compositeMappingCombo); + compositeMappingCombo.addSelectionListener(new SelectionAdapter() { + + @Override + public void widgetSelected(SelectionEvent e) { + super.widgetSelected(e); + recalculateMappapleComponents(); + } + }); + + Label compojnentMappingLabel = new Label(cmposite, SWT.NONE); + compojnentMappingLabel.setText("Select component"); + + componentMappingCombo = new Combo(cmposite, SWT.READ_ONLY | SWT.BORDER); + GridDataFactory.fillDefaults().grab(true, false).applyTo(componentMappingCombo); + } + + protected void recalculateMappapleComponents() { + Simantics.getSession().asyncRequest(new ReadRequest() { + + @Override + public void run(ReadGraph graph) throws DatabaseException { + + + composite.getDisplay().asyncExec(() -> { + + }); + } + }); + } + private void createCRSSettingsGroup(Composite parent) { Group group= new Group(parent, SWT.NONE); group.setFont(parent.getFont()); @@ -288,6 +400,11 @@ public class Functions { protected void computeResult() { defaultVertexMapping = vertexMappings.get(vertexMappingCombo.getItem(vertexMappingCombo.getSelectionIndex())); defaultEdgeMapping = edgeMappings.get(edgeMappingCombo.getItem(edgeMappingCombo.getSelectionIndex())); + defaultCRS = crss.get(crsCombo.getItem(crsCombo.getSelectionIndex())); + } + + public Resource getCRS() { + return defaultCRS; } } @@ -313,6 +430,11 @@ public class Functions { Resource diagram = graph.getSingleObject(composite, ModelingResources.getInstance(graph).CompositeToDiagram); graph.claim(diagram, DN.EdgeDefaultMapping, dialog.getDefaultEdgeMapping()); graph.claim(diagram, DN.VertexDefaultMapping, dialog.getDefaultVertexMapping()); + graph.claim(diagram, DN.HasSpatialRefSystem, dialog.getCRS()); + + // Generated name prefix from composite name + String compositeName = graph.getRelatedValue2(composite, Layer0.getInstance(graph).HasName, Bindings.STRING); + graph.claimLiteral(diagram, Layer0X.getInstance(graph).HasGeneratedNamePrefix, "N" + compositeName.substring(compositeName.length() - 1, compositeName.length())); } }); DefaultActions.asyncPerformDefaultAction(Simantics.getSession(), composite, false, false, true); @@ -326,4 +448,103 @@ public class Functions { } }); } + + public static Collection getDistrictDiagrams(ReadGraph graph) throws DatabaseException { + Layer0 L0 = Layer0.getInstance(graph); + Collection indexRoots = graph.sync(new ObjectsWithType(Simantics.getProjectResource(), L0.ConsistsOf, L0.IndexRoot)); + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + Set results = new HashSet<>(); + for (Resource indexRoot : indexRoots) { + Collection diagrams = QueryIndexUtils.searchByType(graph, indexRoot, DN.Diagram); + results.addAll(diagrams); + } + return results; + } + + private static List listInstanceNames(ReadGraph graph, Variable context, Resource type) throws DatabaseException { + Resource indexRoot = Variables.getIndexRoot(graph, context); + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + List properties = QueryIndexUtils.searchByType(graph, indexRoot, DN.Vertex_ScaleProperty); + return properties.stream() + .map(m -> createEnumeratedValue(graph, m)) + .map(EnumeratedValue::getName) + .collect(Collectors.toList()); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Object edgeThicknessPropertyEnumerationValues(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + return listInstanceNames(graph, context, DN.Edge_ThicknessProperty); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Object nodeScalePropertyEnumerationValues(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + return listInstanceNames(graph, context, DN.Vertex_ScaleProperty); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Object edgeThicknessPropertyModifier(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + Resource diagram = resolveElement(graph, context); + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + return baseMappingModifier(graph, diagram, DN.Diagram_edgeThicknessProperty, DN.Edge_ThicknessProperty, context); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Object nodeScalePropertyModifier(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + Resource diagram = resolveElement(graph, context); + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + return baseMappingModifier(graph, diagram, DN.Diagram_nodeScaleProperty, DN.Vertex_ScaleProperty, context); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Function1 hasDiameterValue(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + return directPropertyValueFunction(DistrictNetworkResource.getInstance(graph).Edge_HasDiameter, 0); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Function1 hasNominalMassFlowValue(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + return directPropertyValueFunction(DistrictNetworkResource.getInstance(graph).Edge_HasNominalMassFlow, 0); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Function1 hasNominalSupplyPressure(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + return directPropertyValueFunction(DistrictNetworkResource.getInstance(graph).Vertex_HasSupplyPressure, 0); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Function1 hasElevation(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + return directPropertyValueFunction(DistrictNetworkResource.getInstance(graph).Vertex_HasElevation, 0); + } + + private static final Function1 ONE = new FunctionImpl1() { + private final Double ONE = 1.0; + @Override + public Double apply(Resource edge) { + return ONE; + } + }; + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Function1 constantOne(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + return ONE; + } + + private static Function1 directPropertyValueFunction(Resource property, double defaultValue) throws DatabaseException { + Double def = defaultValue; + return new FunctionImpl1() { + @Override + public Double apply(Resource edge) { + ReadGraph graph = (ReadGraph) SCLContext.getCurrent().get("graph"); + try { + Double d = graph.getPossibleRelatedValue(edge, property, Bindings.DOUBLE); + return d != null ? d : def; + } catch (DatabaseException e) { + LOGGER.error("Failed to evaluate property value", e); + return def; + } + } + }; + } + }