Developer Documents - User contributions [en]

Check list: Model browser contributions

2017-07-03T13:18:29Z

Teemu Mätäsniemi: /* Step 2: Implementation Plug-in */

To avoid typical errors while defining ontology contributions to model browser follow the following check list:

== Step 1: Ontology Plug-in ==
Define an ontology plugin (org.mylib.ontology)

Define dependencies from Simantics plugins in MANIFEST.MF/Dependencies/Required Plug-ins
<nowiki>org.simantics.layer0
org.simantics.modeling.ontology
org.simantics.viewpoint.ontology
org.simantics.action.ontology</nowiki>

Include the following definitions into your ontology file (*.pgraph)
<nowiki>L0 = <http://www.simantics.org/Layer0-1.1>
VP = <http://www.simantics.org/Viewpoint-1.2>
ACT = <http://www.simantics.org/Action-1.1>
MOD = <http://www.simantics.org/Modeling-1.2></nowiki>

Define a new library (www.mylib.org) for your ontology under Simantics root (''http://''):
<nowiki>MY_LIB = <http://www.mylib.org> : L0.Library
@L0.new</nowiki>

Define your ontology under the library and specify its ResourceClass
<nowiki>MY_ONTOLOGY = <http://www.mylib.org/MyOntology-1.0> : L0.Ontology
@L0.new
L0.HasResourceClass "org.mylib.MyOntologyResource" : L0.String</nowiki>

Check the Name property of ontology plugin in MANIFEST.MF/Overview/General Information. It has to match with URI (without version number) of your ontology.
<nowiki>Name: http://www.mylib.org/MyOntology</nowiki>

Export the package (org.mylib) of ResourceClass in MANIFEST.MF/Runtime/Exported Packages.

Define a new context and include it into MOD.ModelingActionContext
<nowiki>MY_AC = MY_ONTOLOGY.MyActionContext : VP.BrowseContext
VP.BrowseContext.IsIncludedIn MOD.ModelingActionContext</nowiki>

Define a new ActionContribution for each action in this context
<nowiki>MY_AC
VP.BrowseContext.HasActionContribution _ : VP.ActionContribution
L0.HasLabel "My action..."
VP.ActionContribution.HasAction MY_ONTOLOGY.MyAction : ACT.Action
VP.ActionContribution.HasNodeType
L0.Entity</nowiki>

== Step 2: Implementation Plug-in ==
Define a plugin for implementation (org.mylib). Options: Generate an activator=checked, This plug-in will make contributions to the UI=checked.

Define dependencies from Simantics plugins in MANIFEST.MF/Dependencies/Required Plug-ins
<nowiki>org.simantics.db.layer0</nowiki>

Define a new package src/org.mylib.actions

Define a new Java class MyAction.java under org.mylib.actions package
<nowiki>package org.mylib.actions;
import org.simantics.db.layer0.adapter.ActionFactory;
import org.simantics.db.Resource;

public class MyAction implements ActionFactory {
@Override
public Runnable create(Object target) {
if (!(target instanceof Resource))
return null;
final Resource res = (Resource) target;
return new Runnable() {
@Override
public void run() {
// TODO: put your code here
}
};
}
} </nowiki>

Create a new file (adapters.xml) under implementation plugin to map URI (unversioned) of your action to Java class implementation. The content of the file is as follows:
<nowiki><?xml version="1.0" encoding="UTF-8"?>
<adapters>
<target interface="org.simantics.db.layer0.adapter.ActionFactory">
<resource
uri="http://www.mylib.org/MyOntology-0.0/MyAction"
class="org.mylib.actions.MyAction" />
</target>
</adapters></nowiki>

You can check correctness of URI by Graph debugger to search a resource:
<pre>http://www.mylib.org/MyOntology-1.0/MyAction</pre>
Note! Use versioned URI (0.0 -> 1.0) while searching.

Include adapters.xml into build configuration in MANIFEST.MF/Build/Binary Build. Also, include SCL packages and SCL modules if your use them in your implementation.

Export the implementation package (org.mylib.actions) of MyAction.java in MANIFEST.MF/Runtime/Exported Packages.

== Step 3: Product ==
Include the ontology and the implementation plugins into your product configuration (Debug Configurations/Plug-ins) and validate Plug-ins dependencies before running the product.

Check list: Model browser contributions

2017-07-03T13:08:42Z

Teemu Mätäsniemi: /* Step 2: Implementation Plug-in */

To avoid typical errors while defining ontology contributions to model browser follow the following check list:

== Step 1: Ontology Plug-in ==
Define an ontology plugin (org.mylib.ontology)

Define dependencies from Simantics plugins in MANIFEST.MF/Dependencies/Required Plug-ins
<nowiki>org.simantics.layer0
org.simantics.modeling.ontology
org.simantics.viewpoint.ontology
org.simantics.action.ontology</nowiki>

Include the following definitions into your ontology file (*.pgraph)
<nowiki>L0 = <http://www.simantics.org/Layer0-1.1>
VP = <http://www.simantics.org/Viewpoint-1.2>
ACT = <http://www.simantics.org/Action-1.1>
MOD = <http://www.simantics.org/Modeling-1.2></nowiki>

Define a new library (www.mylib.org) for your ontology under Simantics root (''http://''):
<nowiki>MY_LIB = <http://www.mylib.org> : L0.Library
@L0.new</nowiki>

Define your ontology under the library and specify its ResourceClass
<nowiki>MY_ONTOLOGY = <http://www.mylib.org/MyOntology-1.0> : L0.Ontology
@L0.new
L0.HasResourceClass "org.mylib.MyOntologyResource" : L0.String</nowiki>

Check the Name property of ontology plugin in MANIFEST.MF/Overview/General Information. It has to match with URI (without version number) of your ontology.
<nowiki>Name: http://www.mylib.org/MyOntology</nowiki>

Export the package (org.mylib) of ResourceClass in MANIFEST.MF/Runtime/Exported Packages.

Define a new context and include it into MOD.ModelingActionContext
<nowiki>MY_AC = MY_ONTOLOGY.MyActionContext : VP.BrowseContext
VP.BrowseContext.IsIncludedIn MOD.ModelingActionContext</nowiki>

Define a new ActionContribution for each action in this context
<nowiki>MY_AC
VP.BrowseContext.HasActionContribution _ : VP.ActionContribution
L0.HasLabel "My action..."
VP.ActionContribution.HasAction MY_ONTOLOGY.MyAction : ACT.Action
VP.ActionContribution.HasNodeType
L0.Entity</nowiki>

== Step 2: Implementation Plug-in ==
Define a plugin for implementation (org.mylib). Options: Generate an activator=checked, This plug-in will make contributions to the UI=checked.

Define dependencies from Simantics plugins in MANIFEST.MF/Dependencies/Required Plug-ins
<nowiki>org.simantics.db.layer0</nowiki>

Define a package src/org.mylib.actions

Define a new Java class MyAction.java under org.mylib.actions package
<nowiki>package org.mylib.actions;
import org.simantics.db.layer0.adapter.ActionFactory;
import org.simantics.db.Resource;

public class MyAction implements ActionFactory {
@Override
public Runnable create(Object target) {
if (!(target instanceof Resource))
return null;
final Resource res = (Resource) target;
return new Runnable() {
@Override
public void run() {
// TODO: put your code here
}
};
}
} </nowiki>

Create a new file (adapters.xml) under implementation plugin to map URI (unversioned) of your action to Java class implementation. The content of the file is as follows:
<nowiki><?xml version="1.0" encoding="UTF-8"?>
<adapters>
<target interface="org.simantics.db.layer0.adapter.ActionFactory">
<resource
uri="http://www.mylib.org/MyOntology-0.0/MyAction"
class="org.mylib.actions.MyAction" />
</target>
</adapters></nowiki>

You can check correctness of URI by Graph debugger to search a resource:
<pre>http://www.mylib.org/MyOntology-1.0/MyAction</pre>
Note! Use versioned URI (0.0 -> 1.0) while searching.

Include adapters.xml into build configuration in MANIFEST.MF/Build/Binary Build. Also, include SCL packages and SCL modules if your use them in your implementation.

Export the implementation package (org.mylib.actions) of MyAction.java in MANIFEST.MF/Runtime/Exported Packages.

== Step 3: Product ==
Include the ontology and the implementation plugins into your product configuration (Debug Configurations/Plug-ins) and validate Plug-ins dependencies before running the product.

Check list: Model browser contributions

2017-07-03T13:03:57Z

Teemu Mätäsniemi: /* Step 2: Implementation Plug-in */

To avoid typical errors while defining ontology contributions to model browser follow the following check list:

== Step 1: Ontology Plug-in ==
Define an ontology plugin (org.mylib.ontology)

Define dependencies from Simantics plugins in MANIFEST.MF/Dependencies/Required Plug-ins
<nowiki>org.simantics.layer0
org.simantics.modeling.ontology
org.simantics.viewpoint.ontology
org.simantics.action.ontology</nowiki>

Include the following definitions into your ontology file (*.pgraph)
<nowiki>L0 = <http://www.simantics.org/Layer0-1.1>
VP = <http://www.simantics.org/Viewpoint-1.2>
ACT = <http://www.simantics.org/Action-1.1>
MOD = <http://www.simantics.org/Modeling-1.2></nowiki>

Define a new library (www.mylib.org) for your ontology under Simantics root (''http://''):
<nowiki>MY_LIB = <http://www.mylib.org> : L0.Library
@L0.new</nowiki>

Define your ontology under the library and specify its ResourceClass
<nowiki>MY_ONTOLOGY = <http://www.mylib.org/MyOntology-1.0> : L0.Ontology
@L0.new
L0.HasResourceClass "org.mylib.MyOntologyResource" : L0.String</nowiki>

Check the Name property of ontology plugin in MANIFEST.MF/Overview/General Information. It has to match with URI (without version number) of your ontology.
<nowiki>Name: http://www.mylib.org/MyOntology</nowiki>

Export the package (org.mylib) of ResourceClass in MANIFEST.MF/Runtime/Exported Packages.

Define a new context and include it into MOD.ModelingActionContext
<nowiki>MY_AC = MY_ONTOLOGY.MyActionContext : VP.BrowseContext
VP.BrowseContext.IsIncludedIn MOD.ModelingActionContext</nowiki>

Define a new ActionContribution for each action in this context
<nowiki>MY_AC
VP.BrowseContext.HasActionContribution _ : VP.ActionContribution
L0.HasLabel "My action..."
VP.ActionContribution.HasAction MY_ONTOLOGY.MyAction : ACT.Action
VP.ActionContribution.HasNodeType
L0.Entity</nowiki>

== Step 2: Implementation Plug-in ==
Define a plugin for action implementation (org.mylib). Options: Generate an activator=checked, This plug-in will make contributions to the UI=checked.

Define a package src/org.mylib.actions

Define a new Java class MyAction.java under org.mylib.actions package
<nowiki>package org.mylib.actions;
import org.simantics.db.layer0.adapter.ActionFactory;
import org.simantics.db.Resource;

public class MyAction implements ActionFactory {
@Override
public Runnable create(Object target) {
if (!(target instanceof Resource))
return null;
final Resource res = (Resource) target;
return new Runnable() {
@Override
public void run() {
// TODO: put your code here
}
};
}
} </nowiki>

Create a new file (adapters.xml) under implementation plugin to map URI (unversioned) of your action to Java class implementation. The content of the file is as follows:
<nowiki><?xml version="1.0" encoding="UTF-8"?>
<adapters>
<target interface="org.simantics.db.layer0.adapter.ActionFactory">
<resource
uri="http://www.mylib.org/MyOntology-0.0/MyAction"
class="org.mylib.actions.MyAction" />
</target>
</adapters></nowiki>

You can check correctness of URI by Graph debugger to search a resource:
<pre>http://www.mylib.org/MyOntology-1.0/MyAction</pre>
Note! Use versioned URI (0.0 -> 1.0) while searching.

Include adapters.xml into build configuration in MANIFEST.MF/Build/Binary Build. Also, include SCL packages and SCL modules if your use them in your implementation.

Export the implementation package (org.mylib.actions) of MyAction.java in MANIFEST.MF/Runtime/Exported Packages.

== Step 3: Product ==
Include the ontology and the implementation plugins into your product configuration (Debug Configurations/Plug-ins) and validate Plug-ins dependencies before running the product.

Check list: Model browser contributions

2017-07-03T12:59:43Z

Teemu Mätäsniemi: /* Step 1: Ontology Plug-in */

To avoid typical errors while defining ontology contributions to model browser follow the following check list:

== Step 1: Ontology Plug-in ==
Define an ontology plugin (org.mylib.ontology)

Define dependencies from Simantics plugins in MANIFEST.MF/Dependencies/Required Plug-ins
<nowiki>org.simantics.layer0
org.simantics.modeling.ontology
org.simantics.viewpoint.ontology
org.simantics.action.ontology</nowiki>

Include the following definitions into your ontology file (*.pgraph)
<nowiki>L0 = <http://www.simantics.org/Layer0-1.1>
VP = <http://www.simantics.org/Viewpoint-1.2>
ACT = <http://www.simantics.org/Action-1.1>
MOD = <http://www.simantics.org/Modeling-1.2></nowiki>

Define a new library (www.mylib.org) for your ontology under Simantics root (''http://''):
<nowiki>MY_LIB = <http://www.mylib.org> : L0.Library
@L0.new</nowiki>

Define your ontology under the library and specify its ResourceClass
<nowiki>MY_ONTOLOGY = <http://www.mylib.org/MyOntology-1.0> : L0.Ontology
@L0.new
L0.HasResourceClass "org.mylib.MyOntologyResource" : L0.String</nowiki>

Check the Name property of ontology plugin in MANIFEST.MF/Overview/General Information. It has to match with URI (without version number) of your ontology.
<nowiki>Name: http://www.mylib.org/MyOntology</nowiki>

Export the package (org.mylib) of ResourceClass in MANIFEST.MF/Runtime/Exported Packages.

Define a new context and include it into MOD.ModelingActionContext
<nowiki>MY_AC = MY_ONTOLOGY.MyActionContext : VP.BrowseContext
VP.BrowseContext.IsIncludedIn MOD.ModelingActionContext</nowiki>

Define a new ActionContribution for each action in this context
<nowiki>MY_AC
VP.BrowseContext.HasActionContribution _ : VP.ActionContribution
L0.HasLabel "My action..."
VP.ActionContribution.HasAction MY_ONTOLOGY.MyAction : ACT.Action
VP.ActionContribution.HasNodeType
L0.Entity</nowiki>

== Step 2: Implementation Plug-in ==
Define a plugin for action implementation (org.mylib)

Define a package src/org.mylib.actions

Define a new Java class MyAction.java under org.mylib.actions package
<nowiki>package org.mylib.actions;
import org.simantics.db.layer0.adapter.ActionFactory;
import org.simantics.db.Resource;

public class MyAction implements ActionFactory {
@Override
public Runnable create(Object target) {
if (!(target instanceof Resource))
return null;
final Resource res = (Resource) target;
return new Runnable() {
@Override
public void run() {
// TODO: put your code here
}
};
}
} </nowiki>

Create a new file (adapters.xml) under implementation plugin to map URI (unversioned) of your action to Java class implementation. The content of the file is as follows:
<nowiki><?xml version="1.0" encoding="UTF-8"?>
<adapters>
<target interface="org.simantics.db.layer0.adapter.ActionFactory">
<resource
uri="http://www.mylib.org/MyOntology-0.0/MyAction"
class="org.mylib.actions.MyAction" />
</target>
</adapters></nowiki>

You can check correctness of URI by Graph debugger to search a resource:
<pre>http://www.mylib.org/MyOntology-1.0/MyAction</pre>
Note! Use versioned URI (0.0 -> 1.0) while searching.

Include adapters.xml into build configuration in MANIFEST.MF/Build/Binary Build. Also, include SCL packages and SCL modules if your use them in your implementation.

Export the implementation package (org.mylib.actions) of MyAction.java in MANIFEST.MF/Runtime/Exported Packages.

== Step 3: Product ==
Include the ontology and the implementation plugins into your product configuration (Debug Configurations/Plug-ins) and validate Plug-ins dependencies before running the product.

Check list: Model browser contributions

2017-07-03T12:16:25Z

Teemu Mätäsniemi: /* Step 1: Ontology Plug-in */

To avoid typical errors while defining ontology contributions to model browser follow the following check list:

== Step 1: Ontology Plug-in ==
Define an ontology plugin (org.mylib.ontology)

Define dependencies from Simantics plugins in MANIFEST.MF/Dependencies/Required Plug-ins
<nowiki>org.simantics.layer0
org.simantics.modeling.ontology
org.simantics.viewpoint.ontology
org.simantics.action.ontology</nowiki>

Include the following definitions into your ontology file (*.pgraph)
<nowiki>L0 = <http://www.simantics.org/Layer0-1.1>
VP = <http://www.simantics.org/Viewpoint-1.2>
ACT = <http://www.simantics.org/Action-1.1></nowiki>

Define a new library (www.mylib.org) for your ontology under Simantics root (''http://''):
<nowiki>MY_LIB = <http://www.mylib.org> : L0.Library
@L0.new</nowiki>

Define your ontology under the library and specify its ResourceClass
<nowiki>MY_ONTOLOGY = <http://www.mylib.org/MyOntology-1.0> : L0.Ontology
@L0.new
L0.HasResourceClass "org.mylib.MyOntologyResource" : L0.String</nowiki>

Check the Name property of ontology plugin in MANIFEST.MF/Overview/General Information. It has to match with URI (without version number) of your ontology.
<nowiki>Name: http://www.mylib.org/MyOntology</nowiki>

Export the package (org.mylib) of ResourceClass in MANIFEST.MF/Runtime/Exported Packages.

Define a new context and include it into MOD.ModelingActionContext
<nowiki>MY_AC = MY_ONTOLOGY.MyActionContext : VP.BrowseContext
VP.BrowseContext.IsIncludedIn MOD.ModelingActionContext</nowiki>

Define a new ActionContribution for each action in this context
<nowiki>MY_AC
VP.BrowseContext.HasActionContribution _ : VP.ActionContribution
L0.HasLabel "My action..."
VP.ActionContribution.HasAction MY_ONTOLOGY.MyAction : ACT.Action
VP.ActionContribution.HasNodeType
L0.Entity</nowiki>

== Step 2: Implementation Plug-in ==
Define a plugin for action implementation (org.mylib)

Define a package src/org.mylib.actions

Define a new Java class MyAction.java under org.mylib.actions package
<nowiki>package org.mylib.actions;
import org.simantics.db.layer0.adapter.ActionFactory;
import org.simantics.db.Resource;

public class MyAction implements ActionFactory {
@Override
public Runnable create(Object target) {
if (!(target instanceof Resource))
return null;
final Resource res = (Resource) target;
return new Runnable() {
@Override
public void run() {
// TODO: put your code here
}
};
}
} </nowiki>

Create a new file (adapters.xml) under implementation plugin to map URI (unversioned) of your action to Java class implementation. The content of the file is as follows:
<nowiki><?xml version="1.0" encoding="UTF-8"?>
<adapters>
<target interface="org.simantics.db.layer0.adapter.ActionFactory">
<resource
uri="http://www.mylib.org/MyOntology-0.0/MyAction"
class="org.mylib.actions.MyAction" />
</target>
</adapters></nowiki>

You can check correctness of URI by Graph debugger to search a resource:
<pre>http://www.mylib.org/MyOntology-1.0/MyAction</pre>
Note! Use versioned URI (0.0 -> 1.0) while searching.

Include adapters.xml into build configuration in MANIFEST.MF/Build/Binary Build. Also, include SCL packages and SCL modules if your use them in your implementation.

Export the implementation package (org.mylib.actions) of MyAction.java in MANIFEST.MF/Runtime/Exported Packages.

== Step 3: Product ==
Include the ontology and the implementation plugins into your product configuration (Debug Configurations/Plug-ins) and validate Plug-ins dependencies before running the product.

Check list: Model browser contributions

2017-07-03T11:38:24Z

Teemu Mätäsniemi: /* Step 1: Ontology Plug-in */

To avoid typical errors while defining ontology contributions to model browser follow the following check list:

== Step 1: Ontology Plug-in ==
Define a new ontology plugin (org.mylib.ontology)

Define dependencies from Simantics plugins in MANIFEST.MF/Dependencies/Required Plug-ins
<nowiki>org.simantics.layer0
org.simantics.modeling.ontology
org.simantics.viewpoint.ontology
org.simantics.action.ontology</nowiki>

Include the following definitions into your ontology file (*.pgraph)
<nowiki>L0 = <http://www.simantics.org/Layer0-1.1>
VP = <http://www.simantics.org/Viewpoint-1.2>
ACT = <http://www.simantics.org/Action-1.1></nowiki>

Define a new library (www.mylib.org) for your ontology under Simantics root (''http://''):
<nowiki>MY_LIB = <http://www.mylib.org> : L0.Library
@L0.new</nowiki>

Define your ontology under the library and specify its ResourceClass
<nowiki>MY_ONTOLOGY = <http://www.mylib.org/MyOntology-1.0> : L0.Ontology
@L0.new
L0.HasResourceClass "org.mylib.MyOntologyResource" : L0.String</nowiki>

Check the Name property of ontology plugin in MANIFEST.MF/Overview/General Information. It has to match with URI (without version number) of your ontology.
<nowiki>Name: http://www.mylib.org/MyOntology</nowiki>

Export the package (org.mylib) of ResourceClass in MANIFEST.MF/Runtime/Exported Packages.

Define a new context and include it into MOD.ModelingActionContext
<nowiki>MY_AC = MY_ONTOLOGY.MyActionContext : VP.BrowseContext
VP.BrowseContext.IsIncludedIn MOD.ModelingActionContext</nowiki>

Define a new ActionContribution for each action in this context
<nowiki>MY_AC
VP.BrowseContext.HasActionContribution _ : VP.ActionContribution
L0.HasLabel "My action..."
VP.ActionContribution.HasAction MY_LIB.MyAction : ACT.Action
VP.ActionContribution.HasNodeType
L0.Entity

== Step 2: Implementation Plug-in ==
Define a plugin for action implementation(org.mylib)

Check list: Model browser contributions

2017-07-03T11:37:12Z

Teemu Mätäsniemi: /* Step 1: Ontology Plug-in */

To avoid typical errors while defining ontology contributions to model browser follow the following check list:

== Step 1: Ontology Plug-in ==
Define a new ontology plugin (org.mylib.ontology)

Define dependencies from Simantics plugins in MANIFEST.MF/Dependencies/Required Plug-ins
<nowiki>org.simantics.layer0
org.simantics.modeling.ontology
org.simantics.viewpoint.ontology
org.simantics.action.ontology</nowiki>

Include the following definitions into your ontology file (*.pgraph)
<nowiki>L0 = <http://www.simantics.org/Layer0-1.1>
VP = <http://www.simantics.org/Viewpoint-1.2>
ACT = <http://www.simantics.org/Action-1.1></nowiki>

Define a new library (www.mylib.org) for your ontology under Simantics root (''http://''):
<nowiki>MY_LIB = <http://www.mylib.org> : L0.Library
@L0.new</nowiki>

Define your ontology under the library and specify its ResourceClass
<nowiki>MY_ONTOLOGY = <http://www.mylib.org/MyOntology-1.0> : L0.Ontology
@L0.new
L0.HasResourceClass "org.mylib.Resource" : L0.String</nowiki>

Check the Name property of ontology plugin in MANIFEST.MF/Overview/General Information. It has to match with URI (without version number) of your ontology.
<nowiki>Name: http://www.mylib.org/MyOntology</nowiki>

Export the package (org.mylib) of ResourceClass in MANIFEST.MF/Runtime/Exported Packages.

Define a new context and include it into MOD.ModelingActionContext
<nowiki>MY_AC = MY_ONTOLOGY.MyActionContext : VP.BrowseContext
VP.BrowseContext.IsIncludedIn MOD.ModelingActionContext</nowiki>

Define a new ActionContribution for each action in this context
<nowiki>MY_AC
VP.BrowseContext.HasActionContribution _ : VP.ActionContribution
L0.HasLabel "My action..."
VP.ActionContribution.HasAction MY_LIB.MyAction : ACT.Action
VP.ActionContribution.HasNodeType
L0.Entity

== Step 2: Implementation Plug-in ==
Define a plugin for action implementation(org.mylib)

Check list: Model browser contributions

2017-07-03T11:30:14Z

Teemu Mätäsniemi: /* Step 1: Ontology Plug-in */

To avoid typical errors while defining ontology contributions to model browser follow the following check list:

== Step 1: Ontology Plug-in ==
Define a new ontology plugin (org.mylib.ontology)

Include the following definitions into your ontology file (*.pgraph)
<nowiki>L0 = <http://www.simantics.org/Layer0-1.1>
VP = <http://www.simantics.org/Viewpoint-1.2>
ACT = <http://www.simantics.org/Action-1.1></nowiki>

Define a new library (www.mylib.fi) for your ontology under Simantics root (''http://''):
<nowiki>MY_LIB = <http://www.mylib.org> : L0.Library
@L0.new</nowiki>

Define your ontology under the library and specify its ResourceClass
<nowiki>MY_ONTOLOGY = <http://www.mylib.org/MyOntology-1.0> : L0.Ontology
@L0.new
L0.HasResourceClass "org.mylib.Resource" : L0.String</nowiki>

Check the Name property of ontology plugin in MANIFEST.MF/Overview/General Information. It has to match with URI (without version number) of your ontology.
<nowiki>Name: http://www.mylib.org/MyOntology</nowiki>

Export the package (org.mylib) of ResourceClass in MANIFEST.MF/Runtime/Exported Packages.

Define a new context and include it into MOD.ModelingActionContext
<nowiki>MY_AC = MY_ONTOLOGY.MyActionContext : VP.BrowseContext
VP.BrowseContext.IsIncludedIn MOD.ModelingActionContext</nowiki>

Define a new ActionContribution for each action in this context
<nowiki>MY_AC
VP.BrowseContext.HasActionContribution _ : VP.ActionContribution
L0.HasLabel "My action..."
VP.ActionContribution.HasAction MY_LIB.MyAction : ACT.Action
VP.ActionContribution.HasNodeType
L0.Entity

Check list: Model browser contributions

2017-07-03T11:28:30Z

Teemu Mätäsniemi:

To avoid typical errors while defining ontology contributions to model browser follow the following check list:

== Step 1: Ontology Plug-in ==
Define a new ontology plugin (org.mylib.ontology)

Include the following definitions into your ontology file (*.pgraph)
<nowiki>L0 = <http://www.simantics.org/Layer0-1.1>
VP = <http://www.simantics.org/Viewpoint-1.2>
ACT = <http://www.simantics.org/Action-1.1></nowiki>

Define a new library (www.mylib.fi) for your ontology under Simantics root (''http://''):
<nowiki>MY_LIB = <http://www.mylib.org> : L0.Library
@L0.new</nowiki>

Define your ontology under the library and specify its ResourceClass
<nowiki>MY_ONTOLOGY = <http://www.mylib.org/MyOntology-1.0> : L0.Ontology
@L0.new
L0.HasResourceClass "org.mylib.Resource" : L0.String</nowiki>

Check the Name property of ontology plugin in MANIFEST.MF/Overview/General Information. It has to match with URI (without version number) of your ontology.
<nowiki>Name: http://www.mylib.org/MyOntology</nowiki>

Export the package (org.mylib) of ResourceClass in MANIFEST.MF/Runtime/Exported Packages.

Define a new context and include it into ModelingActionContext
<nowiki>MY_AC = MY_ONTOLOGY.MyActionContext : VP.BrowseContext
VP.BrowseContext.IsIncludedIn MOD.ModelingActionContext</nowiki>

Define a new ActionContribution for each action in this context
<nowiki>MY_AC
VP.BrowseContext.HasActionContribution _ : VP.ActionContribution
L0.HasLabel "My action..."
VP.ActionContribution.HasAction MY_LIB.MyAction : ACT.Action
VP.ActionContribution.HasNodeType
L0.Entity

Check list: Model browser contributions

2017-07-03T10:49:32Z

Teemu Mätäsniemi: Created page with "To avoid typical errors while defining ontology contributions to model browser follow the following check list: == Step 1: Ontology Plug-in == Define a new library (www.mylib..."

To avoid typical errors while defining ontology contributions to model browser follow the following check list:

== Step 1: Ontology Plug-in ==
Define a new library (www.mylib.fi) for ontology under Simantics root (''http://''):
MyLib = <''http://www.mylib.fi''> : L0.Library
'' @L0.new''

Simantics Developer Documentation

2017-07-03T10:41:11Z

Teemu Mätäsniemi:

__NOTOC__
[[image:Simantics_logo_pile_01.png|right|border|400px]]

'''Simantics''' is a software platform for modelling and simulation. The system has client-server architecture with a semantic ontology-based modelling database and Eclipse framework -based client software with plug-in interface. The Simantics platform and many of its components are open source under [http://www.eclipse.org/legal/epl-v10.html Eclipse Public License (EPL)].

The philosophy of the Simantics platform is to offer an open, high level application platform on which different computational tools can be easily integrated to form a common environment for modelling and simulation. The platform includes several modelling tools, so-called editors, for e.g. 2D graph-like hierarchical model composition and semantic graph browsing.

One of the biggest innovations in the Simantics platform is the semantic modelling approach itself and high-level ontology tools. The semantic database, i.e. triplestore, on the server side enables high performance data management and arbitrary mappings of data. This enables e.g. efficient mapping of simulation and measurement data to the model configuration and its visualisation.

The Simantics development and maintenance process is built to be solid and scalable from the very beginning. The objective is to aim far to the future what comes to requirements for scalability, usability, and reliability.

This ''Simantics Developer Documentation'' is targeted to programmers and software developers developing either the platform itself or additional plug-ins to be used with or on the platform. The [[userwiki:Main_Page|Simantics End User Documentation]] complements to documentation for the Simantics platform offering overview and detailed information about the platform from the user's point of view. The [https://www.simantics.org/simantics Simantics] website is the source of information for the Simantics project and related subjects[[Tutorials|.]]
<div style="color:white;">Disclaimer Warning: This site may cause narcolepsia in some readers. Consult your doctor if sensitive to boredom.</div>

{|width="75%"
|width="25%" valign="top"|
=== Overview ===

* [[Glossary]]
* [[Introduction to Simantics Architecture]]
* [[Roadmap]]
* [[Data View]]
* [[Component View]]
* [[Licensing|Licensing]]
* [[Useful Links]]


|width="25%" valign="top"|

=== Miscellaneous Documents ===

* [[Quick Development Environment Setup|Quick Development Environment Setup Guide]]
* [[Target Platform]]
* [[Development Practices]]
* [[Internationalization]]
* [[Update Site]]
* [[Coding Convention]]
* [[Tools]]
* [[Testing]]
* [[FAQ]]
* [[Migration To Git]]

|width="25%" valign="top"|

|}

{|width="100%"

|width="25%" valign="top"|

=== Ontology Development ===

* [[:Media:Layer0.pdf|Layer0.pdf]] ([[:File:Layer0.pdf|log]])
* [[Graph Compiler]]
* [[Transferable Graph]]
* [[Binary Container Format]]
* [[Graph File Format]]
* [[Version Migration]]
* [[Tutorial: Ontology Development]]
* [[Check list: Model browser contributions]]
* [[XML Schema Conversion]]

|width="25%" valign="top"|

=== Database Development ===

* [[Interface summary]]
* [[Tutorial: Quickstart]]
* [[Tutorial: Database Development]]
* [[Resource Adaptation]]
* [[Resource Serialization]]
* [[Inverse Relations]]
* [[Virtual Graphs]]
* [[Functions]]
* [[Procedural Values]]
* [[Variable]]
* [[Undo Mechanism]]
* [[Team Features]]
* [[Subgraph Extents]]
* [[Database Testing]]

|width="25%" valign="top"|

=== Data management & Experiment Control ===

* [[Databoard Specification]]
* [[Databoard Developer Manual|Databoard Java Manual]]
* [[Experiment Control]]
* [[Dataflows]]

|width="25%" valign="top"|

=== UI Development ===

* [[Org.simantics.browsing.ui_Manual|Browser Manual]]
* [[org.simantics.browsing.ui.feature|Browser Component]]
* [[Org.simantics.scenegraph.loader|Scene Graph Loader]]
* [[Org.simantics.message|Messages]]
* [[Org.simantics.views|Modelled Views]]
* [[Org.simantics.document|Documents]]
* [[Selection View]]
|}
{|width="100%"
|width="25%" valign="top"|

=== Simantics Constraint Language===

* [http://www.simantics.org/~niemisto/Introduction%20to%20SCL.pptx Introduction to SCL]
* [[SCL Compiler]]
* [[SCL Tutorial]]
* [[SCL Types]]


* [[Org.simantics.objmap_Manual|Object Map Manual]]
* [[SCL Registry]]
* [http://www.simantics.org/SCLDocumentation/StandardLibrary/Prelude.html SCL Reference]
* [http://www.simantics.org/~niemisto/Transformations.pdf Transformation language specification]
* [http://www.simantics.org/~niemisto/Transformations_2015_01_23.pdf Transformation language presentation]
* [http://www.simantics.org/~niemisto/CHRGuide.html CHR Guide]

|width="25%" valign="top"|

=== Model Development ===

* [[Structural Ontology]]
* [[Users and Roles]]
* [[Models]]
* [[Concept Versioning]]
* [[Component Identification]]
* [[Tutorial: Model Development]]

|width="25%" valign="top"|

=== Project Development ===

* [[Project Management Conceptual Model]]
* [[Project Development]]
* [[Tutorial: Project Development]]

|width="25%" valign="top"|

=== Diagram Development ===

* [[2D Ontologies]]
* [[org.simantics.diagram|Diagram]]
* [[org.simantics.scenegraph|Scene graph]]
* [[Diagram connections]]
* [[Tutorial: Diagram Development]]

|}
{|width="100%"
|width="25%" valign="top"|

=== Issue Development ===

* [[Issue subsystem general description]]

|width="25%" valign="top"|

=== Utilities ===

* [[Simantics Generic File Import]]
* [[Logging in Simantics Platform]]

|}

-----

Tutorial: Database Development

2013-12-05T17:20:52Z

Teemu Mätäsniemi: /* Asynchronous read with a SyncListener */

= Basic concepts =
;Session: Database session / connection that allows reading and writing the database using transactions.
;Transaction: A database operation; either read, or write operation. Simantics supports three types of transactions: Read, Write, and WriteOnly.
;Resource: A single object in the database.
;Statement: Triple consisting of subject, predicate, and object
;Literal: primitive value (int, double, String,..) or an array of primitive values.

=Reading the database=

==Literals==

In this example we set a Label to show a Resource’s name. A resource's name is defined using the '''L0.HasName''' property relation.

To support Layer0 URI ↔ resource mapping mechanism (see [[:Media:Layer0.pdf|Layer0.pdf]] section 4), resource names have certain restrictions.
* A single resource cannot have more than one statement objects with '''L0.ConsistsOf'''-predicate that have the same name. For example the following graph snippet in [[Graph File Format]] does not work with the URI → resource discovery mechanism:
<pre>
a : L0.Entity
L0.ConsistsOf
a : L0.Entity
a : L0.Entity
b : L0.Entity
</pre>

===Synchronous read with a return value===
One way to read information stored in the database is to use synchronous reads with a return value. Return value can be any Java class, and here it is String.

<pre>
try {
String name = session.syncRequest(new Read<String>() {
@Override
public String perform(ReadGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
return graph.getRelatedValue(resource, l0.HasName);

}});
label.setText(name);
} catch (DatabaseException e) {
// handle exception here
}
</pre>

Database connection may fail during the transaction and send an exception. Therefore you have to handle the exception in some way. Here we have wrapped the transaction inside try-catch block. In real code the most common thing to do is to let the exception propagate back to UI code.

All literals can be read the same way, you just have to provide correct relation. There are also other methods to read literals that behave differently:
*getRelatedValue(): returns literal or throws and exception if value is not found
*getPossibleRelatedValue(): returns literal value or null, if the value does not exist.

=== Asynchronous read ===

Asynchronous read allows creating requests that are processed in the background. If you don’t need the result immediately, it is recommended to use asynchronous reads for performance reasons or to prevent blocking UI threads.

<pre>
session.asyncRequest(new ReadRequest() {
@Override
public void run(ReadGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
final String name = graph.getRelatedValue(resource, l0.HasName);
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
if (!label.isDisposed())
label.setText(name);
}
});
}
});
</pre>

Here we use separate Runnable to set the label’s text (SWT components must be accessed from main / SWT thread). Note that we have to check if the label is disposed before setting the text.

===Asynchronous read with a Procedure===
Using a procedure allows you to handle possible exceptions caused by failed asynchronous transaction.

<pre>
session.asyncRequest(new Read<String>() {
@Override
public String perform(ReadGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
return graph.getRelatedValue(resource, l0.HasName);
}
}, new Procedure<String>() {
@Override
public void exception(Throwable t) {
// handle exception here
}

@Override
public void execute(final String name) {
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
if (!label.isDisposed())
label.setText(name);
}
});
}
});
</pre>

===Asynchronous read with a SyncListener===
Using <code>SyncListener</code> with a read transaction leaves a listener to the database that notifies changes in the read data. There exist also <code>Listener</code> and <code>AsyncListener</code> interfaces. SyncListener provides a ''ReadGraph'' for the listener, AsyncListener provides ''AsyncReadGraph'' for the user. Using <code>Listener</code> provides no graph access at all, just a notification of a changed read request result.
<pre>
session.asyncRequest(new Read<String>() {
@Override
public String perform(ReadGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
return graph.getRelatedValue(resource, l0.HasName);
}
}, new SyncListener<String>() {
@Override
public void exception(ReadGraph graph, Throwable throwable) throws DatabaseException {
// handle exception here
}

@Override
public void execute(ReadGraph graph, final String name) throws DatabaseException {
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
if (!label.isDisposed())
label.setText(name);
}
});
}

@Override
public boolean isDisposed() {
return label.isDisposed();
}

});
</pre>
Here the listener updates the label when the name changes. The method isDisposed() controls lifecycle of the listener, and here when the label is disposed, the listener is released and it stops updating the label.

===Triggering a read transaction (and its SyncListener) explicitely or without changes in data===
Idea is to embed an ExternalRead object (trigger) into a read request chain. Thus, the chain will be re-evaluated if the trigger is launched. Note, that the trigger has to be embedded with a listener. This guarantees that the trigger is kept alive.
<pre>
final TriggeringExternalRead trigger = new TriggeringExternalRead();

session.asyncRequest(new Read<String>() {
@Override
public String perform(ReadGraph graph) throws DatabaseException {

// embed a trigger with listener into this read request chain
graph.syncRequest(trigger, new Listener<Integer>(){

@Override
public void execute(Integer result) {
// TODO Auto-generated method stub

}

@Override
public void exception(Throwable t) {
// TODO Auto-generated method stub

}

@Override
public boolean isDisposed() {
// TODO Auto-generated method stub
return false;
}});
);
// end of embeding

Layer0 l0 = Layer0.getInstance(graph);
return graph.getRelatedValue(resource, l0.HasName);
}
});
</pre>
To launch a trigger in other code section just call its fire() -method.
<pre>
trigger.fire();
</pre>

==Resources==
Reading resources is similar to reading literals. Here is an example that reads all resources that are connected to a Resource with a ConsistsOf-relation:
<pre>
try {
Collection<Resource> children = session.syncRequest(new Read<Collection<Resource>>() {
@Override
public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
return graph.getObjects(resource, l0.ConsistsOf);
}
});
} catch (DatabaseException e) {
// handle exception here
}
</pre>
Same asynchronous, Procedure, and Listener mechanisms work with reading resources. For example, you can use listener to be notified if resources are added or removed:
<pre>
session.asyncRequest(new Read<Collection<Resource>>() {
@Override
public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
return graph.getObjects(resource, l0.ConsistsOf);
}
},new AsyncListener<Collection<Resource>>() {
@Override
public void exception(AsyncReadGraph graph, Throwable throwable){
// handle exception here
}

@Override
public void execute(AsyncReadGraph graph, Collection<Resource> result) {
// this is run every time a resource is added or removed
}

@Override
public boolean isDisposed() {
// this must return true when the listener is not needed
// anymore to release the listener
return false;
}
});
</pre>

=Writing the database=
==Explicit clustering==

Here we show how you can influence the way resources are grouped by the underlying implemention. You can significantly improve the dynamic behaviour of the database by grouping resources that are likely to be referenced in the same context/operation.

<pre>
try {
session.syncRequest(new WriteRequest() {
@Override
public void perform(WriteGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
try {
graph.newClusterSet(l0.InstanceOf);
} catch (ClusterSetExistException e) {
// Cluster set exits, no problem.
}
Resource newResource = graph.newResource(l0.InstanceOf);
graph.claim(newResource, l0.InstanceOf, null, l0.Entity);
}
});
</pre>

Here is the same effect with setting a default for newResource method.

<pre>
session.syncRequest(new WriteRequest() {
@Override
public void perform(WriteGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
Resource oldClusterSet = graph.setClusterSet4NewResource(l0.InstanceOf);
try {
Resource newResource = graph.newResource();
graph.claim(newResource, l0.InstanceOf, null, l0.Entity);
} finally {
graph.setClusterSet4NewResource(oldClusterSet);
}
}
});
</pre>

==Setting Literals==

Here we set a name of a resource to “New name”. Both synchronous and asynchronous versions are similar, the only difference is that with synchronous way you have to handle the exception, while using an asynchronous write without a Procedure does not let you know if the transaction failed. Any exceptions will just be logged by the database client library.
<pre>
try {
session.syncRequest(new WriteRequest() {
@Override
public void perform(WriteGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
graph.claimLiteral(resource, l0.HasName, "New name");
}
});
} catch (DatabaseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
</pre>
<pre>
session.asyncRequest(new WriteRequest() {
@Override
public void perform(WriteGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
graph.claimLiteral(resource, l0.HasName, "New name");
}
});
</pre>
Using a Procedure with an asynchronous write transaction is similar to read transactions, so we don’t have separate example of that. Note that listeners can only be used with read transactions, not write transactions.
===Creating new Resources===
Same synchronous and asynchronous mechanisms apply to writing new Resources. The difference is that with asynchronous you can use a Callback to check if write failed, or separate WriteResult and a Procedure to return and check custom results of a write transaction.

Here is an example that creates a new library, gives it a name “New Library” and connects it to given resource.
<pre>
session.asyncRequest(new WriteRequest() {
@Override
public void perform(WriteGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
Resource newResource = graph.newResource();
graph.claim(newResource, l0.InstanceOf, l0.Library);
graph.claimLiteral(newResource, l0.HasName, "New Library");
graph.claim(resource, l0.ConsistsOf, newResource);

}
});
</pre>
The key points here are:
*New resource are created with WriteGraph.newResource()
*You must set resource’s type using InstanceOf-relation.
*If you do not connect created resources anywhere, the resources become orphan resources. For orphan resources there is no statement path to/from the database root resource. They cannot be traversed and therefore found from the database.

===Deleting resources===
Here is an example that removes everything the given resource consists of directly. In the end it removes all the statements from the given resource, thereby essentially removing the resource itself. A resource is considered to not exist if it has no statements, since there's nothing to define its nature.
<pre>
session.asyncRequest(new WriteRequest() {
@Override
public void perform(WriteGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
for (Resource consistsOf : graph.getObjects(resource, l0.ConsistsOf)) {
// Remove all statements (consistsOf, ?p, ?o) and their possible inverse statements
graph.deny(consistsOf);
}
// Remove resource itself by removing any statements to/from it.
graph.deny(resource);
}
});
</pre>
Another example, that deletes the name of the given resource.
<pre>
session.asyncRequest(new WriteRequest() {
@Override
public void perform(WriteGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
graph.denyLiteral(resource, l0.HasName);
}
});
</pre>

The key points here are:
*deny -methods are used to delete statements from the database
*denyLiteral -methods are used to delete literal values from the database
*A resource that has no statements does not exist.

=Example case: Product and Purchase management=

In this example, we will implement a simple product and purchase management system. The system will allow user to define new products, and create new purchase orders. To keep the example simple, the products have just a name and unit cost, and purchase orders will have name of the customer and a list of ordered products.

We have already implemented skeleton for the system. It contains basic user interface for creating products and purchases, but it lacks several features that we are going to add during this tutorial. The base code can be found from SVN:

*https://www.simulationsite.net/svn/simantics/tutorials/trunk/org.simantics.example
*https://www.simulationsite.net/svn/simantics/tutorials/trunk/org.simantics.example.feature

Ontology that we are using is defined in ''Example.pgraph'' file. It is in ''org.simantics.example/graph'' folder. To run the example application, use ''simantics-example.product''. After starting the example product, you should get a user interface like the one in Figure 1.

<pre>
Eclipse will complain that AsyncPurchaseEditorFinal.java does not compile, but it does not prevent
starting the application.
</pre>

[[Image:simantics_db_tutorial_start.png|thumb|600px|center|Figure 1: Tutorial application after one created product (Product 1) and one purchase.]]

When you use the application you may notice following:
*Name of the customer or the date of the order is not shown anywhere.
*When purchase editor is open, new products won’t show up in it. Only closing and opening the editor shows the products.
*Adding new products to purchases can be done only in Example Browser
*While you can order several products, you cannot order multiple items of the same product.

Org.simantics.example plug-in is split into four packages:
*editors: Purchase Editor implementation.
*handlers: UI actions.
*project: Project binding. See … for more details.
*resource: Taxonomy generated from the used ontology.

The most important parts of this tutorial are editors. AsyncPurchaseEditor and classes in handlers-package.

==Adding the missing information to UI==
First we have to add new Text widgets to the Purchase Editor. At the beginning of AsyncPurchaseEditor.java you see:

<pre>
// UI controls
private final Text totalCost;
private final TableViewer productViewer;
private final TableViewerColumn nameColumn;
private final TableViewerColumn costColumn;
</pre>
Add new line after totalCost:
<pre>
private final Text customer;
private final Text date;
</pre>
Then we have to instantiate text fields, create labels that inform user what the text fields mean, and setup the layout properly. In the beginning of the constructor modify:
<pre>
Label l = new Label(this, SWT.NONE);
l.setText("Total Price:");
GridDataFactory.fillDefaults().applyTo(l);

totalCost = new Text(this, SWT.NONE);
totalCost.setEditable(false);
GridDataFactory.fillDefaults().grab(true, false).applyTo(totalCost);
</pre>
To:
<pre>
Label l = new Label(this, SWT.NONE);
l.setText("Customer:");
GridDataFactory.fillDefaults().applyTo(l);

customer = new Text(this, SWT.NONE);
customer.setEditable(false);
GridDataFactory.fillDefaults().grab(true, false).applyTo(customer);

l = new Label(this, SWT.NONE);
l.setText("Date:");
GridDataFactory.fillDefaults().applyTo(l);

date = new Text(this, SWT.NONE);
date.setEditable(false);
GridDataFactory.fillDefaults().grab(true, false).applyTo(date);

l = new Label(this, SWT.NONE);
l.setText("Total Price:");
GridDataFactory.fillDefaults().applyTo(l);

totalCost = new Text(this, SWT.NONE);
totalCost.setEditable(false);
GridDataFactory.fillDefaults().grab(true, false).applyTo(totalCost);
</pre>
And finally, we have to update text fields to show the data. Modify updateUI(Model m) method to contain:
<pre>
customer.setText(m.boughtBy);
date.setText(m.boughtAt);
</pre>

Completed code is in org.simantics.example.phases.AsyncPurchaseEditorMiddle.hava

==Fixing the editor updates==
Currently the Purchase Editor loads products in the purchase when the editor is opened, but if new products are added, editor’s user interface won’t update. To fix this, modify AsyncPurhaseEditor’s setInput(Resource) method. Currently the method is:
<pre>
public void setInput(Resource r) {
this.input = r;
if (input == null)
return;

session.asyncRequest(new Read<Model>() {
@Override
public Model perform(ReadGraph graph) throws DatabaseException {
return loadModel(graph, input);
}
}, new Procedure<Model>() {
@Override
public void exception(Throwable throwable) {
ExceptionUtils.logAndShowError(throwable);
}
@Override
public void execute(final Model result) {
// Set the loaded model as the model viewed by the UI.
getDisplay().asyncExec(new Runnable() {
@Override
public void run() {
if (isDisposed())
return;
updateUI(result);
}
});
}
});
}
</pre>
Hint: You have to replace the Procedure with an Listener.

Answer:
<pre>
public void setInput(Resource r) {
this.input = r;
if (input == null)
return;

session.asyncRequest(new Read<Model>() {
@Override
public Model perform(ReadGraph graph) throws DatabaseException {
return loadModel(graph, input);
}
}, new Listener<Model>() {
@Override
public boolean isDisposed() {
return AsyncPurchaseEditor.this.isDisposed();
}

@Override
public void exception(AsyncReadGraph graph, Throwable throwable) {
ExceptionUtils.logAndShowError(throwable);
}

@Override
public void execute(final Model result) {
// Set the loaded model as the model viewed by the UI.
getDisplay().asyncExec(new Runnable() {
@Override
public void run() {
if (AsyncPurchaseEditor.this.isDisposed())
return;
updateUI(result);
}
});
}
});
}
</pre>
After this modification the editor should update its contents when the data is changed. You may try to add new product to purchase order when the editor is open to check that it really works.

Completed code is in org.simantics.example.phases.AsyncPurchaseEditorMiddle2.hava

==Adding Context Menu to Purchase Editor==
We are going to add context menu to Purchase editor. The context menu will be used for adding new products to a purchase.

There are several ways to implement the context menu in Eclipse. For sake of simplicity, we are not going to implement context menu that allows contributions from plug-in definitions (plugin.xml).

The code that Example Browser uses in its menu is in handlers.AddProductsContributionItem. Sadly, we cannot reuse that implementation, since it uses Eclipse’s selection mechanism to interpret current purchase, while we want to use the purchase that editor has opened.

Put this class to AsyncPurchaseEditor.java:

<pre>
public class AddProductsContributionItem extends CompoundContributionItem {

public AddProductsContributionItem() {
super();
}

public AddProductsContributionItem(String id) {
super(id);
}

@Override
protected IContributionItem[] getContributionItems() {

ProductManagerImpl manager = SimanticsUI.getProject().getHint(ProductManager.PRODUCT_MANAGER);

Map<Resource, String> products = manager.getProducts();

final Resource purchase = input;

IContributionItem[] result = new IContributionItem[products.size()];
int i=0;
System.out.println("Products count = " + products.size());
for(Map.Entry<Resource, String> entry : products.entrySet()) {
final Resource product = entry.getKey();
result[i++] = new ActionContributionItem(new Action("Add " + entry.getValue()) {
@Override
public void run() {
SimanticsUI.getSession().asyncRequest(new WriteRequest() {
@Override
public void perform(WriteGraph graph) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
if(!graph.hasStatement(purchase, l0.ConsistsOf, product))
graph.claim(purchase, l0.ConsistsOf, product);
}
});
}
});
}
return result;
}
}
</pre>
It is the same code as handlers.AddProductsContributionItem, but the selection mechanism has been replaced with the editor input.

To add context menu to the editor, add this code to the end of AsyncPurchaseEditor’s constructor:
<pre>
final MenuManager manager = new MenuManager();
manager.add(new AddProductsContributionItem());
Menu menu = manager.createContextMenu(productViewer.getControl());

this.addDisposeListener(new DisposeListener() {

@Override
public void widgetDisposed(DisposeEvent e) {
manager.dispose();
}
});

productViewer.getControl().setMenu(menu);
</pre>

Completed code is in org.simantics.example.phases.AsyncPurchaseEditorMiddle3.hava

==Supporting multiple items of the same product==
Current ontology is designed so that one purchase order contains products, but product count cannot be stored anywhere [Figure 2].

[[Image:simantics_db_tutorial1.png|thumb|center|700px|Figure 2: Purchases contain only links to products, and there is no way to store product count.]]

To add support for product count we have to change the ontology. We have to introduce new type “ProductPurchase” that will have link to ordered Product and property for product count [Figure 3].

[[File:simantics_db_tutorial2.png|thumb|center|700px|Figure 3: Purchases contain ProductCounts that link to Products.]]

Open the ontology (example.pgraph) and add these to ExampleOntology:
<pre>
EXAMPLE.ProductCount <R L0.HasProperty : L0.FunctionalRelation
L0.HasDomain EXAMPLE.ProductPurchase
L0.HasRange L0.Double

EXAMPLE.ProductPurchase <T L0.Entity
@L0.singleProperty EXAMPLE.ProductCount
</pre>

After this clean the applications workspace, since now it has a database with old ontologies.

To get the application working, we must update AddProductContributionsItem.java and AsyncPurchaseEditor.java. We start with the AddProduct…java. Currently its wrote transaction is:
<pre>
if(!graph.hasStatement(purchase, l0.ConsistsOf, product))
graph.claim(purchase, l0.ConsistsOf, product);
</pre>
This just creates a link between the Purchase and selected Product. We need to create an instance of ProductPurchase link it to the Purchase and to selected Product:
<pre>
for (Resource productPurchase : graph.getObjects(purchase, l0.ConsistsOf)) {
if (graph.hasStatement(productPurchase, l0.ConsistsOf, product)) {
double amount = graph.getRelatedValue(productPurchase, e.ProductCount);
graph.claimLiteral(productPurchase, e.ProductCount, amount + 1.0);
return;
}
}

Resource productPurchase = graph.newResource();
graph.claim(productPurchase, l0.InstanceOf, e.ProductPurchase);
graph.claimLiteral(productPurchase, e.ProductCount, 1.0);
graph.claim(purchase, l0.ConsistsOf, productPurchase);
graph.claim(productPurchase, l0.ConsistsOf, product);
</pre>
This code checks first if the product is already in the purchase, and increases count by one if it is.

Then we edit AsyncPurchaseEditor.java. Start by adding “amount” to Item:
<pre>
class Item {
String name;
double costs;
double amount;
}
</pre>
Next, change loadModel() method to read the data in current form and include product count:
<pre>
if (g.isInstanceOf(modelResource, ex.Purchase)) {
Resource purchase = modelResource;
m.boughtAt = g.getRelatedValue(purchase, ex.BoughtAt);
m.boughtBy = g.getRelatedValue(purchase, ex.BoughtBy);

List<Item> items = new ArrayList<Item>();
for (Resource productPurchase : g.getObjects(purchase, g.getBuiltins().ConsistsOf)) {
Resource product = g.getSingleObject(productPurchase, b.ConsistsOf);
Item i = new Item();
i.name = g.getRelatedValue(product, b.HasName);
i.costs = g.getRelatedValue(product, ex.Costs);
i.amount = g.getRelatedValue(productPurchase, ex.ProductCount);
items.add(i);
}
m.items = items.toArray(new Item[items.size()]);
}
</pre>
Then update AddProductContributionItem inside AsyncPurchaseEditor.java to match the previous edit.

To show the product count we have to add new column to the table. First, create a member for the column:
<pre>
private final TableViewerColumn amountColumn;
</pre>
Then initialize the column in the AsyncPurchaseEditor’s constructor:
<pre>
amountColumn = new TableViewerColumn(productViewer, SWT.LEFT);
amountColumn.getColumn().setWidth(100);
amountColumn.getColumn().setText("Amount");
amountColumn.setLabelProvider(new CellLabelProvider() {
@Override
public void update(ViewerCell cell) {
Item i = (Item) cell.getElement();
cell.setText(String.valueOf(i.amount));
}
});
</pre>
And last, change updateUI() method to calculate total costs correctly and update the table’s layout:
<pre>
private void updateUI(Model m) {
// Update the UI based on the contents of the specified model.
double total = 0;
for (Item i : m.items) {
total += i.costs * i.amount;
}
totalCost.setText(String.valueOf(total));

customer.setText(m.boughtBy);
date.setText(m.boughtAt);

productViewer.setInput(m);

nameColumn.getColumn().pack();
costColumn.getColumn().pack();
amountColumn.getColumn().pack();
}
</pre>
After these modifications, your application should look like in Figure 4.

[[File:simantics_db_tutorial_amount.png|thumb|center|700px|Figure 4: Amount column has been added into the table.]]

Completed code is in org.simantics.example.phases.AsyncPurchaseEditorFinal.java and completed ontology in example.pgraph.end

[[Category: Database Development]]
[[Category: Tutorials]]

FAQ

2013-12-05T16:44:17Z

Teemu Mätäsniemi:

== Working with the IDE ==

# Q: Product does not launch from IDE
#: INFO: org.eclipse.core.runtime.CoreException: Plug-in org.simantics.workbench was unable to load class org.simantics.workbench.internal.SimanticsWorkbenchApplication
#: java.lang.UnsupportedClassVersionError: org/simantics/workbench/internal/SimanticsWorkbenchApplication : Unsupported major.minor version 51.0
#: A: Product has been compiled with a different version of Java VM than the one being launched with
#: Resolutions: Check Windows->Preferences->Java->Compiler->Compiler compliance level
#: Resolutions: Check Windows->Preferences->Java->Installed JREs

== Graph debugger ==
# Q:Relation is not shown in Graph debugger
#: Resolutions: Check that the relation is inherited by using <R
#: Resolutions: Check that inverse relation has also been defined by L0.InverseOf. If the inverse relation is not defined the Graph debugger can not know how to navigate from object resource to subject resource.

Subgraph operations

2013-11-22T14:57:51Z

Teemu Mätäsniemi:

This page discusses three common operations that handle some subgraph of the whole Simantics database.
They all have very similar issues:
* Export/import
** What is exported?
** How are references from the exported part to the unexported part handled?
* Copy/paste
** What is copied?
** How are references from the copied part to the uncopied part handled?
* Removal
** What is removed?
** How are references between the removed and the unremoved resources handled?
Moreover in many cases copy/paste should behave similarly to export/import
and immediate removal of an imported object should usually restore the database to the
state before import.

== Baseline behavior ==

First, it should be made clear, that in some cases there are more than one reasonable behaviour
for the operations. For example, consider an applications where graphical and semantic objects are
separated and the same semantic object can be represented by multiple graphical objects.
When the user removes a graphical object, it is possible to remove also the corresponding semantic object,
but it is also sensible to remove only the graphical object. Sometimes the desired behaviour can
be asked from the user.

This means that the "correct" behaviour of each operation cannot be based purely on the shape of the
data but it should be customizable in each case separately. However, the customization cannot be
based solely on the type of the resource selected when the operation is requested. For example, a removal
of a library has a very simple behavior: its children should also be removed. However the children
of the library may each require different removal customization.

In order to collect all requirements for the customizable export/import, copy/paste and removal operations,
we first define the ''baseline behaviour'' for the operations. The idea is that we can then collect all current cases where
the operations should behave differently from the baseline and this helps for choosing the right customization
hooks.

Every operation targets some resource C. In some cases there can be more than one target,
but definitions should be easily generalizable for that case.

A resource is ''external to C'' if
there is a PartOf-path leading from the resource to the root library such
that the path does not include C. In other words, the set of resources external
to C are the resources that are reachable by ConsistsOf from root library without
going through C.

A resource is ''in the context of C'' if it reachable from C by statements
without going through any external resources.

[[Image:Extent.png]]

Now, we can define baseline behaviors:
* Export writes all resources in the context of C as internal resources to the transferable graph, together with all their statements excluding PartOf-statements from C. Resources external to C are referred by URI. C is marked the root of TG.
* Import creates all internal resources in TG file as new resources and adds all the statements in TG. The references to external resources are resolved by URI and if the resource does not exist a dummy resource is created. The root of the TG is attached by ConsistsOf to the target of the import operation.
* Copy/paste behaves just like export/import.
* Removal unlinks all the resource in the context of C from the external resources.

== Exceptions to baseline behavior ==

=== Export/import ===

Requirements
* Developing import contributors a deveploper wants to list URIs of externals and possible change some of them while importing. This features enables e.g. moving of data of diagrams although different type declarations are used. Also, other kind of usage is possible. This requirement relates to a resolving of URIs feature.
* Developing export contributors a developer wants to know all external URIs. Thus, the developer can be aware of data which is not included into exported data.

Design guidelines (derived from baseline behaviour and aids in export/import operations)
* Define a symbol of a component type in the context of the component type
* Define a diagram of a composite in the context of the composite

=== Copy/paste ===

* All diagram elements
** Template-diagram templatization tags must be removed (MOD.IsTemplatized)
** Generate fresh names for all copied elements within the target diagram's context
** Include element in the target diagram's ordered set
** Add database metadata comment for element copy

In addition, follow these rules for specific element types:
* Diagram reference elements
** Assertion: Copying must ensure that MOD.HasParentComponent correctly refers to the copied parent component
** Offset all copied element positions based on the paste specification
* Diagram connections
** Move connection to front of the target diagram's ordered set to push it behind all other elements
** Offset each route line in the connection by the offset specified in the paste specification based on the route line direction (horizontal/vertical)
* Diagram flags
** Offset all copied element positions based on the paste specification
** If flag is disconnected after copy, remove its L0.HasLabel.
** If flag and its counterpart were both copied and the flag pair is diagam-local, FlagLabelingScheme must be used to set the same L0.HasLabel for both flags.
* Diagram monitors
** If the component the monitors refers to (DIA.HasMonitorComponent) a component that was not included in the copy, the monitor element position must be recalculated to be:
*** original monitored element world position + offset from paste specification
* Other diagram elements
** Offset all copied element positions based on the paste specification

=== Removal ===

* Component types (and other types)
** If the type has instances the operation must be cancelled or all the instances must be removed
* Connection points, properties (and other relations)
** If the relation is used somewhere the operation must be cancelled or the corresponding statement must be removed.
* Components
** If component is created by mapping from a diagram the corresponding diagram elements should also be removed