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;
return processor.syncRequest(new Read<String>() {
@Override
public String perform(ReadGraph graph) throws DatabaseException {
+ EnumerationValue<Resource> 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);
}
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<Resource> enumerate(ReadGraph graph, Resource resource) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
Set<Resource> types = graph.getTypes(resource);
Collection<Resource> values = graph.getObjects(type, l0.ConsistsOf);
List<EnumeratedValue<Resource>> result = new ArrayList<EnumeratedValue<Resource>>(values.size());
for (Resource value : values) {
- result.add(new EnumeratedValue<Resource>(safeName(graph, value), value));
+ result.add(new EnumeratedValue<Resource>(getEnumerationValueName(graph, value), value));
}
Enumeration<Resource> enumeration = new Enumeration<Resource>(result);
return new EnumerationValue<Resource>(enumeration, enumeration.find(resource));
public class QueryCache extends QueryCacheBase {
- private static final boolean SINGLE = false;
+ private static final boolean SINGLE = true;
public QueryCache(QuerySupport querySupport, int threads) {
super(querySupport, threads);
id="tspan6235"
x="4.0821486"
y="291.79337"
- style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:5.64444447px;font-family:'The Real Font';-inkscape-font-specification:'The Real Font';fill:#ffffff;fill-opacity:1;stroke-width:0.26458335px">1.40.0</tspan></text>
+ style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:5.64444447px;font-family:'The Real Font';-inkscape-font-specification:'The Real Font';fill:#ffffff;fill-opacity:1;stroke-width:0.26458335px">1.41.0</tspan></text>
<circle
style="opacity:0.92900002;fill:#5d6b91;fill-opacity:1;stroke:none;stroke-width:1.27400005;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;filter:url(#filter6809)"
id="path6231"
*******************************************************************************/
package org.simantics.diagram.connection;
-import gnu.trove.list.array.TDoubleArrayList;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-
import java.awt.geom.Line2D;
import java.awt.geom.Path2D;
+import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.io.PrintStream;
import java.io.Serializable;
import org.simantics.diagram.connection.segments.Segment;
import org.simantics.diagram.connection.splitting.SplittedRouteGraph;
+import gnu.trove.list.array.TDoubleArrayList;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+
public class RouteGraph implements Serializable {
private static final long serialVersionUID = 2004022454972623908L;
routeLine.collectSegments(segments);
return segments;
}
+
+ public Segment findNearestSegment(double x, double y) {
+ Segment nearest = null;
+ double minDistanceSq = Double.MAX_VALUE;
+
+ for (Segment segment : getSegments()) {
+ RoutePoint p1 = segment.p1;
+ RoutePoint p2 = segment.p2;
+
+ double distanceSq = Line2D.ptSegDistSq(p1.x, p1.y, p2.x, p2.y, x, y);
+ if (distanceSq < minDistanceSq) {
+ minDistanceSq = distanceSq;
+ nearest = segment;
+ }
+ }
+ return nearest;
+ }
+
+ public Point2D findNearestPoint(double x, double y) {
+ Segment nearest = findNearestSegment(x, y);
+ if (nearest == null) return null;
+
+ RoutePoint p1 = nearest.p1;
+ RoutePoint p2 = nearest.p2;
+
+ double d = Math.pow(p2.x - p1.x, 2.0) + Math.pow(p2.y - p1.y, 2.0);
+
+ if (d == 0) {
+ return new Point2D.Double(p1.x, p1.y);
+ } else {
+ double u = ((x - p1.x) * (p2.x - p1.x) + (y - p1.y) * (p2.y - p1.y)) / d;
+ if (u > 1.0) {
+ return new Point2D.Double(p2.x, p2.y);
+ } else if (u <= 0.0) {
+ return new Point2D.Double(p1.x, p1.y);
+ } else {
+ return new Point2D.Double(p2.x * u + p1.x * (1.0-u), (p2.y * u + p1.y * (1.0- u)));
+ }
+ }
+ }
public Path2D getPath2D() {
Path2D result = new Path2D.Double();
result.addAll(graph.syncRequest(new AllModelIssues(model, false)));
}
- List<Resource> libraries = SCLFunctions.evaluateDB("Simantics/SharedOntologies", "getSharedOntologies", Tuple0.INSTANCE);
+ List<Resource> libraries = SCLFunctions.evaluateGraph("Simantics/SharedOntologies", "getSharedOntologies", graph, Tuple0.INSTANCE);
for (Resource library : libraries) {
result.addAll(graph.syncRequest(new AllModelIssues(library, false)));
public static void run() throws DatabaseException {
Resource model = Simantics.getSession().syncRequest(new PossibleActiveModel(Simantics.getProjectResource()));
if(model != null)
- run(null);
+ run(model);
}
public static void run(Resource model) {
VP.ActionContribution.HasNodeType SIMU.Model
VP.ActionContribution.HasAction ACTIONS.ActivateModel
+MOD.Contributions.ActivateExperiment : VP.ActionContribution
+ L0.HasLabel "Activate"
+ VP.ActionContribution.HasImage SILK.bullet_go
+ VP.ActionContribution.HasCategory VP.EditActionCategory
+ VP.ActionContribution.HasNodeType SIMU.Experiment
+ VP.ActionContribution.HasAction ACTIONS.ActivateExperiment
+
MOD.Contributions.Help : VP.ActionContribution
L0.HasLabel "Help"
VP.ActionContribution.HasImage SILK.help
@MOD.sclAction "createSpreadsheetBookAction"
ACTIONS.ActivateModel
@MOD.sclAction "activateModelAction"
+ACTIONS.ActivateExperiment
+ @MOD.sclAction "activateExperimentAction"
ACTIONS.MigrateComponentType : ACT.Action
ACTIONS.CompilePGraphs : ACT.Action
//ACTIONS.MigrateMasterTypical : ACT.Action
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;
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;
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)
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;
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;
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;
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<Resource> graphTypes1 = QueryIndexUtils.searchByTypeAndName(graph, L0Res, L0.ValueType, newValue);
+ Collection<Resource> graphTypes2 = QueryIndexUtils.searchByTypeAndName(graph, root, L0.ValueType, newValue);
+
+ Collection<Resource> graphTypes = new HashSet<>(graphTypes1);
+ graphTypes.addAll(graphTypes2);
+
+ Set<Pair<Resource, String>> candidates = new HashSet<>();
+ for (Resource graphType : graphTypes) {
+ Collection<Statement> 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<Resource, String> 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);
}
});
package org.simantics.modeling.ui.diagram.style;
import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Collections;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.layer0.variable.Variable;
import org.simantics.db.layer0.variable.Variables;
+import org.simantics.diagram.connection.RouteGraph;
import org.simantics.diagram.elements.DecorationSVGNode;
import org.simantics.diagram.elements.SVGNode;
+import org.simantics.diagram.handler.Paster;
+import org.simantics.diagram.handler.Paster.RouteLine;
import org.simantics.diagram.profile.StyleBase;
+import org.simantics.diagram.stubs.DiagramResource;
import org.simantics.diagram.synchronization.graph.DiagramGraphUtil;
import org.simantics.issues.Severity;
import org.simantics.issues.common.IssueResourcesContexts;
import org.simantics.modeling.ui.Activator;
import org.simantics.modeling.ui.diagram.style.IssueDecorationStyle.IssueResult;
import org.simantics.scenegraph.INode;
+import org.simantics.scenegraph.g2d.nodes.ConnectionNode;
import org.simantics.scenegraph.g2d.nodes.Decoration;
+import org.simantics.scenegraph.g2d.nodes.connection.RouteGraphNode;
import org.simantics.scenegraph.profile.EvaluationContext;
import org.simantics.scenegraph.profile.common.ProfileVariables;
import org.simantics.scenegraph.utils.NodeUtil;
+import org.simantics.structural.stubs.StructuralResource2;
import org.simantics.utils.datastructures.map.Tuple;
return null;
List<Resource> contexts = getContexts(graph, element);
- AffineTransform transform = DiagramGraphUtil.getAffineTransform(graph, element);
Map<Severity, List<Resource>> issuesBySeverity = graph.syncRequest(new ListModelIssuesBySeverity(model, true, true, Severity.NOTE),
TransientCacheListener.<Map<Severity, List<Resource>>>instance());
List<Resource> issues = issuesBySeverity.get(severity);
if (issues != null) {
Set<Resource> issueContexts = graph.syncRequest(new IssueResourcesContexts(issues));
- if (!Collections.disjoint(issueContexts, contexts))
- return new IssueResult(severity, transform);
+ if (!Collections.disjoint(issueContexts, contexts)) {
+ return new IssueResult(severity, getIdentifier(graph, runtimeDiagram, element));
+ }
}
}
return null;
}
+ private static Object getIdentifier(ReadGraph graph, Resource runtimeDiagram, Resource element) throws DatabaseException {
+ DiagramResource DIA = DiagramResource.getInstance(graph);
+ StructuralResource2 STR = StructuralResource2.getInstance(graph);
+ if (graph.isInstanceOf(element, DIA.RouteGraphConnection)) {
+ Collection<Resource> connectors = graph.getObjects(element, DIA.HasConnector);
+ Collection<Resource> routeNodes = graph.getObjects(element, DIA.HasInteriorRouteNode);
+
+ // This is needed to make this query result change every time the underlying element changes visually.
+ Set<Object> identifier = new HashSet<Object>(connectors.size() + routeNodes.size());
+
+ for (Resource connector : connectors) {
+ for (Resource connectedTo : graph.getObjects(connector, STR.Connects)) {
+ if (!connectedTo.equals(element)) {
+ AffineTransform at = DiagramGraphUtil.getDynamicAffineTransform(graph, runtimeDiagram, connectedTo, DIA.HasDynamicTransform, false);
+ identifier.add(at);
+ }
+ }
+ }
+ for (Resource routeLine : routeNodes) {
+ RouteLine rl = Paster.readRouteLine(graph, routeLine);
+ identifier.add(rl);
+ }
+ return identifier;
+ } else {
+ return DiagramGraphUtil.getAffineTransform(graph, element);
+ }
+ }
+
@Override
public void applyStyleForNode(EvaluationContext observer, INode node, IssueResult result) {
if (result == null) {
protected AffineTransform getDecorationPosition(INode node) {
Rectangle2D bounds = NodeUtil.getLocalBounds(node, Decoration.class);
+ if (node instanceof ConnectionNode) {
+ for (INode child : ((ConnectionNode)node).getSortedNodes()) {
+ if (child instanceof RouteGraphNode) {
+ RouteGraphNode rgn = (RouteGraphNode) child;
+ RouteGraph rg = rgn.getRouteGraph();
+ Point2D nearest = rg.findNearestPoint(bounds.getCenterX(), bounds.getCenterY());
+ if (nearest != null) {
+ return AffineTransform.getTranslateInstance(nearest.getX(), nearest.getY());
+ }
+ }
+ }
+ }
double tx = bounds.getX();
double ty = bounds.getY();
return AffineTransform.getTranslateInstance(tx, ty);
* element moves.
*/
public static class IssueResult extends Tuple {
- public IssueResult(Severity severity, AffineTransform transform) {
- super(severity, transform);
+ public IssueResult(Severity severity, Object identifier) {
+ super(severity, identifier);
}
public Severity getSeverity() {
return (Severity) getField(0);
super(Messages.OpenDiagramFromComponentAdapter_OpenDiagramContainingComponent, Activator.SYMBOL_ICON);
}
+ protected String getEditorId(ReadGraph g, Resource diagram) throws DatabaseException {
+ ModelingResources MOD = ModelingResources.getInstance(g);
+ String preferredEditorId = g.getPossibleRelatedValue(diagram, MOD.PreferredDiagramEditorID);
+ if(preferredEditorId != null)
+ return preferredEditorId;
+ else
+ return EDITOR_ID;
+ }
+
@Override
public boolean canHandle(ReadGraph graph, Object input) throws DatabaseException {
Pair<Resource, String> p = tryGetResource(graph, input);
Resource composite = g.getSingleObject(component, l0.PartOf);
Resource diagram = ComponentUtils.getPossibleCompositeDiagram(g, composite);
+ String editorId = getEditorId(g, composite);
+
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(getClass().getSimpleName() + ".findDiagram: component: " + NameUtils.getURIOrSafeNameInternal(g, component)); //$NON-NLS-1$
LOGGER.debug(getClass().getSimpleName() + ".findDiagram: composite: " + NameUtils.getURIOrSafeNameInternal(g, composite)); //$NON-NLS-1$
// Prevent diagram from opening if there's nothing to select
// on the diagram based on the received input.
if (!selectedObjects.isEmpty())
- result.add( NavigateToTarget.editorActivator(EDITOR_ID, diagram, indexRoot, rvi, editorActivationCallback(selectedObjects)) );
+ result.add( NavigateToTarget.editorActivator(editorId, diagram, indexRoot, rvi, editorActivationCallback(selectedObjects)) );
} else {
final MapSet<NamedResource, Resource> referencingDiagrams = listReferenceDiagrams(g, referenceElements);
final Set<NamedResource> diagrams = referencingDiagrams.getKeys();
RVI rvi = getDiagramCompositeRvi(g, singleDiagram.getResource());
if (rvi != null) {
Collection<Resource> selectedObjects = referencingDiagrams.getValues(singleDiagram);
- result.add( NavigateToTarget.editorActivator(EDITOR_ID, singleDiagram.getResource(), indexRoot, rvi, editorActivationCallback(selectedObjects)) );
+ result.add( NavigateToTarget.editorActivator(editorId, singleDiagram.getResource(), indexRoot, rvi, editorActivationCallback(selectedObjects)) );
}
break;
if (selected != null) {
Collection<Resource> selectedObjects = referencingDiagrams.getValues(selected);
RVI drvi = diagramToRvi.get(selected);
- NavigateToTarget.editorActivator(EDITOR_ID, selected.getResource(), indexRoot, drvi, editorActivationCallback(selectedObjects)).run();
+ NavigateToTarget.editorActivator(editorId, selected.getResource(), indexRoot, drvi, editorActivationCallback(selectedObjects)).run();
}
});
break;
createExperimentRun :: Resource -> <WriteGraph> Resource
createExperimentRunWithType :: Resource -> Resource -> <WriteGraph> Resource
activateRun :: Resource -> <WriteGraph> ()
+
+activateExperimentAction :: Resource -> <Proc> ()
+activateExperimentAction experiment = do
+ syncWrite (\() -> activateExperiment experiment)
+ ()
importJava "org.simantics.simulation.experiment.IExperiment" where
data IExperiment
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
+import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class SCLScenegraph {
} else if (!(node instanceof RouteGraphNode) && !(node instanceof LinkNode)){
try {
Element doc = renderSVGNode(svgGenerator, (IG2DNode)node);
- if (doc.getElementsByTagName("g").getLength() == 0)
+ NodeList gList = doc.getElementsByTagName("g");
+ if (gList.getLength() == 0)
return;
+ boolean hasContent = false;
+ for (int i = 0; i < gList.getLength(); i++) {
+ Node gNode = gList.item(i);
+ if (gNode.hasChildNodes()) {
+ hasContent = true;
+ break;
+ }
+ }
+ if (!hasContent)
+ return;
String svg = printSVGDocument(doc);
- parentBuilder.append(MAIN_SECTION, "<g>");
+ parentBuilder.append(MAIN_SECTION, "<g class=\"" +node.getSimpleClassName() +"\">");
parentBuilder.append(MAIN_SECTION, svg);
parentBuilder.append(MAIN_SECTION, "\n</g>");
} catch (Exception e) {
// This is a lifted flag in a structural configuration.
mappedConnectionPoints.add(new CPTerminal(terminal.component, isLiftedAs));
} else {
- // Do nothing, because the flag is not connected
+ mappedConnectionPoints.add(terminal);
}
}
} else if (cp instanceof CPConnection) {
*******************************************************************************/
package org.simantics.modeling.userComponent;
+import java.util.Collections;
import java.util.Map;
import org.simantics.databoard.Bindings;
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;
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;
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);
}
}
+ // 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<String, Resource> 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);
+ }
}
}
}
" 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<String,Resource> 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);
} else {
- Layer0 L0 = Layer0.getInstance(g);
ModelingResources MOD = ModelingResources.getInstance(g);
if(g.isInstanceOf(object, MOD.SCLValue)) {
Resource assertion = g.getSingleObject(object, L0.HasObjectInverse);
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) +
return;
}
+ Layer0 L0 = Layer0.getInstance(g);
+ if(possibleType != null) {
+ if(g.hasStatement(possibleType, L0.Enumeration)) {
+ if(!g.isInstanceOf(object, possibleType)) {
+ Map<String, Resource> 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.<String>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);
return true;
else if (object == null)
return false;
- else if (ObserverGroupListener.class != object.getClass())
+ else if (getClass() != object.getClass())
return false;
ObserverGroupListener other = (ObserverGroupListener)object;
return observer.equals(other.observer) && group.equals(other.group) && style.equals(other.style);
}
private static <T> T evaluate(RuntimeModule rm, String function, Object ... args) throws ValueNotFound {
- return evaluate(resolveFunction(rm, function));
+ return evaluate(resolveFunction(rm, function), args);
}
public static <T> T evaluate(String module, String function, Object ... args) throws ValueNotFound {
}
}
- public static <T> T evaluateGraph(String module, String function, Object graph, Object ... args) throws DatabaseException {
+ public static <T> T evaluateGraph(String module, String function, ReadGraph graph, Object ... args) throws DatabaseException {
final SCLContext context = SCLContext.getCurrent();
SCLContext.push(context);
Object oldGraph = context.put(GRAPH, graph);
}
}
- public static void runWithGraph(Object graph, Runnable r) {
+ public static void runWithGraph(ReadGraph graph, Runnable r) {
final SCLContext context = SCLContext.getCurrent();
SCLContext.push(context);
Object oldGraph = context.put(GRAPH, graph);
import java.io.IOException;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.Map;
import java.util.function.Consumer;
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;
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;
Resource parameterResource = parameter.getRepresents(graph);
if(graph.sync(new IsEnumeratedValue(parameterResource))) {
Map<String, Resource> map = graph.sync(new InstanceEnumerationMap(parameterResource));
- return new ArrayList<String>(map.keySet());
+ ArrayList<String> values = new ArrayList<>(map.keySet());
+ Collections.sort(values, AlphanumComparator.COMPARATOR);
+ return values;
} else if(graph.isInstanceOf(parameterResource, L0.Boolean)) {
return CollectionUtils.toList("true", "false");
}
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);
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);
<feature
id="org.simantics.sdk"
label="Simantics SDK"
- version="1.40.0.qualifier"
+ version="1.41.0.qualifier"
provider-name="VTT Technical Research Centre of Finland">
<description url="http://www.example.com/description">
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?pde?>
<!-- generated with https://github.com/mbarbero/fr.obeo.releng.targetplatform -->
-<target name="Simantics 1.40.0" sequenceNumber="1560983842">
+<target name="Simantics 1.41.0" sequenceNumber="1560983842">
<locations>
<location includeMode="slicer" includeAllPlatforms="true" includeSource="true" includeConfigurePhase="false" type="InstallableUnit">
<unit id="com.google.guava" version="21.0.0.v20170206-1425"/>
-target "Simantics 1.40.0"
+target "Simantics 1.41.0"
with source allEnvironments
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<artifactId>org.simantics.sdk.repository</artifactId>
- <version>1.40.0-SNAPSHOT</version>
+ <version>1.41.0-SNAPSHOT</version>
<packaging>eclipse-repository</packaging>
<parent>