From: Jussi Koskela Date: Thu, 5 Sep 2019 11:41:27 +0000 (+0300) Subject: Support enumerated property types in UC interface (2nd try) X-Git-Tag: v1.43.0~136^2~78 X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=commitdiff_plain;h=3a25ce941361ea625bc07a427b0574fe5cb17180 Support enumerated property types in UC interface (2nd try) Other improvements: -Support labels in enumeration values -Sort enum values in edit combo alphanumerically (was hash order) Bugs fixed: -Instantiated values for IC properties were not converted properly on type edit if the UC was defined in linked index root gitlab #339 Change-Id: Ia452d0523a7a215181745870515cb74b8c838e90 --- diff --git a/bundles/org.simantics.browsing.ui.graph.impl/src/org/simantics/browsing/ui/graph/impl/EnumerationVariableModifier3.java b/bundles/org.simantics.browsing.ui.graph.impl/src/org/simantics/browsing/ui/graph/impl/EnumerationVariableModifier3.java index 32bd28c17..52b5012d7 100644 --- a/bundles/org.simantics.browsing.ui.graph.impl/src/org/simantics/browsing/ui/graph/impl/EnumerationVariableModifier3.java +++ b/bundles/org.simantics.browsing.ui.graph.impl/src/org/simantics/browsing/ui/graph/impl/EnumerationVariableModifier3.java @@ -13,10 +13,12 @@ package org.simantics.browsing.ui.graph.impl; import java.util.List; +import org.simantics.browsing.ui.common.modifiers.EnumerationValue; import org.simantics.browsing.ui.content.Labeler.EnumerationModifier; import org.simantics.databoard.Bindings; import org.simantics.db.ReadGraph; import org.simantics.db.RequestProcessor; +import org.simantics.db.Resource; import org.simantics.db.Session; import org.simantics.db.VirtualGraph; import org.simantics.db.WriteGraph; @@ -53,6 +55,10 @@ public class EnumerationVariableModifier3 implements EnumerationModifier { return processor.syncRequest(new Read() { @Override public String perform(ReadGraph graph) throws DatabaseException { + EnumerationValue ev = graph.syncRequest(new GetEnumerationValue(variable.getParent(graph).getRepresents(graph))); + if(ev != null) { + return ev.getEnumeratedValue().getName(); + } // System.err.println(variable.getURI(graph)); return variable.getValue(graph);//variable.getPossiblePropertyValue(graph, Variables.LABEL); } diff --git a/bundles/org.simantics.browsing.ui.graph.impl/src/org/simantics/browsing/ui/graph/impl/GetEnumerationValue.java b/bundles/org.simantics.browsing.ui.graph.impl/src/org/simantics/browsing/ui/graph/impl/GetEnumerationValue.java index c246e7bd9..0f9d119ac 100644 --- a/bundles/org.simantics.browsing.ui.graph.impl/src/org/simantics/browsing/ui/graph/impl/GetEnumerationValue.java +++ b/bundles/org.simantics.browsing.ui.graph.impl/src/org/simantics/browsing/ui/graph/impl/GetEnumerationValue.java @@ -42,6 +42,14 @@ public class GetEnumerationValue extends ResourceRead return enumerate(graph, resource); } + public static String getEnumerationValueName(ReadGraph graph, Resource resource) throws DatabaseException { + Layer0 L0 = Layer0.getInstance(graph); + String label = graph.getPossibleRelatedValue(resource, L0.HasLabel, Bindings.STRING); + if(label != null) + return label; + return safeName(graph, resource); + } + public static EnumerationValue enumerate(ReadGraph graph, Resource resource) throws DatabaseException { Layer0 l0 = Layer0.getInstance(graph); Set types = graph.getTypes(resource); @@ -61,7 +69,7 @@ public class GetEnumerationValue extends ResourceRead Collection values = graph.getObjects(type, l0.ConsistsOf); List> result = new ArrayList>(values.size()); for (Resource value : values) { - result.add(new EnumeratedValue(safeName(graph, value), value)); + result.add(new EnumeratedValue(getEnumerationValueName(graph, value), value)); } Enumeration enumeration = new Enumeration(result); return new EnumerationValue(enumeration, enumeration.find(resource)); diff --git a/bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/componentTypeEditor/ComponentTypeViewer.java b/bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/componentTypeEditor/ComponentTypeViewer.java index 75c60d24c..38f24b4f7 100644 --- a/bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/componentTypeEditor/ComponentTypeViewer.java +++ b/bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/componentTypeEditor/ComponentTypeViewer.java @@ -34,6 +34,7 @@ import org.osgi.framework.BundleContext; import org.osgi.framework.InvalidSyntaxException; import org.osgi.framework.ServiceReference; import org.simantics.Simantics; +import org.simantics.browsing.ui.graph.impl.GetEnumerationValue; import org.simantics.databoard.Bindings; import org.simantics.databoard.binding.Binding; import org.simantics.databoard.binding.error.BindingException; @@ -42,6 +43,7 @@ import org.simantics.databoard.type.NumberType; import org.simantics.db.ReadGraph; import org.simantics.db.Resource; import org.simantics.db.common.NamedResource; +import org.simantics.db.common.request.IsEnumeratedValue; import org.simantics.db.common.request.UniqueRead; import org.simantics.db.common.utils.NameUtils; import org.simantics.db.exception.DatabaseException; @@ -201,6 +203,8 @@ public class ComponentTypeViewer { expression = graph.getPossibleRelatedValue(assertion, L0.SCLValue_expression, Bindings.STRING); if(expression != null) { defaultValue = "=" + expression; //$NON-NLS-1$ + } else if (graph.sync(new IsEnumeratedValue(assertion))) { + defaultValue = GetEnumerationValue.getEnumerationValueName(graph, assertion); } else { Datatype dt = getPossibleDatatype(graph, assertion); if (dt == null) diff --git a/bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/componentTypeEditor/ComponentTypeViewerData.java b/bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/componentTypeEditor/ComponentTypeViewerData.java index ea10d6d8d..01c799d45 100644 --- a/bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/componentTypeEditor/ComponentTypeViewerData.java +++ b/bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/componentTypeEditor/ComponentTypeViewerData.java @@ -1,8 +1,11 @@ package org.simantics.modeling.ui.componentTypeEditor; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; +import java.util.HashSet; import java.util.List; +import java.util.Set; import java.util.concurrent.ScheduledFuture; import java.util.concurrent.TimeUnit; import java.util.regex.Matcher; @@ -33,6 +36,7 @@ import org.eclipse.swt.widgets.Text; import org.eclipse.ui.forms.widgets.Form; import org.eclipse.ui.forms.widgets.FormToolkit; import org.simantics.Simantics; +import org.simantics.databoard.Bindings; import org.simantics.databoard.type.NumberType; import org.simantics.databoard.units.internal.library.UnitLibrary; import org.simantics.databoard.util.Limit; @@ -40,15 +44,20 @@ import org.simantics.databoard.util.Range; import org.simantics.databoard.util.RangeException; import org.simantics.db.RequestProcessor; import org.simantics.db.Resource; +import org.simantics.db.Statement; import org.simantics.db.WriteGraph; import org.simantics.db.common.NamedResource; +import org.simantics.db.common.request.IndexRoot; import org.simantics.db.common.request.WriteRequest; import org.simantics.db.exception.DatabaseException; import org.simantics.db.function.DbConsumer; +import org.simantics.db.layer0.QueryIndexUtils; +import org.simantics.db.layer0.util.Layer0Utils; import org.simantics.layer0.Layer0; import org.simantics.modeling.userComponent.ComponentTypeCommands; import org.simantics.scl.runtime.function.Function2; import org.simantics.scl.runtime.function.Function4; +import org.simantics.utils.datastructures.Pair; import org.simantics.utils.threads.ThreadUtils; import org.simantics.utils.ui.ErrorLogger; @@ -246,12 +255,47 @@ public class ComponentTypeViewerData { if (propertyInfo.immutable) return; + Simantics.getSession().async(new WriteRequest() { @Override public void perform(WriteGraph graph) throws DatabaseException { graph.markUndoPoint(); - ComponentTypeCommands.editType(graph, componentType, propertyInfo.resource, convertDefaultValue, newValue); + + String newValue2 = newValue; + + Resource possibleGraphType = null; + Resource root = graph.syncRequest(new IndexRoot(componentType)); + + Resource L0Res = graph.getResource("http://www.simantics.org/Layer0-1.1"); + Layer0 L0 = Layer0.getInstance(graph); + + Collection graphTypes1 = QueryIndexUtils.searchByTypeAndName(graph, L0Res, L0.ValueType, newValue); + Collection graphTypes2 = QueryIndexUtils.searchByTypeAndName(graph, root, L0.ValueType, newValue); + + Collection graphTypes = new HashSet<>(graphTypes1); + graphTypes.addAll(graphTypes2); + + Set> candidates = new HashSet<>(); + for (Resource graphType : graphTypes) { + Collection stms = graph.getAssertedStatements(graphType, L0.HasValueType); + if(stms.size() == 1) { + // Only accept valueType if it asserts HasValueType with the same name + String hasValueType = graph.getValue(stms.iterator().next().getObject(), Bindings.STRING); + if (hasValueType.equals(newValue)) { + candidates.add(new Pair<>(graphType, hasValueType)); + } + } + } + + // We support only graph types with unique name at this point. Later we could implement UI to let the user to select from multiple graph types. + if (candidates.size() == 1) { + Pair result = candidates.iterator().next(); + possibleGraphType = result.first; + newValue2 = result.second; + } + + ComponentTypeCommands.editType(graph, componentType, propertyInfo.resource, convertDefaultValue, newValue2, possibleGraphType); if (range != null) ComponentTypeCommands.setRange(graph, componentType, propertyInfo.resource, range); } }); diff --git a/bundles/org.simantics.modeling/src/org/simantics/modeling/userComponent/ComponentTypeCommands.java b/bundles/org.simantics.modeling/src/org/simantics/modeling/userComponent/ComponentTypeCommands.java index 74ae599e3..9cf93fac5 100644 --- a/bundles/org.simantics.modeling/src/org/simantics/modeling/userComponent/ComponentTypeCommands.java +++ b/bundles/org.simantics.modeling/src/org/simantics/modeling/userComponent/ComponentTypeCommands.java @@ -11,6 +11,7 @@ *******************************************************************************/ package org.simantics.modeling.userComponent; +import java.util.Collections; import java.util.Map; import org.simantics.databoard.Bindings; @@ -27,11 +28,13 @@ import org.simantics.db.Resource; import org.simantics.db.Statement; import org.simantics.db.WriteGraph; import org.simantics.db.common.CommentMetadata; +import org.simantics.db.common.request.EnumerationMap; +import org.simantics.db.common.request.IsEnumeratedValue; import org.simantics.db.common.request.UnaryRead; import org.simantics.db.common.utils.NameUtils; import org.simantics.db.exception.DatabaseException; import org.simantics.db.exception.ServiceException; -import org.simantics.db.layer0.request.ModelInstances; +import org.simantics.db.layer0.QueryIndexUtils; import org.simantics.db.layer0.util.Layer0Utils; import org.simantics.layer0.Layer0; import org.simantics.modeling.ModelingResources; @@ -42,6 +45,7 @@ import org.simantics.scl.runtime.tuple.Tuple3; import org.simantics.selectionview.SelectionViewResources; import org.simantics.structural.stubs.StructuralResource2; import org.simantics.structural2.utils.StructuralUtils; +import org.simantics.utils.strings.AlphanumComparator; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -199,6 +203,11 @@ public class ComponentTypeCommands { public static void setRequiredType(WriteGraph g, Resource componentType, Resource property, String requiredType) throws DatabaseException { + setRequiredType(g, componentType, property, requiredType, null); + } + + public static void setRequiredType(WriteGraph g, Resource componentType, Resource property, + String requiredType, Resource possibleType) throws DatabaseException { Layer0 L0 = Layer0.getInstance(g); g.claimLiteral(property, L0.RequiresValueType, requiredType); @@ -211,17 +220,34 @@ public class ComponentTypeCommands { } } + // We assert the range of the property only if we are given a dedicated graph value type + if(g.hasStatement(property, L0.HasRange)) + g.deny(property, L0.HasRange); + + if(possibleType != null) { + // We have a dedicated graph type for this SCL value type + if(g.hasStatement(possibleType, L0.Enumeration)) { + // This value type is an enumeration - let's constrain the range of this predicate to match the enumeration type only + g.claim(property, L0.HasRange, possibleType); + } + } + CommentMetadata cm = g.getMetadata(CommentMetadata.class); g.addMetadata(cm.add("Set required type "+ requiredType + " for component/annotation " + property)); } public static void editType(WriteGraph graph, Resource componentType, Resource property, boolean convertDefaultValue, String newValue) throws DatabaseException { - ComponentTypeCommands.setRequiredType(graph, componentType, property, newValue); + editType(graph, componentType, property, convertDefaultValue, newValue, null); + } + + public static void editType(WriteGraph graph, Resource componentType, Resource property, boolean convertDefaultValue, String newValue, Resource possibleType) throws DatabaseException { + ComponentTypeCommands.setRequiredType(graph, componentType, property, newValue, possibleType); if (convertDefaultValue) { - ComponentTypeCommands.convertDefaultValue(graph, componentType, property, newValue); - Map instances = graph.sync(new ModelInstances(componentType, componentType)); - for(Resource instance : instances.values()) { - ComponentTypeCommands.convertInstantiatedValue(graph, instance, property, newValue); + ComponentTypeCommands.convertDefaultValue(graph, componentType, property, newValue, possibleType); + for (Resource indexRoot : Layer0Utils.listIndexRoots(graph)) { + for(Resource instance : QueryIndexUtils.searchByTypeShallow(graph, indexRoot, componentType)) { + ComponentTypeCommands.convertInstantiatedValue(graph, instance, property, newValue, componentType); + } } } } @@ -270,11 +296,29 @@ public class ComponentTypeCommands { " in " + NameUtils.getSafeName(g, type) + "."); return; } + + Layer0 L0 = Layer0.getInstance(g); + Resource range = g.getPossibleObject(relation, L0.HasRange); + if (range != null) { + if(g.hasStatement(range, L0.Enumeration)) { + Map values = g.syncRequest(new EnumerationMap(range)); + Resource value = values.get(valueText); + if (value != null) { + for(Resource assertion : g.getObjects(type, L0.Asserts)) { + Resource p = g.getSingleObject(assertion, L0.HasPredicate); + if (p.equals(relation)) { + g.deny(assertion, L0.HasObject, object); + g.claim(assertion, L0.HasObject, value); + } + } + } + return; + } + } if(valueText.length() > 0 && valueText.charAt(0) == '=') { String expression = valueText.substring(1); - Layer0 L0 = Layer0.getInstance(g); ModelingResources MOD = ModelingResources.getInstance(g); if(!g.isInstanceOf(object, MOD.SCLValue)) { Resource assertion = g.getSingleObject(object, L0.HasObjectInverse); @@ -288,7 +332,6 @@ public class ComponentTypeCommands { } else { - Layer0 L0 = Layer0.getInstance(g); ModelingResources MOD = ModelingResources.getInstance(g); if(g.isInstanceOf(object, MOD.SCLValue)) { Resource assertion = g.getSingleObject(object, L0.HasObjectInverse); @@ -421,6 +464,22 @@ public class ComponentTypeCommands { public static void convertDefaultValue(WriteGraph g, Resource type, Resource relation, String newSCLType) throws DatabaseException { + convertDefaultValue(g, type, relation, newSCLType, null); + } + + private static Resource findAssertionWithPO(ReadGraph graph, Resource possibleType, Resource predicate, Resource object) throws DatabaseException { + Layer0 L0 = Layer0.getInstance(graph); + for(Resource assertion : graph.getObjects(possibleType, L0.Asserts)) { + Resource p = graph.getSingleObject(assertion, L0.HasPredicate); + Resource o = graph.getSingleObject(assertion, L0.HasObject); + if(predicate.equals(p) && object.equals(o)) + return assertion; + } + return null; + } + + public static void convertDefaultValue(WriteGraph g, + Resource type, Resource relation, String newSCLType, Resource possibleType) throws DatabaseException { Resource object = getAssertedObject(g, type, relation); if(object == null) { LOGGER.warn("Didn't find assertion for " + NameUtils.getSafeName(g, relation) + @@ -428,27 +487,72 @@ public class ComponentTypeCommands { return; } + Layer0 L0 = Layer0.getInstance(g); + if(possibleType != null) { + if(g.hasStatement(possibleType, L0.Enumeration)) { + if(!g.isInstanceOf(object, possibleType)) { + Map enumMap = g.syncRequest(new EnumerationMap(possibleType)); + String firstKey = Collections.min(enumMap.keySet(), AlphanumComparator.COMPARATOR); + Resource defaultValue = enumMap.get(firstKey); + + if (defaultValue != null) { + Resource assertion = findAssertionWithPO(g, type, relation, object); + if(assertion != null) { + g.deny(assertion, L0.HasObject); + g.claim(assertion, L0.HasObject, defaultValue); + return; + } else { + Layer0Utils.assert_(g, type, relation, defaultValue); + return; + } + } + } else { + return; + } + } + } + Tuple tuple = getDatatypeValueAndBinding(g, object, newSCLType); if (tuple == null) return; - Layer0 L0 = Layer0.getInstance(g); + if(g.sync(new IsEnumeratedValue(object))) { + Resource assertion = findAssertionWithPO(g, type, relation, object); + object = g.newResource(); + g.claim(object, L0.InstanceOf, L0.Literal); + if(assertion != null) { + g.deny(assertion, L0.HasObject); + g.claim(assertion, L0.HasObject, object); + } + } + g.claimLiteral(object, L0.HasDataType, L0.DataType, tuple.get(0), Bindings.getBindingUnchecked(Datatype.class)); g.claimLiteral(object, L0.HasValueType, g.getRelatedValue(relation, L0.RequiresValueType, Bindings.STRING), Bindings.STRING); g.claimValue(object, tuple.get(1), (Binding)tuple.get(2)); } - public static void convertInstantiatedValue(WriteGraph g, Resource instance, Resource relation, String newSCLType) + public static void convertInstantiatedValue(WriteGraph g, Resource instance, Resource relation, String newSCLType) throws DatabaseException { + convertInstantiatedValue(g, instance, relation, newSCLType, null); + } + + public static void convertInstantiatedValue(WriteGraph g, Resource instance, Resource relation, String newSCLType, Resource possibleType) throws DatabaseException { Statement stm = g.getPossibleStatement(instance, relation); if(stm != null && !stm.isAsserted(instance)) { + Layer0 L0 = Layer0.getInstance(g); Resource object = stm.getObject(); + if(g.sync(new IsEnumeratedValue(object))) { + if(!g.isInstanceOf(object, possibleType)) { + g.deny(instance, relation); + } + return; + } + // We can only convert literals - Layer0 L0 = Layer0.getInstance(g); if(!g.isInstanceOf(object, L0.Literal)) return; Tuple tuple = getDatatypeValueAndBinding(g, object, newSCLType); diff --git a/bundles/org.simantics.selectionview/src/org/simantics/selectionview/function/All.java b/bundles/org.simantics.selectionview/src/org/simantics/selectionview/function/All.java index 79541b061..d26d86682 100644 --- a/bundles/org.simantics.selectionview/src/org/simantics/selectionview/function/All.java +++ b/bundles/org.simantics.selectionview/src/org/simantics/selectionview/function/All.java @@ -2,6 +2,7 @@ package org.simantics.selectionview.function; import java.io.IOException; import java.util.ArrayList; +import java.util.Collections; import java.util.Map; import java.util.function.Consumer; @@ -13,6 +14,7 @@ import org.eclipse.swt.widgets.FontDialog; import org.simantics.Simantics; import org.simantics.browsing.ui.NodeContext; import org.simantics.browsing.ui.content.Labeler.DialogModifier; +import org.simantics.browsing.ui.graph.impl.GetEnumerationValue; import org.simantics.common.format.Formatter; import org.simantics.databoard.Bindings; import org.simantics.databoard.Datatypes; @@ -62,6 +64,7 @@ import org.simantics.ui.fonts.Fonts; import org.simantics.ui.selection.WorkbenchSelectionElement; import org.simantics.ui.selection.WorkbenchSelectionUtils; import org.simantics.utils.datastructures.collections.CollectionUtils; +import org.simantics.utils.strings.AlphanumComparator; import org.simantics.utils.ui.AdaptionUtils; import org.simantics.utils.ui.ErrorLogger; import org.simantics.utils.ui.ISelectionUtils; @@ -198,7 +201,9 @@ public class All { Resource parameterResource = parameter.getRepresents(graph); if(graph.sync(new IsEnumeratedValue(parameterResource))) { Map map = graph.sync(new InstanceEnumerationMap(parameterResource)); - return new ArrayList(map.keySet()); + ArrayList values = new ArrayList<>(map.keySet()); + Collections.sort(values, AlphanumComparator.COMPARATOR); + return values; } else if(graph.isInstanceOf(parameterResource, L0.Boolean)) { return CollectionUtils.toList("true", "false"); } @@ -463,6 +468,14 @@ public class All { value = formatterFunction.apply(property.getValue(graph)); } } + + Resource possibleValue = context.getParent(graph).getPossibleRepresents(graph); + if(possibleValue != null) { + if(graph.syncRequest(new IsEnumeratedValue(possibleValue))) { + return GetEnumerationValue.getEnumerationValueName(graph, possibleValue); + } + } + if(value == null) { Variant variant = property.getVariantValue(graph); @@ -518,8 +531,14 @@ public class All { String parsedLabel = (String)_value; Object value = parsedLabel; + boolean isEnumeration = false; + Resource possibleValue = context.getParent(graph).getPossibleRepresents(graph); + if(possibleValue != null) { + isEnumeration = graph.syncRequest(new IsEnumeratedValue(possibleValue)); + } + Datatype type = context.getParent(graph).getPossibleDatatype(graph); - if (type != null) { + if (type != null && !isEnumeration) { Binding binding = Bindings.getBinding(type);