X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.diagram%2Fsrc%2Forg%2Fsimantics%2Fdiagram%2Ffunction%2FPredefinedVariables.java;fp=bundles%2Forg.simantics.diagram%2Fsrc%2Forg%2Fsimantics%2Fdiagram%2Ffunction%2FPredefinedVariables.java;h=d3eafc2bd9c1f1f8d69c9dd44421c484316ca734;hp=0000000000000000000000000000000000000000;hb=969bd23cab98a79ca9101af33334000879fb60c5;hpb=866dba5cd5a3929bbeae85991796acb212338a08 diff --git a/bundles/org.simantics.diagram/src/org/simantics/diagram/function/PredefinedVariables.java b/bundles/org.simantics.diagram/src/org/simantics/diagram/function/PredefinedVariables.java new file mode 100644 index 000000000..d3eafc2bd --- /dev/null +++ b/bundles/org.simantics.diagram/src/org/simantics/diagram/function/PredefinedVariables.java @@ -0,0 +1,361 @@ +package org.simantics.diagram.function; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Set; + +import org.simantics.annotation.ontology.AnnotationResource; +import org.simantics.db.ReadGraph; +import org.simantics.db.Resource; +import org.simantics.db.exception.DatabaseException; +import org.simantics.db.layer0.variable.Variable; +import org.simantics.db.layer0.variable.Variables; +import org.simantics.diagram.content.ConnectionUtil; +import org.simantics.diagram.flag.FlagUtil; +import org.simantics.diagram.stubs.DiagramResource; +import org.simantics.layer0.Layer0; +import org.simantics.modeling.ModelingResources; +import org.simantics.modeling.template2d.ontology.Template2dResource; +import org.simantics.structural.stubs.StructuralResource2; +import org.simantics.ui.SimanticsUI; + +public class PredefinedVariables { + public static final String root = "root"; + public static final String project = "project"; + public static final String model = "model"; + public static final String template = "template"; + public static final String current = "."; + public static final String diagramComposite = "diagramComposite"; + public static final String diagram = "diagram"; + public static final String flagAnnotation = "annotation"; + + /** + * flagSourceObject refers to a structural component which has an element on the flag's diagram + */ + public static final String flagSourceObject = "flagSourceObject"; + + /** + * flagTargetObject refers to a structural component which has an element on the counterpart flag's diagram + */ + public static final String flagTargetObject = "flagTargetObject"; + + /** + * flagSourceComposite refers to a structural composite which corresponds the flag's diagram + */ + public static final String flagSourceComposite = "flagSourceComposite"; + + /** + * flagTargetComposite refers to a structural composite which corresponds the counterpart flag's diagram + */ + public static final String flagTargetComposite = "flagTargetComposite"; + + /** + * flagRouterComponent refers to a structural component which corresponds a graphical connection connected with the flag + */ + public static final String flagRouterComponent = "flagRouterComponent"; + + private static PredefinedVariables factory = new PredefinedVariables(); + + public static PredefinedVariables getInstance(){ + return factory; + } + + public static void setFactory(PredefinedVariables factory){ + PredefinedVariables.factory = factory; + } + + Resource connectedComponent = null; + + private Resource getConnectedComponent(ReadGraph graph, Resource flag) throws DatabaseException { + StructuralResource2 STR = StructuralResource2.getInstance(graph); + ModelingResources MOD = ModelingResources.getInstance(graph); + ConnectionUtil cu = new ConnectionUtil(graph); + Resource connectedComponent = null; + Set connectors = new HashSet(); + for (Resource connector : graph.getObjects(flag, STR.IsConnectedTo)) { + Resource diagramConnection = ConnectionUtil.tryGetConnection(graph, connector); + if (diagramConnection != null) { + connectors.clear(); + cu.getConnectors(diagramConnection, connectors); + connectors.remove(connector); + if (connectors.isEmpty()) { + continue; + } else { + //connectedComponent = graph.getPossibleObject(diagramConnection, MOD.ElementToComponent); + if (connectedComponent == null) { + for (Resource conn : connectors) { + Resource element = cu.getConnectedComponent(diagramConnection, conn); + if (element == null) + continue; + connectedComponent = graph.getPossibleObject(element, MOD.ElementToComponent); + if (connectedComponent != null) + break; + } + } + } + } + } + return connectedComponent; + } + + public Resource getFlagRouterComponent(ReadGraph graph, Variable variable) throws DatabaseException { + Resource flag = variable.getPossibleRepresents(graph); + return flag == null ? null : getFlagRouterComponent(graph, flag); + } + + public Resource getFlagRouterComponent(ReadGraph graph, Resource flag) throws DatabaseException { + + Layer0 L0 = Layer0.getInstance(graph); + ModelingResources MOD = ModelingResources.getInstance(graph); + + Resource container = graph.getSingleObject(flag, L0.PartOf); + Resource composite = graph.getSingleObject(container, MOD.DiagramToComposite); + Variable var = Variables.getVariable(graph, composite); + +// System.err.println("var: " + var.getURI(graph)); + + Variable result = FlagUtil.getPossibleFlagSignal(graph, var, flag, L0.Entity); + if(result != null) return result.getRepresents(graph); + else return null; + + } + + private Resource getFlagTargetObject(ReadGraph graph, Variable variable){ + try { + Resource flag = variable.getRepresents(graph); + Set targetFlags = FlagUtil.getCounterparts(graph, flag); + + // if there are multiple targets + if (targetFlags.size() != 1) + return null; + + Resource targetFlag = targetFlags.toArray(new Resource[0])[0]; + if (targetFlag == null) + return null; + Resource connectedComponent = getConnectedComponent(graph, targetFlag); + if (connectedComponent == null) + return null; + return connectedComponent; + } catch (DatabaseException e) { + } + return null; + } + + private Resource getFlagSourceObject(ReadGraph graph, Variable variable){ + try { + Resource flag = variable.getRepresents(graph); + Resource connectedComponent = getConnectedComponent(graph, flag); + if (connectedComponent == null) + return null; + return connectedComponent; + } catch (DatabaseException e) { + } + return null; + } + + private Resource getFlagSourceComposite(ReadGraph graph, Variable variable){ + try { + Layer0 L0 = Layer0.getInstance(graph); + ModelingResources MOD = ModelingResources.getInstance(graph); + + Resource flag = variable.getRepresents(graph); + Resource diagram = graph.getPossibleObject(flag, L0.PartOf); + if (diagram == null) + return null; + Resource composite = graph.getPossibleObject(diagram, MOD.DiagramToComposite); + if (composite == null) + return null; + return composite; + } catch (DatabaseException e) { + } + return null; + } + + private Resource getFlagTargetComposite(ReadGraph graph, Variable variable){ + try { + Layer0 L0 = Layer0.getInstance(graph); + ModelingResources MOD = ModelingResources.getInstance(graph); + + Resource flag = variable.getRepresents(graph); + Set targetFlags = FlagUtil.getCounterparts(graph, flag); + + // if there are multiple targets + if (targetFlags.size() != 1) + return null; + + Resource targetFlag = targetFlags.toArray(new Resource[0])[0]; + if (targetFlag == null) + return null; + Resource diagram = graph.getPossibleObject(targetFlag, L0.PartOf); + if (diagram == null) + return null; + Resource composite = graph.getPossibleObject(diagram, MOD.DiagramToComposite); + if (composite == null) + return null; + return composite; + } catch (DatabaseException e) { + } + return null; + } + + public static Resource getAnnotation(ReadGraph graph, Resource res) throws DatabaseException { + Layer0 L0 = Layer0.getInstance(graph); + Collection children = graph.getObjects(res, L0.ConsistsOf); + Resource anno = null; + AnnotationResource ANNO = AnnotationResource.getInstance(graph); + for (Resource child:children){ + if (graph.isInstanceOf(child, ANNO.Annotation)){ + anno = child; + break; + } + } + return anno; + } + + private Resource getDiagramComposite(ReadGraph graph, Variable variable){ + try { + Resource res = variable.getRepresents(graph); + if (res == null) + return null; + DiagramResource DIA = DiagramResource.getInstance(graph); + if (graph.isInstanceOf(res, DIA.Flag)){ + ModelingResources MOD = ModelingResources.getInstance(graph); + Layer0 L0 = Layer0.getInstance(graph); + Resource parent = graph.getPossibleObject(res, L0.PartOf); + if (parent == null) + return null; + if (!graph.isInstanceOf(parent, DIA.Diagram)) + return null; + return graph.getPossibleObject(parent, MOD.DiagramToComposite); + } + return res; + } catch (DatabaseException e) { + } + return null; + } + + public Resource getPredefinedResource(ReadGraph graph, Variable selection, String id) throws DatabaseException { + Resource predefined = null; + if (id.equals(root)) + predefined = graph.getRootLibrary(); + else if (id.equals(project)) + predefined = SimanticsUI.getProject().get(); + else if (id.equals(model)) + predefined = Variables.getPossibleModel(graph, selection); + else if (id.equals(template)){ + Resource composite = selection.getRepresents(graph); + if (composite == null) + return null; + ModelingResources MOD = ModelingResources.getInstance(graph); + Template2dResource TEPLATE2D = Template2dResource.getInstance(graph); + Resource diagram = graph.getPossibleObject(composite, MOD.CompositeToDiagram); + if (diagram == null) + return null; + predefined = graph.getPossibleObject(diagram, TEPLATE2D.HasDrawingTemplate); + } + else if (id.equals(current)) + predefined = selection.getPossibleRepresents(graph); + else if (id.equals(flagAnnotation)){ + Resource flag = selection.getPossibleRepresents(graph); + if (flag != null) + predefined = getAnnotation(graph, flag); + } + else if (id.equals(diagram)){ + Resource composite = selection.getPossibleRepresents(graph); + if (composite == null) + return null; + ModelingResources MOD = ModelingResources.getInstance(graph); + predefined = graph.getPossibleObject(composite, MOD.CompositeToDiagram); + } + else if (id.equals(diagramComposite)) + predefined = getDiagramComposite(graph, selection); + else if (id.equals(flagSourceObject)) + predefined = getFlagSourceObject(graph, selection); + else if (id.equals(flagTargetObject)) + predefined = getFlagTargetObject(graph, selection); + else if (id.equals(flagSourceComposite)) + predefined = getFlagSourceComposite(graph, selection); + else if (id.equals(flagTargetComposite)) + predefined = getFlagTargetComposite(graph, selection); + else if (id.equals(flagRouterComponent)) + predefined = getFlagRouterComponent(graph, selection); + return predefined; + } + + public Variable getPredefinedVariable(ReadGraph graph, Variable selection, String id) throws DatabaseException { + Resource predefined = this.getPredefinedResource(graph, selection, id); + if (predefined == null) + return null; + + Variable v = selection; + if (predefined != null) + v = Variables.getPossibleVariable(graph, predefined); + return v; + } + + public Variable getVariable(ReadGraph graph, String path, Resource converter, Variable selection) throws DatabaseException { + if (path == null) + return null; + int colonInx = path.indexOf(':'); + int firstSlash = path.indexOf('/'); + int firstHash = path.indexOf('#'); + int firstFlashInx = firstSlash; + if(firstFlashInx == -1) firstFlashInx = firstHash; + else { + if(firstHash > -1 && firstHash < firstFlashInx) firstFlashInx = firstHash; + } + + String predefined = null; + String relativePath = null; + + // if scheme is followed by absolute uri + // for examples: + // pre:/model/Library/logo.svg#data -- get under model + // pre:/./Library/logo.svg#data-- get under composite which corresponds the diagram + // pre:/project/Library/FORTUM_LOGO_CMYK.svg#data -- get under project + // pre:/root/Library/FORTUM_LOGO_CMYK.svg#data -- get under root + + if (colonInx != -1 && firstFlashInx != -1 && colonInx+1 == firstFlashInx && path.length() > firstFlashInx+1){ + String scheme = path.substring(0, colonInx); + String absPath = path.substring(firstFlashInx+1); + if (scheme.equals("pre")){ + int endOfPredefined1 = absPath.indexOf('/'); + int endOfPredefined2 = absPath.indexOf('#'); + if (endOfPredefined1 == -1 && endOfPredefined2 == -1) + predefined = absPath; + if (endOfPredefined1 == -1 && endOfPredefined2 != -1) + predefined = absPath.substring(0, endOfPredefined2); + if (endOfPredefined1 != -1 && endOfPredefined2 == -1) + predefined = absPath.substring(0, endOfPredefined1); + if (endOfPredefined1 != -1 && endOfPredefined2 != -1){ + if (endOfPredefined2 < endOfPredefined1) + endOfPredefined1 = endOfPredefined2; + predefined = absPath.substring(0, endOfPredefined1); + } + relativePath = absPath.substring(predefined.length()); + } + } + + //Variable activeVariable = ScenegraphLoaderUtils.getPossibleVariableSelection(graph, context); + if (selection == null) + return null; + + Variable v = selection; + if (predefined != null) + v = getPredefinedVariable(graph, selection, predefined); + + if (v == null) + return null; + + Variable property = null; + if (relativePath != null){ + if (relativePath.startsWith("/.")) + relativePath = relativePath.substring(1); + property = v.browsePossible(graph, relativePath); + } + else + property = v.browsePossible(graph, path); + return property; + } + +}