diff --git a/features/org.eclipse.papyrus.moka.feature/feature.xml b/features/org.eclipse.papyrus.moka.feature/feature.xml
index 3409be2..93a969b 100644
--- a/features/org.eclipse.papyrus.moka.feature/feature.xml
+++ b/features/org.eclipse.papyrus.moka.feature/feature.xml
@@ -69,14 +69,9 @@
       <import plugin="org.eclipse.emf.common.ui" version="2.18.0" match="compatible"/>
       <import plugin="org.eclipse.papyrus.uml.diagram.common" version="4.0.0" match="greaterOrEqual"/>
       <import plugin="org.eclipse.papyrus.infra.services.validation" version="4.0.0" match="compatible"/>
-      <import plugin="org.eclipse.papyrus.moka.ui.tracepoint.view" version="4.0.0" match="compatible"/>
-      <import plugin="org.eclipse.papyrus.moka.trace.interfaces" version="4.0.0" match="compatible"/>
-      <import plugin="org.eclipse.papyrus.moka.trace" version="4.0.0" match="compatible"/>
-      <import plugin="org.eclipse.papyrus.moka.tracepoint.service" version="4.0.0" match="compatible"/>
       <import plugin="org.eclipse.papyrus.infra.ui" version="3.0.0" match="compatible"/>
       <import plugin="org.eclipse.swt" version="3.114.100" match="compatible"/>
       <import plugin="org.eclipse.papyrus.infra.widgets" version="4.0.0" match="compatible"/>
-      <import plugin="org.eclipse.papyrus.moka.trace.model" version="4.0.0" match="compatible"/>
       <import plugin="org.eclipse.papyrus.infra.services.decoration" version="3.0.0" match="compatible"/>
       <import plugin="org.eclipse.papyrus.infra.gmfdiag.commands" version="4.0.0" match="compatible"/>
       <import plugin="org.eclipse.papyrus.infra.services.markerlistener" version="3.0.0" match="compatible"/>
@@ -86,166 +81,218 @@
 
    <plugin
          id="org.aspectj.runtime"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.aspectj.weaver"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.equinox.weaving.aspectj"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.equinox.weaving.hook"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.kernel.scheduling"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.engine.uml"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.engine.uml.animation"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.engine.uml.debug"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.engine.uml.scheduling"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.engine.uml.time"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.engine.uml.time.interfaces"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.engine.uml.time.scheduling"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.fuml"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.fuml.assertionlibrary"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.fuml.interfaces"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.fuml.standardlibrary"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.fuml.validation"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.kernel"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.kernel.animation"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.kernel.debug"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.modeling.utils"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.pscs"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.pscs.interfaces"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.pscs.utils"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.pscs.validation"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.pssm"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.pssm.interfaces"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.pssm.validation"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.ui"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.utils"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.utils.ui"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.papyrus.moka.trace"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.papyrus.moka.trace.interfaces"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.papyrus.moka.trace.model"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.papyrus.moka.tracepoint.service"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.papyrus.moka.ui.tracepoint.view"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.paho.client.mqttv3"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.engine.schedulable"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.fuml.standardlibrary.ui"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.fuml.library"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
    <plugin
          id="org.eclipse.papyrus.moka.engine.uml.debug.ui"
+         download-size="0"
+         install-size="0"
          version="0.0.0"/>
 
 </feature>
diff --git a/features/org.eclipse.papyrus.moka.trace.feature/.project b/features/org.eclipse.papyrus.moka.trace.feature/.project
new file mode 100644
index 0000000..4ea65ae
--- /dev/null
+++ b/features/org.eclipse.papyrus.moka.trace.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.moka.trace.feature</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.pde.FeatureBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.FeatureNature</nature>
+	</natures>
+</projectDescription>
diff --git a/features/org.eclipse.papyrus.moka.trace.feature/build.properties b/features/org.eclipse.papyrus.moka.trace.feature/build.properties
new file mode 100644
index 0000000..64f93a9
--- /dev/null
+++ b/features/org.eclipse.papyrus.moka.trace.feature/build.properties
@@ -0,0 +1 @@
+bin.includes = feature.xml
diff --git a/features/org.eclipse.papyrus.moka.trace.feature/feature.xml b/features/org.eclipse.papyrus.moka.trace.feature/feature.xml
new file mode 100644
index 0000000..de7416d
--- /dev/null
+++ b/features/org.eclipse.papyrus.moka.trace.feature/feature.xml
@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="org.eclipse.papyrus.moka.trace.feature"
+      label="Moka Trace Service"
+      version="4.1.0.qualifier"
+      provider-name="CEA LIST">
+
+   <description>
+      Providing trace generation service.
+   </description>
+
+   <copyright>
+Copyright (c) 2018 CEA LIST.\n\
+All rights reserved. This program and the accompanying materials\n\
+are made available under the terms of the Eclipse Public License 2.0\n\
+which accompanies this distribution, and is available at\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n
+   </copyright>
+
+   <license>
+      [Enter License Description here.]
+   </license>
+
+   <requires>
+      <import feature="org.eclipse.papyrus.moka.feature" version="4.0.0" match="compatible"/>
+   </requires>
+
+   <plugin
+         id="org.eclipse.papyrus.moka.trace"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"/>
+
+   <plugin
+         id="org.eclipse.papyrus.moka.trace.source"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.papyrus.moka.trace.model.editor"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"/>
+
+   <plugin
+         id="org.eclipse.papyrus.moka.tracepoint.service"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"/>
+
+   <plugin
+         id="org.eclipse.papyrus.moka.ui.tracepoint.view"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"/>
+
+   <plugin
+         id="org.eclipse.papyrus.moka.trace.interfaces"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"/>
+
+   <plugin
+         id="org.eclipse.papyrus.moka.trace.model.edit"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"/>
+
+   <plugin
+         id="org.eclipse.papyrus.moka.trace.model"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"/>
+
+</feature>
diff --git a/features/org.eclipse.papyrus.moka.trace.feature/pom.xml b/features/org.eclipse.papyrus.moka.trace.feature/pom.xml
new file mode 100644
index 0000000..b97f31a
--- /dev/null
+++ b/features/org.eclipse.papyrus.moka.trace.feature/pom.xml
@@ -0,0 +1,18 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	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>
+
+	<!-- Parent POM (i.e., POM located in the feature folder) -->
+	<parent>
+		<groupId>org.eclipse.papyrus.moka</groupId>
+		<artifactId>org.eclipse.papyrus.moka.features</artifactId>
+		<version>4.1.0-SNAPSHOT</version>
+	</parent>
+
+	<!-- POM description -->
+	<artifactId>org.eclipse.papyrus.moka.trace.feature</artifactId>
+	<packaging>eclipse-feature</packaging>
+	<name>Moka Trace Service Feature</name>
+
+</project>
\ No newline at end of file
diff --git a/features/pom.xml b/features/pom.xml
index e7de5e8..b5d35de 100644
--- a/features/pom.xml
+++ b/features/pom.xml
@@ -18,6 +18,7 @@
 	<!-- Modules to build -->
 	<modules>
 		<module>org.eclipse.papyrus.moka.feature</module>
+		<module>org.eclipse.papyrus.moka.trace.feature</module>
 	</modules>
 	
 </project>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/.classpath b/plugins/org.eclipse.papyrus.moka.trace.model.edit/.classpath
new file mode 100644
index 0000000..26e67d6
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src-gen"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/.project b/plugins/org.eclipse.papyrus.moka.trace.model.edit/.project
new file mode 100644
index 0000000..99c8f4e
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.moka.trace.model.edit</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+	</natures>
+</projectDescription>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/META-INF/MANIFEST.MF b/plugins/org.eclipse.papyrus.moka.trace.model.edit/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..beb778b
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/META-INF/MANIFEST.MF
@@ -0,0 +1,17 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %pluginName
+Bundle-SymbolicName: org.eclipse.papyrus.moka.trace.model.edit;singleton:=true
+Automatic-Module-Name: org.eclipse.papyrus.moka.trace.model.edit
+Bundle-Version: 4.1.0.qualifier
+Bundle-ClassPath: .
+Bundle-Activator: org.eclipse.papyrus.moka.trace.model.mokatraceservice.provider.FumltracemodelEditPlugin$Implementation
+Bundle-Vendor: %providerName
+Bundle-Localization: plugin
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.papyrus.moka.trace.model.mokatraceservice.provider
+Require-Bundle: org.eclipse.core.runtime,
+ org.eclipse.papyrus.moka.trace.model;visibility:=reexport,
+ org.eclipse.emf.edit;visibility:=reexport,
+ org.eclipse.uml2.common.edit;visibility:=reexport
+Bundle-ActivationPolicy: lazy
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/about.html b/plugins/org.eclipse.papyrus.moka.trace.model.edit/about.html
new file mode 100644
index 0000000..8d57930
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/about.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>June 5, 2007</p>	
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0/">https://www.eclipse.org/legal/epl-2.0/</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+
+</body>
+</html>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/build.properties b/plugins/org.eclipse.papyrus.moka.trace.model.edit/build.properties
new file mode 100644
index 0000000..18cd638
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/build.properties
@@ -0,0 +1,21 @@
+# Copyright (c) 2019 CEA LIST and others.
+# 
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License 2.0
+# which accompanies this distribution, and is available at
+# https://www.eclipse.org/legal/epl-2.0/
+# 
+# SPDX-License-Identifier: EPL-2.0
+# 
+# Contributors:
+#   CEA LIST - Initial API and implementation
+# 
+
+bin.includes = .,\
+               icons/,\
+               META-INF/,\
+               plugin.xml,\
+               plugin.properties
+jars.compile.order = .
+source.. = src-gen/
+output.. = bin/
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/icons/full/obj16/MokaTrace.gif b/plugins/org.eclipse.papyrus.moka.trace.model.edit/icons/full/obj16/MokaTrace.gif
new file mode 100644
index 0000000..7b7c428
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/icons/full/obj16/MokaTrace.gif
Binary files differ
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/plugin.properties b/plugins/org.eclipse.papyrus.moka.trace.model.edit/plugin.properties
new file mode 100644
index 0000000..33fcd88
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/plugin.properties
@@ -0,0 +1,32 @@
+# Copyright (c) 2019 CEA LIST and others.
+# 
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License 2.0
+# which accompanies this distribution, and is available at
+# https://www.eclipse.org/legal/epl-2.0/
+# 
+# SPDX-License-Identifier: EPL-2.0
+# 
+# Contributors:
+#   CEA LIST - Initial API and implementation
+# 
+
+pluginName = Moka Trace Service Model Edit Support
+providerName = Eclipse Modeling Project
+
+_UI_CreateChild_text = {0}
+_UI_CreateChild_text2 = {1} {0}
+_UI_CreateChild_text3 = {1}
+_UI_CreateChild_tooltip = Create New {0} Under {1} Feature
+_UI_CreateChild_description = Create a new child of type {0} for the {1} feature of the selected {2}.
+_UI_CreateSibling_description = Create a new sibling of type {0} for the selected {2}, under the {1} feature of their parent.
+
+_UI_PropertyDescriptor_description = The {0} of the {1}
+
+_UI_MokaTrace_type = Moka Trace
+_UI_Unknown_type = Object
+
+_UI_Unknown_datatype= Value
+
+_UI_Unknown_feature = Unspecified
+
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/plugin.xml b/plugins/org.eclipse.papyrus.moka.trace.model.edit/plugin.xml
new file mode 100644
index 0000000..f2362c1
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/plugin.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<!--
+ Copyright (c) 2019 CEA LIST and others.
+ 
+ All rights reserved. This program and the accompanying materials
+ are made available under the terms of the Eclipse Public License 2.0
+ which accompanies this distribution, and is available at
+ https://www.eclipse.org/legal/epl-2.0/
+ 
+ SPDX-License-Identifier: EPL-2.0
+ 
+ Contributors:
+   CEA LIST - Initial API and implementation
+ 
+-->
+
+<plugin>
+
+   <extension point="org.eclipse.emf.edit.itemProviderAdapterFactories">
+      <!-- @generated mokatraceservice -->
+      <factory
+            uri="http://www.eclipse.org/papyrus/moka/trace"
+            class="org.eclipse.papyrus.moka.trace.model.mokatraceservice.provider.MokaTraceServiceItemProviderAdapterFactory"
+            supportedTypes=
+              "org.eclipse.emf.edit.provider.IEditingDomainItemProvider
+               org.eclipse.emf.edit.provider.IStructuredItemContentProvider
+               org.eclipse.emf.edit.provider.ITreeItemContentProvider
+               org.eclipse.emf.edit.provider.IItemLabelProvider
+               org.eclipse.emf.edit.provider.IItemPropertySource"/>
+   </extension>
+
+</plugin>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/pom.xml b/plugins/org.eclipse.papyrus.moka.trace.model.edit/pom.xml
new file mode 100644
index 0000000..2a02a7d
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/pom.xml
@@ -0,0 +1,18 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	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>
+	
+	<!-- Parent POM (i.e., Services) -->
+	<parent>
+		<groupId>org.eclipse.papyrus.moka</groupId>
+		<artifactId>org.eclipse.papyrus.moka.plugins</artifactId>
+		<version>4.1.0-SNAPSHOT</version>
+	</parent>
+
+	<!-- POM Description -->
+	<artifactId>org.eclipse.papyrus.moka.trace.model.edit</artifactId>
+	<packaging>eclipse-plugin</packaging>
+	<name>org.eclipse.papyrus.moka.trace.model.edit</name>
+	<description>Moka trace services model edit</description>
+
+</project>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/provider/FumltracemodelEditPlugin.java b/plugins/org.eclipse.papyrus.moka.trace.model.edit/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/provider/FumltracemodelEditPlugin.java
new file mode 100644
index 0000000..92e6228
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/provider/FumltracemodelEditPlugin.java
@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) 2019 CEA LIST and others.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *   CEA LIST - Initial API and implementation
+ * 
+ */
+package org.eclipse.papyrus.moka.trace.model.mokatraceservice.provider;
+
+import org.eclipse.emf.common.EMFPlugin;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+/**
+ * This is the central singleton for the Fumltracemodel edit plugin.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public final class FumltracemodelEditPlugin extends EMFPlugin {
+	/**
+	 * Keep track of the singleton.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final FumltracemodelEditPlugin INSTANCE = new FumltracemodelEditPlugin();
+
+	/**
+	 * Keep track of the singleton.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private static Implementation plugin;
+
+	/**
+	 * Create the instance.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public FumltracemodelEditPlugin() {
+		super
+		  (new ResourceLocator [] {
+		   });
+	}
+
+	/**
+	 * Returns the singleton instance of the Eclipse plugin.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the singleton instance.
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getPluginResourceLocator() {
+		return plugin;
+	}
+
+	/**
+	 * Returns the singleton instance of the Eclipse plugin.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the singleton instance.
+	 * @generated
+	 */
+	public static Implementation getPlugin() {
+		return plugin;
+	}
+
+	/**
+	 * The actual implementation of the Eclipse <b>Plugin</b>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static class Implementation extends EclipsePlugin {
+		/**
+		 * Creates an instance.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		public Implementation() {
+			super();
+
+			// Remember the static instance.
+			//
+			plugin = this;
+		}
+	}
+
+}
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/provider/MokaTraceItemProvider.java b/plugins/org.eclipse.papyrus.moka.trace.model.edit/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/provider/MokaTraceItemProvider.java
new file mode 100644
index 0000000..1cd5d10
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/provider/MokaTraceItemProvider.java
@@ -0,0 +1,132 @@
+/**
+ * Copyright (c) 2019 CEA LIST and others.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *   CEA LIST - Initial API and implementation
+ * 
+ */
+package org.eclipse.papyrus.moka.trace.model.mokatraceservice.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.papyrus.moka.trace.model.mokatraceservice.MokaTrace} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class MokaTraceItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public MokaTraceItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This returns MokaTrace.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/MokaTrace"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		return getString("_UI_MokaTrace_type");
+	}
+
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return FumltracemodelEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.edit/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/provider/MokaTraceServiceItemProviderAdapterFactory.java b/plugins/org.eclipse.papyrus.moka.trace.model.edit/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/provider/MokaTraceServiceItemProviderAdapterFactory.java
new file mode 100644
index 0000000..6ff0f89
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.edit/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/provider/MokaTraceServiceItemProviderAdapterFactory.java
@@ -0,0 +1,217 @@
+/**
+ * Copyright (c) 2019 CEA LIST and others.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *   CEA LIST - Initial API and implementation
+ * 
+ */
+package org.eclipse.papyrus.moka.trace.model.mokatraceservice.provider;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.edit.provider.ChangeNotifier;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.edit.provider.IChangeNotifier;
+import org.eclipse.emf.edit.provider.IDisposable;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.INotifyChangedListener;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+
+import org.eclipse.papyrus.moka.trace.model.mokatraceservice.util.MokaTraceServiceAdapterFactory;
+
+/**
+ * This is the factory that is used to provide the interfaces needed to support Viewers.
+ * The adapters generated by this factory convert EMF adapter notifications into calls to {@link #fireNotifyChanged fireNotifyChanged}.
+ * The adapters also support Eclipse property sheets.
+ * Note that most of the adapters are shared among multiple instances.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class MokaTraceServiceItemProviderAdapterFactory extends MokaTraceServiceAdapterFactory implements ComposeableAdapterFactory, IChangeNotifier, IDisposable {
+	/**
+	 * This keeps track of the root adapter factory that delegates to this adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ComposedAdapterFactory parentAdapterFactory;
+
+	/**
+	 * This is used to implement {@link org.eclipse.emf.edit.provider.IChangeNotifier}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IChangeNotifier changeNotifier = new ChangeNotifier();
+
+	/**
+	 * This keeps track of all the supported types checked by {@link #isFactoryForType isFactoryForType}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<Object> supportedTypes = new ArrayList<Object>();
+
+	/**
+	 * This constructs an instance.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public MokaTraceServiceItemProviderAdapterFactory() {
+		supportedTypes.add(IEditingDomainItemProvider.class);
+		supportedTypes.add(IStructuredItemContentProvider.class);
+		supportedTypes.add(ITreeItemContentProvider.class);
+		supportedTypes.add(IItemLabelProvider.class);
+		supportedTypes.add(IItemPropertySource.class);
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.papyrus.moka.trace.model.mokatraceservice.MokaTrace} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected MokaTraceItemProvider mokaTraceItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.papyrus.moka.trace.model.mokatraceservice.MokaTrace}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createMokaTraceAdapter() {
+		if (mokaTraceItemProvider == null) {
+			mokaTraceItemProvider = new MokaTraceItemProvider(this);
+		}
+
+		return mokaTraceItemProvider;
+	}
+
+	/**
+	 * This returns the root adapter factory that contains this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public ComposeableAdapterFactory getRootAdapterFactory() {
+		return parentAdapterFactory == null ? this : parentAdapterFactory.getRootAdapterFactory();
+	}
+
+	/**
+	 * This sets the composed adapter factory that contains this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setParentAdapterFactory(ComposedAdapterFactory parentAdapterFactory) {
+		this.parentAdapterFactory = parentAdapterFactory;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object type) {
+		return supportedTypes.contains(type) || super.isFactoryForType(type);
+	}
+
+	/**
+	 * This implementation substitutes the factory itself as the key for the adapter.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter adapt(Notifier notifier, Object type) {
+		return super.adapt(notifier, this);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object adapt(Object object, Object type) {
+		if (isFactoryForType(type)) {
+			Object adapter = super.adapt(object, type);
+			if (!(type instanceof Class<?>) || (((Class<?>)type).isInstance(adapter))) {
+				return adapter;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * This adds a listener.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void addListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.addListener(notifyChangedListener);
+	}
+
+	/**
+	 * This removes a listener.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void removeListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.removeListener(notifyChangedListener);
+	}
+
+	/**
+	 * This delegates to {@link #changeNotifier} and to {@link #parentAdapterFactory}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void fireNotifyChanged(Notification notification) {
+		changeNotifier.fireNotifyChanged(notification);
+
+		if (parentAdapterFactory != null) {
+			parentAdapterFactory.fireNotifyChanged(notification);
+		}
+	}
+
+	/**
+	 * This disposes all of the item providers created by this factory. 
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void dispose() {
+		if (mokaTraceItemProvider != null) mokaTraceItemProvider.dispose();
+	}
+
+}
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/.classpath b/plugins/org.eclipse.papyrus.moka.trace.model.editor/.classpath
new file mode 100644
index 0000000..26e67d6
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src-gen"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/.project b/plugins/org.eclipse.papyrus.moka.trace.model.editor/.project
new file mode 100644
index 0000000..4e9c444
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.moka.trace.model.editor</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+	</natures>
+</projectDescription>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/META-INF/MANIFEST.MF b/plugins/org.eclipse.papyrus.moka.trace.model.editor/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..ff8ef2e
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/META-INF/MANIFEST.MF
@@ -0,0 +1,19 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %pluginName
+Bundle-SymbolicName: org.eclipse.papyrus.moka.trace.model.editor;singleton:=true
+Automatic-Module-Name: org.eclipse.papyrus.moka.trace.model.editor
+Bundle-Version: 4.1.0.qualifier
+Bundle-ClassPath: .
+Bundle-Activator: org.eclipse.papyrus.moka.trace.model.mokatraceservice.presentation.FumltracemodelEditorPlugin$Implementation
+Bundle-Vendor: %providerName
+Bundle-Localization: plugin
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.papyrus.moka.trace.model.mokatraceservice.presentation
+Require-Bundle: org.eclipse.core.runtime,
+ org.eclipse.core.resources;visibility:=reexport,
+ org.eclipse.papyrus.moka.trace.model.edit;visibility:=reexport,
+ org.eclipse.emf.ecore.xmi;visibility:=reexport,
+ org.eclipse.emf.edit.ui;visibility:=reexport,
+ org.eclipse.ui.ide;visibility:=reexport
+Bundle-ActivationPolicy: lazy
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/about.html b/plugins/org.eclipse.papyrus.moka.trace.model.editor/about.html
new file mode 100644
index 0000000..8d57930
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/about.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>June 5, 2007</p>	
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0/">https://www.eclipse.org/legal/epl-2.0/</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+
+</body>
+</html>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/build.properties b/plugins/org.eclipse.papyrus.moka.trace.model.editor/build.properties
new file mode 100644
index 0000000..12dae42
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/build.properties
@@ -0,0 +1,21 @@
+# Copyright (c) 2019 CEA LIST and others.
+# 
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License 2.0
+# which accompanies this distribution, and is available at
+# https://www.eclipse.org/legal/epl-2.0/
+# 
+# SPDX-License-Identifier: EPL-2.0
+# 
+# Contributors:
+#   CEA LIST - Initial API and implementation
+# 
+
+bin.includes = .,\
+               icons/,\
+               META-INF/,\
+               plugin.xml,\
+               plugin.properties
+jars.compile.order = .
+source.. = src-gen/
+output.. = bin
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/icons/full/obj16/MokaTraceServiceModelFile.gif b/plugins/org.eclipse.papyrus.moka.trace.model.editor/icons/full/obj16/MokaTraceServiceModelFile.gif
new file mode 100644
index 0000000..22ec75b
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/icons/full/obj16/MokaTraceServiceModelFile.gif
Binary files differ
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/icons/full/wizban/NewMokaTraceService.gif b/plugins/org.eclipse.papyrus.moka.trace.model.editor/icons/full/wizban/NewMokaTraceService.gif
new file mode 100644
index 0000000..259704c
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/icons/full/wizban/NewMokaTraceService.gif
Binary files differ
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/plugin.properties b/plugins/org.eclipse.papyrus.moka.trace.model.editor/plugin.properties
new file mode 100644
index 0000000..de75543
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/plugin.properties
@@ -0,0 +1,64 @@
+# Copyright (c) 2019 CEA LIST and others.
+# 
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License 2.0
+# which accompanies this distribution, and is available at
+# https://www.eclipse.org/legal/epl-2.0/
+# 
+# SPDX-License-Identifier: EPL-2.0
+# 
+# Contributors:
+#   CEA LIST - Initial API and implementation
+# 
+
+pluginName = Moka Trace Service Model Editor
+providerName = Eclipse Modeling Project
+
+_UI_MokaTraceServiceEditor_menu = &MokaTraceService Editor
+
+_UI_CreateChild_menu_item = &New Child
+_UI_CreateSibling_menu_item = N&ew Sibling
+
+_UI_ShowPropertiesView_menu_item = Show &Properties View
+_UI_RefreshViewer_menu_item = &Refresh
+
+_UI_SelectionPage_label = Selection
+_UI_ParentPage_label = Parent
+_UI_ListPage_label = List
+_UI_TreePage_label = Tree
+_UI_TablePage_label = Table
+_UI_TreeWithColumnsPage_label = Tree with Columns
+_UI_ObjectColumn_label = Object
+_UI_SelfColumn_label = Self
+
+_UI_NoObjectSelected = Selected Nothing
+_UI_SingleObjectSelected = Selected Object: {0}
+_UI_MultiObjectSelected = Selected {0} Objects
+
+_UI_OpenEditorError_label = Open Editor
+
+_UI_Wizard_category = Example EMF Model Creation Wizards
+
+_UI_CreateModelError_message = Problems encountered in file "{0}"
+
+_UI_MokaTraceServiceModelWizard_label = MokaTraceService Model
+_UI_MokaTraceServiceModelWizard_description = Create a new MokaTraceService model
+
+_UI_MokaTraceServiceEditor_label = MokaTraceService Model Editor
+
+_UI_MokaTraceServiceEditorFilenameDefaultBase = My
+_UI_MokaTraceServiceEditorFilenameExtensions = mokatraceservice
+
+_UI_Wizard_label = New
+
+_WARN_FilenameExtension = The file name must end in ''.{0}''
+_WARN_FilenameExtensions = The file name must have one of the following extensions: {0}
+
+_UI_ModelObject = &Model Object
+_UI_XMLEncoding = &XML Encoding
+_UI_XMLEncodingChoices = UTF-8 ASCII UTF-16 UTF-16BE UTF-16LE ISO-8859-1
+_UI_Wizard_initial_object_description = Select a model object to create
+
+_UI_FileConflict_label = File Conflict
+_WARN_FileConflict = There are unsaved changes that conflict with changes made outside the editor.  Do you wish to discard this editor's changes?
+
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/plugin.xml b/plugins/org.eclipse.papyrus.moka.trace.model.editor/plugin.xml
new file mode 100644
index 0000000..ef78fc0
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/plugin.xml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<!--
+ Copyright (c) 2019 CEA LIST and others.
+ 
+ All rights reserved. This program and the accompanying materials
+ are made available under the terms of the Eclipse Public License 2.0
+ which accompanies this distribution, and is available at
+ https://www.eclipse.org/legal/epl-2.0/
+ 
+ SPDX-License-Identifier: EPL-2.0
+ 
+ Contributors:
+   CEA LIST - Initial API and implementation
+ 
+-->
+
+<plugin>
+
+   <extension point="org.eclipse.ui.newWizards">
+      <!-- @generated mokatraceservice -->
+      <category
+            id="org.eclipse.emf.ecore.Wizard.category.ID"
+            name="%_UI_Wizard_category"/>
+      <wizard
+            id="org.eclipse.papyrus.moka.trace.model.mokatraceservice.presentation.MokaTraceServiceModelWizardID"
+            name="%_UI_MokaTraceServiceModelWizard_label"
+            class="org.eclipse.papyrus.moka.trace.model.mokatraceservice.presentation.MokaTraceServiceModelWizard"
+            category="org.eclipse.emf.ecore.Wizard.category.ID"
+            icon="icons/full/obj16/MokaTraceServiceModelFile.gif">
+         <description>%_UI_MokaTraceServiceModelWizard_description</description>
+         <selection class="org.eclipse.core.resources.IResource"/>
+      </wizard>
+   </extension>
+
+   <extension point="org.eclipse.ui.editors">
+      <!-- @generated mokatraceservice -->
+      <editor
+            id="org.eclipse.papyrus.moka.trace.model.mokatraceservice.presentation.MokaTraceServiceEditorID"
+            name="%_UI_MokaTraceServiceEditor_label"
+            icon="icons/full/obj16/MokaTraceServiceModelFile.gif"
+            extensions="mtrace"
+            class="org.eclipse.papyrus.moka.trace.model.mokatraceservice.presentation.MokaTraceServiceEditor"
+            contributorClass="org.eclipse.papyrus.moka.trace.model.mokatraceservice.presentation.MokaTraceServiceActionBarContributor">
+      </editor>
+   </extension>
+
+</plugin>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/pom.xml b/plugins/org.eclipse.papyrus.moka.trace.model.editor/pom.xml
new file mode 100644
index 0000000..a1aeab5
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/pom.xml
@@ -0,0 +1,18 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	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>
+	
+	<!-- Parent POM (i.e., Services) -->
+	<parent>
+		<groupId>org.eclipse.papyrus.moka</groupId>
+		<artifactId>org.eclipse.papyrus.moka.plugins</artifactId>
+		<version>4.1.0-SNAPSHOT</version>
+	</parent>
+
+	<!-- POM Description -->
+	<artifactId>org.eclipse.papyrus.moka.trace.model.editor</artifactId>
+	<packaging>eclipse-plugin</packaging>
+	<name>org.eclipse.papyrus.moka.trace.model.editor</name>
+	<description>Moka trace services model editor</description>
+
+</project>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/FumltracemodelEditorPlugin.java b/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/FumltracemodelEditorPlugin.java
new file mode 100644
index 0000000..02e9ee1
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/FumltracemodelEditorPlugin.java
@@ -0,0 +1,103 @@
+/**
+ * Copyright (c) 2019 CEA LIST and others.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *   CEA LIST - Initial API and implementation
+ * 
+ */
+package org.eclipse.papyrus.moka.trace.model.mokatraceservice.presentation;
+
+import org.eclipse.emf.common.EMFPlugin;
+
+import org.eclipse.emf.common.ui.EclipseUIPlugin;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+/**
+ * This is the central singleton for the Fumltracemodel editor plugin.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public final class FumltracemodelEditorPlugin extends EMFPlugin {
+	/**
+	 * Keep track of the singleton.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final FumltracemodelEditorPlugin INSTANCE = new FumltracemodelEditorPlugin();
+	
+	/**
+	 * Keep track of the singleton.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private static Implementation plugin;
+
+	/**
+	 * Create the instance.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public FumltracemodelEditorPlugin() {
+		super
+			(new ResourceLocator [] {
+			});
+	}
+
+	/**
+	 * Returns the singleton instance of the Eclipse plugin.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the singleton instance.
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getPluginResourceLocator() {
+		return plugin;
+	}
+	
+	/**
+	 * Returns the singleton instance of the Eclipse plugin.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the singleton instance.
+	 * @generated
+	 */
+	public static Implementation getPlugin() {
+		return plugin;
+	}
+	
+	/**
+	 * The actual implementation of the Eclipse <b>Plugin</b>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static class Implementation extends EclipseUIPlugin {
+		/**
+		 * Creates an instance.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		public Implementation() {
+			super();
+	
+			// Remember the static instance.
+			//
+			plugin = this;
+		}
+	}
+
+}
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/MokaTraceServiceActionBarContributor.java b/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/MokaTraceServiceActionBarContributor.java
new file mode 100644
index 0000000..925b862
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/MokaTraceServiceActionBarContributor.java
@@ -0,0 +1,438 @@
+/**
+ * Copyright (c) 2019 CEA LIST and others.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *   CEA LIST - Initial API and implementation
+ * 
+ */
+package org.eclipse.papyrus.moka.trace.model.mokatraceservice.presentation;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.eclipse.emf.common.ui.viewer.IViewerProvider;
+
+import org.eclipse.emf.edit.domain.EditingDomain;
+import org.eclipse.emf.edit.domain.IEditingDomainProvider;
+
+import org.eclipse.emf.edit.ui.action.ControlAction;
+import org.eclipse.emf.edit.ui.action.CreateChildAction;
+import org.eclipse.emf.edit.ui.action.CreateSiblingAction;
+import org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor;
+import org.eclipse.emf.edit.ui.action.LoadResourceAction;
+import org.eclipse.emf.edit.ui.action.ValidateAction;
+
+import org.eclipse.jface.action.Action;
+import org.eclipse.jface.action.ActionContributionItem;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.action.IContributionItem;
+import org.eclipse.jface.action.IContributionManager;
+import org.eclipse.jface.action.IMenuListener;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.IToolBarManager;
+import org.eclipse.jface.action.MenuManager;
+import org.eclipse.jface.action.Separator;
+import org.eclipse.jface.action.SubContributionItem;
+
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.ISelectionProvider;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.Viewer;
+
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.PartInitException;
+
+/**
+ * This is the action bar contributor for the MokaTraceService model editor.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class MokaTraceServiceActionBarContributor
+	extends EditingDomainActionBarContributor
+	implements ISelectionChangedListener {
+	/**
+	 * This keeps track of the active editor.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IEditorPart activeEditorPart;
+
+	/**
+	 * This keeps track of the current selection provider.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ISelectionProvider selectionProvider;
+
+	/**
+	 * This action opens the Properties view.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IAction showPropertiesViewAction =
+		new Action(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_ShowPropertiesView_menu_item")) {
+			@Override
+			public void run() {
+				try {
+					getPage().showView("org.eclipse.ui.views.PropertySheet");
+				}
+				catch (PartInitException exception) {
+					FumltracemodelEditorPlugin.INSTANCE.log(exception);
+				}
+			}
+		};
+
+	/**
+	 * This action refreshes the viewer of the current editor if the editor
+	 * implements {@link org.eclipse.emf.common.ui.viewer.IViewerProvider}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IAction refreshViewerAction =
+		new Action(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_RefreshViewer_menu_item")) {
+			@Override
+			public boolean isEnabled() {
+				return activeEditorPart instanceof IViewerProvider;
+			}
+
+			@Override
+			public void run() {
+				if (activeEditorPart instanceof IViewerProvider) {
+					Viewer viewer = ((IViewerProvider)activeEditorPart).getViewer();
+					if (viewer != null) {
+						viewer.refresh();
+					}
+				}
+			}
+		};
+
+	/**
+	 * This will contain one {@link org.eclipse.emf.edit.ui.action.CreateChildAction} corresponding to each descriptor
+	 * generated for the current selection by the item provider.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<IAction> createChildActions;
+
+	/**
+	 * This is the menu manager into which menu contribution items should be added for CreateChild actions.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IMenuManager createChildMenuManager;
+
+	/**
+	 * This will contain one {@link org.eclipse.emf.edit.ui.action.CreateSiblingAction} corresponding to each descriptor
+	 * generated for the current selection by the item provider.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<IAction> createSiblingActions;
+
+	/**
+	 * This is the menu manager into which menu contribution items should be added for CreateSibling actions.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IMenuManager createSiblingMenuManager;
+
+	/**
+	 * This creates an instance of the contributor.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public MokaTraceServiceActionBarContributor() {
+		super(ADDITIONS_LAST_STYLE);
+		loadResourceAction = new LoadResourceAction();
+		validateAction = new ValidateAction();
+		controlAction = new ControlAction();
+	}
+
+	/**
+	 * This adds Separators for editor additions to the tool bar.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void contributeToToolBar(IToolBarManager toolBarManager) {
+		super.contributeToToolBar(toolBarManager);
+		toolBarManager.add(new Separator("mokatraceservice-settings"));
+		toolBarManager.add(new Separator("mokatraceservice-additions"));
+	}
+
+	/**
+	 * This adds to the menu bar a menu and some separators for editor additions,
+	 * as well as the sub-menus for object creation items.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void contributeToMenu(IMenuManager menuManager) {
+		super.contributeToMenu(menuManager);
+
+		IMenuManager submenuManager = new MenuManager(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_MokaTraceServiceEditor_menu"), "org.eclipse.papyrus.moka.trace.model.mokatraceserviceMenuID");
+		menuManager.insertAfter("additions", submenuManager);
+		submenuManager.add(new Separator("settings"));
+		submenuManager.add(new Separator("actions"));
+		submenuManager.add(new Separator("additions"));
+		submenuManager.add(new Separator("additions-end"));
+
+		// Prepare for CreateChild item addition or removal.
+		//
+		createChildMenuManager = new MenuManager(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_CreateChild_menu_item"));
+		submenuManager.insertBefore("additions", createChildMenuManager);
+
+		// Prepare for CreateSibling item addition or removal.
+		//
+		createSiblingMenuManager = new MenuManager(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_CreateSibling_menu_item"));
+		submenuManager.insertBefore("additions", createSiblingMenuManager);
+
+		// Force an update because Eclipse hides empty menus now.
+		//
+		submenuManager.addMenuListener
+			(new IMenuListener() {
+				 @Override
+				 public void menuAboutToShow(IMenuManager menuManager) {
+					 menuManager.updateAll(true);
+				 }
+			 });
+
+		addGlobalActions(submenuManager);
+	}
+
+	/**
+	 * When the active editor changes, this remembers the change and registers with it as a selection provider.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setActiveEditor(IEditorPart part) {
+		super.setActiveEditor(part);
+		activeEditorPart = part;
+
+		// Switch to the new selection provider.
+		//
+		if (selectionProvider != null) {
+			selectionProvider.removeSelectionChangedListener(this);
+		}
+		if (part == null) {
+			selectionProvider = null;
+		}
+		else {
+			selectionProvider = part.getSite().getSelectionProvider();
+			selectionProvider.addSelectionChangedListener(this);
+
+			// Fake a selection changed event to update the menus.
+			//
+			if (selectionProvider.getSelection() != null) {
+				selectionChanged(new SelectionChangedEvent(selectionProvider, selectionProvider.getSelection()));
+			}
+		}
+	}
+
+	/**
+	 * This implements {@link org.eclipse.jface.viewers.ISelectionChangedListener},
+	 * handling {@link org.eclipse.jface.viewers.SelectionChangedEvent}s by querying for the children and siblings
+	 * that can be added to the selected object and updating the menus accordingly.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void selectionChanged(SelectionChangedEvent event) {
+		// Remove any menu items for old selection.
+		//
+		if (createChildMenuManager != null) {
+			depopulateManager(createChildMenuManager, createChildActions);
+		}
+		if (createSiblingMenuManager != null) {
+			depopulateManager(createSiblingMenuManager, createSiblingActions);
+		}
+
+		// Query the new selection for appropriate new child/sibling descriptors
+		//
+		Collection<?> newChildDescriptors = null;
+		Collection<?> newSiblingDescriptors = null;
+
+		ISelection selection = event.getSelection();
+		if (selection instanceof IStructuredSelection && ((IStructuredSelection)selection).size() == 1) {
+			Object object = ((IStructuredSelection)selection).getFirstElement();
+
+			EditingDomain domain = ((IEditingDomainProvider)activeEditorPart).getEditingDomain();
+
+			newChildDescriptors = domain.getNewChildDescriptors(object, null);
+			newSiblingDescriptors = domain.getNewChildDescriptors(null, object);
+		}
+
+		// Generate actions for selection; populate and redraw the menus.
+		//
+		createChildActions = generateCreateChildActions(newChildDescriptors, selection);
+		createSiblingActions = generateCreateSiblingActions(newSiblingDescriptors, selection);
+
+		if (createChildMenuManager != null) {
+			populateManager(createChildMenuManager, createChildActions, null);
+			createChildMenuManager.update(true);
+		}
+		if (createSiblingMenuManager != null) {
+			populateManager(createSiblingMenuManager, createSiblingActions, null);
+			createSiblingMenuManager.update(true);
+		}
+	}
+
+	/**
+	 * This generates a {@link org.eclipse.emf.edit.ui.action.CreateChildAction} for each object in <code>descriptors</code>,
+	 * and returns the collection of these actions.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<IAction> generateCreateChildActions(Collection<?> descriptors, ISelection selection) {
+		Collection<IAction> actions = new ArrayList<IAction>();
+		if (descriptors != null) {
+			for (Object descriptor : descriptors) {
+				actions.add(new CreateChildAction(activeEditorPart, selection, descriptor));
+			}
+		}
+		return actions;
+	}
+
+	/**
+	 * This generates a {@link org.eclipse.emf.edit.ui.action.CreateSiblingAction} for each object in <code>descriptors</code>,
+	 * and returns the collection of these actions.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<IAction> generateCreateSiblingActions(Collection<?> descriptors, ISelection selection) {
+		Collection<IAction> actions = new ArrayList<IAction>();
+		if (descriptors != null) {
+			for (Object descriptor : descriptors) {
+				actions.add(new CreateSiblingAction(activeEditorPart, selection, descriptor));
+			}
+		}
+		return actions;
+	}
+
+	/**
+	 * This populates the specified <code>manager</code> with {@link org.eclipse.jface.action.ActionContributionItem}s
+	 * based on the {@link org.eclipse.jface.action.IAction}s contained in the <code>actions</code> collection,
+	 * by inserting them before the specified contribution item <code>contributionID</code>.
+	 * If <code>contributionID</code> is <code>null</code>, they are simply added.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void populateManager(IContributionManager manager, Collection<? extends IAction> actions, String contributionID) {
+		if (actions != null) {
+			for (IAction action : actions) {
+				if (contributionID != null) {
+					manager.insertBefore(contributionID, action);
+				}
+				else {
+					manager.add(action);
+				}
+			}
+		}
+	}
+		
+	/**
+	 * This removes from the specified <code>manager</code> all {@link org.eclipse.jface.action.ActionContributionItem}s
+	 * based on the {@link org.eclipse.jface.action.IAction}s contained in the <code>actions</code> collection.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void depopulateManager(IContributionManager manager, Collection<? extends IAction> actions) {
+		if (actions != null) {
+			IContributionItem[] items = manager.getItems();
+			for (int i = 0; i < items.length; i++) {
+				// Look into SubContributionItems
+				//
+				IContributionItem contributionItem = items[i];
+				while (contributionItem instanceof SubContributionItem) {
+					contributionItem = ((SubContributionItem)contributionItem).getInnerItem();
+				}
+
+				// Delete the ActionContributionItems with matching action.
+				//
+				if (contributionItem instanceof ActionContributionItem) {
+					IAction action = ((ActionContributionItem)contributionItem).getAction();
+					if (actions.contains(action)) {
+						manager.remove(contributionItem);
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * This populates the pop-up menu before it appears.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void menuAboutToShow(IMenuManager menuManager) {
+		super.menuAboutToShow(menuManager);
+		MenuManager submenuManager = null;
+
+		submenuManager = new MenuManager(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_CreateChild_menu_item"));
+		populateManager(submenuManager, createChildActions, null);
+		menuManager.insertBefore("edit", submenuManager);
+
+		submenuManager = new MenuManager(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_CreateSibling_menu_item"));
+		populateManager(submenuManager, createSiblingActions, null);
+		menuManager.insertBefore("edit", submenuManager);
+	}
+
+	/**
+	 * This inserts global actions before the "additions-end" separator.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void addGlobalActions(IMenuManager menuManager) {
+		menuManager.insertAfter("additions-end", new Separator("ui-actions"));
+		menuManager.insertAfter("ui-actions", showPropertiesViewAction);
+
+		refreshViewerAction.setEnabled(refreshViewerAction.isEnabled());		
+		menuManager.insertAfter("ui-actions", refreshViewerAction);
+
+		super.addGlobalActions(menuManager);
+	}
+
+	/**
+	 * This ensures that a delete action will clean up all references to deleted objects.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected boolean removeAllReferencesOnDelete() {
+		return true;
+	}
+
+}
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/MokaTraceServiceEditor.java b/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/MokaTraceServiceEditor.java
new file mode 100644
index 0000000..fb6c1db
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/MokaTraceServiceEditor.java
@@ -0,0 +1,1860 @@
+/**
+ * Copyright (c) 2019 CEA LIST and others.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *   CEA LIST - Initial API and implementation
+ * 
+ */
+package org.eclipse.papyrus.moka.trace.model.mokatraceservice.presentation;
+
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EventObject;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceChangeEvent;
+import org.eclipse.core.resources.IResourceChangeListener;
+import org.eclipse.core.resources.IResourceDelta;
+import org.eclipse.core.resources.IResourceDeltaVisitor;
+import org.eclipse.core.resources.ResourcesPlugin;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+
+import org.eclipse.jface.action.IMenuListener;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.IStatusLineManager;
+import org.eclipse.jface.action.IToolBarManager;
+import org.eclipse.jface.action.MenuManager;
+import org.eclipse.jface.action.Separator;
+
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.dialogs.ProgressMonitorDialog;
+
+import org.eclipse.jface.util.LocalSelectionTransfer;
+
+import org.eclipse.jface.viewers.ColumnWeightData;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.ISelectionProvider;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.ListViewer;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.jface.viewers.StructuredViewer;
+import org.eclipse.jface.viewers.TableLayout;
+import org.eclipse.jface.viewers.TableViewer;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.jface.viewers.Viewer;
+
+import org.eclipse.swt.SWT;
+
+import org.eclipse.swt.custom.CTabFolder;
+
+import org.eclipse.swt.dnd.DND;
+import org.eclipse.swt.dnd.FileTransfer;
+import org.eclipse.swt.dnd.Transfer;
+
+import org.eclipse.swt.events.ControlAdapter;
+import org.eclipse.swt.events.ControlEvent;
+
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.graphics.Rectangle;
+
+import org.eclipse.swt.layout.FillLayout;
+
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Menu;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.TableColumn;
+import org.eclipse.swt.widgets.Tree;
+import org.eclipse.swt.widgets.TreeColumn;
+
+import org.eclipse.ui.IActionBars;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IEditorSite;
+import org.eclipse.ui.IPartListener;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.PartInitException;
+
+import org.eclipse.ui.dialogs.SaveAsDialog;
+
+import org.eclipse.ui.ide.IGotoMarker;
+
+import org.eclipse.ui.part.FileEditorInput;
+import org.eclipse.ui.part.MultiPageEditorPart;
+
+import org.eclipse.ui.views.contentoutline.ContentOutline;
+import org.eclipse.ui.views.contentoutline.ContentOutlinePage;
+import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
+
+import org.eclipse.ui.views.properties.IPropertySheetPage;
+import org.eclipse.ui.views.properties.PropertySheet;
+import org.eclipse.ui.views.properties.PropertySheetPage;
+
+import org.eclipse.emf.common.command.BasicCommandStack;
+import org.eclipse.emf.common.command.Command;
+import org.eclipse.emf.common.command.CommandStack;
+import org.eclipse.emf.common.command.CommandStackListener;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.ui.MarkerHelper;
+import org.eclipse.emf.common.ui.ViewerPane;
+
+import org.eclipse.emf.common.ui.editor.ProblemEditorPart;
+
+import org.eclipse.emf.common.ui.viewer.IViewerProvider;
+
+import org.eclipse.emf.common.util.BasicDiagnostic;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.emf.common.util.URI;
+
+
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+
+import org.eclipse.emf.ecore.util.EContentAdapter;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+
+import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
+import org.eclipse.emf.edit.domain.EditingDomain;
+import org.eclipse.emf.edit.domain.IEditingDomainProvider;
+
+import org.eclipse.emf.edit.provider.AdapterFactoryItemDelegator;
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory;
+
+import org.eclipse.emf.edit.provider.resource.ResourceItemProviderAdapterFactory;
+
+import org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor;
+
+import org.eclipse.emf.edit.ui.celleditor.AdapterFactoryTreeEditor;
+
+import org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter;
+import org.eclipse.emf.edit.ui.dnd.LocalTransfer;
+import org.eclipse.emf.edit.ui.dnd.ViewerDragAdapter;
+
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
+import org.eclipse.emf.edit.ui.provider.UnwrappingSelectionProvider;
+
+import org.eclipse.emf.edit.ui.util.EditUIMarkerHelper;
+import org.eclipse.emf.edit.ui.util.EditUIUtil;
+
+import org.eclipse.emf.edit.ui.view.ExtendedPropertySheetPage;
+
+import org.eclipse.papyrus.moka.trace.model.mokatraceservice.provider.MokaTraceServiceItemProviderAdapterFactory;
+
+import org.eclipse.ui.actions.WorkspaceModifyOperation;
+
+
+/**
+ * This is an example of a MokaTraceService model editor.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class MokaTraceServiceEditor
+	extends MultiPageEditorPart
+	implements IEditingDomainProvider, ISelectionProvider, IMenuListener, IViewerProvider, IGotoMarker {
+	/**
+	 * This keeps track of the editing domain that is used to track all changes to the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected AdapterFactoryEditingDomain editingDomain;
+
+	/**
+	 * This is the one adapter factory used for providing views of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ComposedAdapterFactory adapterFactory;
+
+	/**
+	 * This is the content outline page.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IContentOutlinePage contentOutlinePage;
+
+	/**
+	 * This is a kludge...
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IStatusLineManager contentOutlineStatusLineManager;
+
+	/**
+	 * This is the content outline page's viewer.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected TreeViewer contentOutlineViewer;
+
+	/**
+	 * This is the property sheet page.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected List<PropertySheetPage> propertySheetPages = new ArrayList<PropertySheetPage>();
+
+	/**
+	 * This is the viewer that shadows the selection in the content outline.
+	 * The parent relation must be correctly defined for this to work.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected TreeViewer selectionViewer;
+
+	/**
+	 * This inverts the roll of parent and child in the content provider and show parents as a tree.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected TreeViewer parentViewer;
+
+	/**
+	 * This shows how a tree view works.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected TreeViewer treeViewer;
+
+	/**
+	 * This shows how a list view works.
+	 * A list viewer doesn't support icons.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ListViewer listViewer;
+
+	/**
+	 * This shows how a table view works.
+	 * A table can be used as a list with icons.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected TableViewer tableViewer;
+
+	/**
+	 * This shows how a tree view with columns works.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected TreeViewer treeViewerWithColumns;
+
+	/**
+	 * This keeps track of the active viewer pane, in the book.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ViewerPane currentViewerPane;
+
+	/**
+	 * This keeps track of the active content viewer, which may be either one of the viewers in the pages or the content outline viewer.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Viewer currentViewer;
+
+	/**
+	 * This listens to which ever viewer is active.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ISelectionChangedListener selectionChangedListener;
+
+	/**
+	 * This keeps track of all the {@link org.eclipse.jface.viewers.ISelectionChangedListener}s that are listening to this editor.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<ISelectionChangedListener> selectionChangedListeners = new ArrayList<ISelectionChangedListener>();
+
+	/**
+	 * This keeps track of the selection of the editor as a whole.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ISelection editorSelection = StructuredSelection.EMPTY;
+
+	/**
+	 * The MarkerHelper is responsible for creating workspace resource markers presented
+	 * in Eclipse's Problems View.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected MarkerHelper markerHelper = new EditUIMarkerHelper();
+
+	/**
+	 * This listens for when the outline becomes active
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IPartListener partListener =
+		new IPartListener() {
+			@Override
+			public void partActivated(IWorkbenchPart p) {
+				if (p instanceof ContentOutline) {
+					if (((ContentOutline)p).getCurrentPage() == contentOutlinePage) {
+						getActionBarContributor().setActiveEditor(MokaTraceServiceEditor.this);
+
+						setCurrentViewer(contentOutlineViewer);
+					}
+				}
+				else if (p instanceof PropertySheet) {
+					if (propertySheetPages.contains(((PropertySheet)p).getCurrentPage())) {
+						getActionBarContributor().setActiveEditor(MokaTraceServiceEditor.this);
+						handleActivate();
+					}
+				}
+				else if (p == MokaTraceServiceEditor.this) {
+					handleActivate();
+				}
+			}
+			@Override
+			public void partBroughtToTop(IWorkbenchPart p) {
+				// Ignore.
+			}
+			@Override
+			public void partClosed(IWorkbenchPart p) {
+				// Ignore.
+			}
+			@Override
+			public void partDeactivated(IWorkbenchPart p) {
+				// Ignore.
+			}
+			@Override
+			public void partOpened(IWorkbenchPart p) {
+				// Ignore.
+			}
+		};
+
+	/**
+	 * Resources that have been removed since last activation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<Resource> removedResources = new ArrayList<Resource>();
+
+	/**
+	 * Resources that have been changed since last activation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<Resource> changedResources = new ArrayList<Resource>();
+
+	/**
+	 * Resources that have been saved.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<Resource> savedResources = new ArrayList<Resource>();
+
+	/**
+	 * Map to store the diagnostic associated with a resource.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Map<Resource, Diagnostic> resourceToDiagnosticMap = new LinkedHashMap<Resource, Diagnostic>();
+
+	/**
+	 * Controls whether the problem indication should be updated.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected boolean updateProblemIndication = true;
+
+	/**
+	 * Adapter used to update the problem indication when resources are demanded loaded.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected EContentAdapter problemIndicationAdapter =
+		new EContentAdapter() {
+			protected boolean dispatching;
+
+			@Override
+			public void notifyChanged(Notification notification) {
+				if (notification.getNotifier() instanceof Resource) {
+					switch (notification.getFeatureID(Resource.class)) {
+						case Resource.RESOURCE__IS_LOADED:
+						case Resource.RESOURCE__ERRORS:
+						case Resource.RESOURCE__WARNINGS: {
+							Resource resource = (Resource)notification.getNotifier();
+							Diagnostic diagnostic = analyzeResourceProblems(resource, null);
+							if (diagnostic.getSeverity() != Diagnostic.OK) {
+								resourceToDiagnosticMap.put(resource, diagnostic);
+							}
+							else {
+								resourceToDiagnosticMap.remove(resource);
+							}
+							dispatchUpdateProblemIndication();
+							break;
+						}
+					}
+				}
+				else {
+					super.notifyChanged(notification);
+				}
+			}
+
+			protected void dispatchUpdateProblemIndication() {
+				if (updateProblemIndication && !dispatching) {
+					dispatching = true;
+					getSite().getShell().getDisplay().asyncExec
+						(new Runnable() {
+							 @Override
+							 public void run() {
+								 dispatching = false;
+								 updateProblemIndication();
+							 }
+						 });
+				}
+			}
+
+			@Override
+			protected void setTarget(Resource target) {
+				basicSetTarget(target);
+			}
+
+			@Override
+			protected void unsetTarget(Resource target) {
+				basicUnsetTarget(target);
+				resourceToDiagnosticMap.remove(target);
+				dispatchUpdateProblemIndication();
+			}
+		};
+
+	/**
+	 * This listens for workspace changes.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IResourceChangeListener resourceChangeListener =
+		new IResourceChangeListener() {
+			@Override
+			public void resourceChanged(IResourceChangeEvent event) {
+				IResourceDelta delta = event.getDelta();
+				try {
+					class ResourceDeltaVisitor implements IResourceDeltaVisitor {
+						protected ResourceSet resourceSet = editingDomain.getResourceSet();
+						protected Collection<Resource> changedResources = new ArrayList<Resource>();
+						protected Collection<Resource> removedResources = new ArrayList<Resource>();
+
+						@Override
+						public boolean visit(IResourceDelta delta) {
+							if (delta.getResource().getType() == IResource.FILE) {
+								if (delta.getKind() == IResourceDelta.REMOVED ||
+								    delta.getKind() == IResourceDelta.CHANGED && delta.getFlags() != IResourceDelta.MARKERS) {
+									Resource resource = resourceSet.getResource(URI.createPlatformResourceURI(delta.getFullPath().toString(), true), false);
+									if (resource != null) {
+										if (delta.getKind() == IResourceDelta.REMOVED) {
+											removedResources.add(resource);
+										}
+										else if (!savedResources.remove(resource)) {
+											changedResources.add(resource);
+										}
+									}
+								}
+								return false;
+							}
+
+							return true;
+						}
+
+						public Collection<Resource> getChangedResources() {
+							return changedResources;
+						}
+
+						public Collection<Resource> getRemovedResources() {
+							return removedResources;
+						}
+					}
+
+					final ResourceDeltaVisitor visitor = new ResourceDeltaVisitor();
+					delta.accept(visitor);
+
+					if (!visitor.getRemovedResources().isEmpty()) {
+						getSite().getShell().getDisplay().asyncExec
+							(new Runnable() {
+								 @Override
+								 public void run() {
+									 removedResources.addAll(visitor.getRemovedResources());
+									 if (!isDirty()) {
+										 getSite().getPage().closeEditor(MokaTraceServiceEditor.this, false);
+									 }
+								 }
+							 });
+					}
+
+					if (!visitor.getChangedResources().isEmpty()) {
+						getSite().getShell().getDisplay().asyncExec
+							(new Runnable() {
+								 @Override
+								 public void run() {
+									 changedResources.addAll(visitor.getChangedResources());
+									 if (getSite().getPage().getActiveEditor() == MokaTraceServiceEditor.this) {
+										 handleActivate();
+									 }
+								 }
+							 });
+					}
+				}
+				catch (CoreException exception) {
+					FumltracemodelEditorPlugin.INSTANCE.log(exception);
+				}
+			}
+		};
+
+	/**
+	 * Handles activation of the editor or it's associated views.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void handleActivate() {
+		// Recompute the read only state.
+		//
+		if (editingDomain.getResourceToReadOnlyMap() != null) {
+		  editingDomain.getResourceToReadOnlyMap().clear();
+
+		  // Refresh any actions that may become enabled or disabled.
+		  //
+		  setSelection(getSelection());
+		}
+
+		if (!removedResources.isEmpty()) {
+			if (handleDirtyConflict()) {
+				getSite().getPage().closeEditor(MokaTraceServiceEditor.this, false);
+			}
+			else {
+				removedResources.clear();
+				changedResources.clear();
+				savedResources.clear();
+			}
+		}
+		else if (!changedResources.isEmpty()) {
+			changedResources.removeAll(savedResources);
+			handleChangedResources();
+			changedResources.clear();
+			savedResources.clear();
+		}
+	}
+
+	/**
+	 * Handles what to do with changed resources on activation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void handleChangedResources() {
+		if (!changedResources.isEmpty() && (!isDirty() || handleDirtyConflict())) {
+			ResourceSet resourceSet = editingDomain.getResourceSet();
+			if (isDirty()) {
+				changedResources.addAll(resourceSet.getResources());
+			}
+			editingDomain.getCommandStack().flush();
+
+			updateProblemIndication = false;
+			for (Resource resource : changedResources) {
+				if (resource.isLoaded()) {
+					resource.unload();
+					try {
+						resource.load(resourceSet.getLoadOptions());
+					}
+					catch (IOException exception) {
+						if (!resourceToDiagnosticMap.containsKey(resource)) {
+							resourceToDiagnosticMap.put(resource, analyzeResourceProblems(resource, exception));
+						}
+					}
+				}
+			}
+
+			if (AdapterFactoryEditingDomain.isStale(editorSelection)) {
+				setSelection(StructuredSelection.EMPTY);
+			}
+
+			updateProblemIndication = true;
+			updateProblemIndication();
+		}
+	}
+
+	/**
+	 * Updates the problems indication with the information described in the specified diagnostic.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void updateProblemIndication() {
+		if (updateProblemIndication) {
+			BasicDiagnostic diagnostic =
+				new BasicDiagnostic
+					(Diagnostic.OK,
+					 "org.eclipse.papyrus.moka.trace.model.editor",
+					 0,
+					 null,
+					 new Object [] { editingDomain.getResourceSet() });
+			for (Diagnostic childDiagnostic : resourceToDiagnosticMap.values()) {
+				if (childDiagnostic.getSeverity() != Diagnostic.OK) {
+					diagnostic.add(childDiagnostic);
+				}
+			}
+
+			int lastEditorPage = getPageCount() - 1;
+			if (lastEditorPage >= 0 && getEditor(lastEditorPage) instanceof ProblemEditorPart) {
+				((ProblemEditorPart)getEditor(lastEditorPage)).setDiagnostic(diagnostic);
+				if (diagnostic.getSeverity() != Diagnostic.OK) {
+					setActivePage(lastEditorPage);
+				}
+			}
+			else if (diagnostic.getSeverity() != Diagnostic.OK) {
+				ProblemEditorPart problemEditorPart = new ProblemEditorPart();
+				problemEditorPart.setDiagnostic(diagnostic);
+				problemEditorPart.setMarkerHelper(markerHelper);
+				try {
+					addPage(++lastEditorPage, problemEditorPart, getEditorInput());
+					setPageText(lastEditorPage, problemEditorPart.getPartName());
+					setActivePage(lastEditorPage);
+					showTabs();
+				}
+				catch (PartInitException exception) {
+					FumltracemodelEditorPlugin.INSTANCE.log(exception);
+				}
+			}
+
+			if (markerHelper.hasMarkers(editingDomain.getResourceSet())) {
+				try {
+					markerHelper.updateMarkers(diagnostic);
+				}
+				catch (CoreException exception) {
+					FumltracemodelEditorPlugin.INSTANCE.log(exception);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Shows a dialog that asks if conflicting changes should be discarded.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected boolean handleDirtyConflict() {
+		return
+			MessageDialog.openQuestion
+				(getSite().getShell(),
+				 getString("_UI_FileConflict_label"),
+				 getString("_WARN_FileConflict"));
+	}
+
+	/**
+	 * This creates a model editor.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public MokaTraceServiceEditor() {
+		super();
+		initializeEditingDomain();
+	}
+
+	/**
+	 * This sets up the editing domain for the model editor.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void initializeEditingDomain() {
+		// Create an adapter factory that yields item providers.
+		//
+		adapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE);
+
+		adapterFactory.addAdapterFactory(new ResourceItemProviderAdapterFactory());
+		adapterFactory.addAdapterFactory(new MokaTraceServiceItemProviderAdapterFactory());
+		adapterFactory.addAdapterFactory(new ReflectiveItemProviderAdapterFactory());
+
+		// Create the command stack that will notify this editor as commands are executed.
+		//
+		BasicCommandStack commandStack = new BasicCommandStack();
+
+		// Add a listener to set the most recent command's affected objects to be the selection of the viewer with focus.
+		//
+		commandStack.addCommandStackListener
+			(new CommandStackListener() {
+				 @Override
+				 public void commandStackChanged(final EventObject event) {
+					 getContainer().getDisplay().asyncExec
+						 (new Runnable() {
+							  @Override
+							  public void run() {
+								  firePropertyChange(IEditorPart.PROP_DIRTY);
+
+								  // Try to select the affected objects.
+								  //
+								  Command mostRecentCommand = ((CommandStack)event.getSource()).getMostRecentCommand();
+								  if (mostRecentCommand != null) {
+									  setSelectionToViewer(mostRecentCommand.getAffectedObjects());
+								  }
+								  for (Iterator<PropertySheetPage> i = propertySheetPages.iterator(); i.hasNext(); ) {
+									  PropertySheetPage propertySheetPage = i.next();
+									  if (propertySheetPage.getControl() == null || propertySheetPage.getControl().isDisposed()) {
+										  i.remove();
+									  }
+									  else {
+										  propertySheetPage.refresh();
+									  }
+								  }
+							  }
+						  });
+				 }
+			 });
+
+		// Create the editing domain with a special command stack.
+		//
+		editingDomain = new AdapterFactoryEditingDomain(adapterFactory, commandStack, new HashMap<Resource, Boolean>());
+	}
+
+	/**
+	 * This is here for the listener to be able to call it.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+			@Override
+	protected void firePropertyChange(int action) {
+		super.firePropertyChange(action);
+	}
+
+	/**
+	 * This sets the selection into whichever viewer is active.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setSelectionToViewer(Collection<?> collection) {
+		final Collection<?> theSelection = collection;
+		// Make sure it's okay.
+		//
+		if (theSelection != null && !theSelection.isEmpty()) {
+			Runnable runnable =
+				new Runnable() {
+					@Override
+					public void run() {
+						// Try to select the items in the current content viewer of the editor.
+						//
+						if (currentViewer != null) {
+							currentViewer.setSelection(new StructuredSelection(theSelection.toArray()), true);
+						}
+					}
+				};
+			getSite().getShell().getDisplay().asyncExec(runnable);
+		}
+	}
+
+	/**
+	 * This returns the editing domain as required by the {@link IEditingDomainProvider} interface.
+	 * This is important for implementing the static methods of {@link AdapterFactoryEditingDomain}
+	 * and for supporting {@link org.eclipse.emf.edit.ui.action.CommandAction}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EditingDomain getEditingDomain() {
+		return editingDomain;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public class ReverseAdapterFactoryContentProvider extends AdapterFactoryContentProvider {
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		public ReverseAdapterFactoryContentProvider(AdapterFactory adapterFactory) {
+			super(adapterFactory);
+		}
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		@Override
+		public Object [] getElements(Object object) {
+			Object parent = super.getParent(object);
+			return (parent == null ? Collections.EMPTY_SET : Collections.singleton(parent)).toArray();
+		}
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		@Override
+		public Object [] getChildren(Object object) {
+			Object parent = super.getParent(object);
+			return (parent == null ? Collections.EMPTY_SET : Collections.singleton(parent)).toArray();
+		}
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		@Override
+		public boolean hasChildren(Object object) {
+			Object parent = super.getParent(object);
+			return parent != null;
+		}
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		@Override
+		public Object getParent(Object object) {
+			return null;
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setCurrentViewerPane(ViewerPane viewerPane) {
+		if (currentViewerPane != viewerPane) {
+			if (currentViewerPane != null) {
+				currentViewerPane.showFocus(false);
+			}
+			currentViewerPane = viewerPane;
+		}
+		setCurrentViewer(currentViewerPane.getViewer());
+	}
+
+	/**
+	 * This makes sure that one content viewer, either for the current page or the outline view, if it has focus,
+	 * is the current one.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setCurrentViewer(Viewer viewer) {
+		// If it is changing...
+		//
+		if (currentViewer != viewer) {
+			if (selectionChangedListener == null) {
+				// Create the listener on demand.
+				//
+				selectionChangedListener =
+					new ISelectionChangedListener() {
+						// This just notifies those things that are affected by the section.
+						//
+						@Override
+						public void selectionChanged(SelectionChangedEvent selectionChangedEvent) {
+							setSelection(selectionChangedEvent.getSelection());
+						}
+					};
+			}
+
+			// Stop listening to the old one.
+			//
+			if (currentViewer != null) {
+				currentViewer.removeSelectionChangedListener(selectionChangedListener);
+			}
+
+			// Start listening to the new one.
+			//
+			if (viewer != null) {
+				viewer.addSelectionChangedListener(selectionChangedListener);
+			}
+
+			// Remember it.
+			//
+			currentViewer = viewer;
+
+			// Set the editors selection based on the current viewer's selection.
+			//
+			setSelection(currentViewer == null ? StructuredSelection.EMPTY : currentViewer.getSelection());
+		}
+	}
+
+	/**
+	 * This returns the viewer as required by the {@link IViewerProvider} interface.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Viewer getViewer() {
+		return currentViewer;
+	}
+
+	/**
+	 * This creates a context menu for the viewer and adds a listener as well registering the menu for extension.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void createContextMenuFor(StructuredViewer viewer) {
+		MenuManager contextMenu = new MenuManager("#PopUp");
+		contextMenu.add(new Separator("additions"));
+		contextMenu.setRemoveAllWhenShown(true);
+		contextMenu.addMenuListener(this);
+		Menu menu= contextMenu.createContextMenu(viewer.getControl());
+		viewer.getControl().setMenu(menu);
+		getSite().registerContextMenu(contextMenu, new UnwrappingSelectionProvider(viewer));
+
+		int dndOperations = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
+		Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance(), LocalSelectionTransfer.getTransfer(), FileTransfer.getInstance() };
+		viewer.addDragSupport(dndOperations, transfers, new ViewerDragAdapter(viewer));
+		viewer.addDropSupport(dndOperations, transfers, new EditingDomainViewerDropAdapter(editingDomain, viewer));
+	}
+
+	/**
+	 * This is the method called to load a resource into the editing domain's resource set based on the editor's input.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void createModel() {
+		URI resourceURI = EditUIUtil.getURI(getEditorInput(), editingDomain.getResourceSet().getURIConverter());
+		Exception exception = null;
+		Resource resource = null;
+		try {
+			// Load the resource through the editing domain.
+			//
+			resource = editingDomain.getResourceSet().getResource(resourceURI, true);
+		}
+		catch (Exception e) {
+			exception = e;
+			resource = editingDomain.getResourceSet().getResource(resourceURI, false);
+		}
+
+		Diagnostic diagnostic = analyzeResourceProblems(resource, exception);
+		if (diagnostic.getSeverity() != Diagnostic.OK) {
+			resourceToDiagnosticMap.put(resource,  analyzeResourceProblems(resource, exception));
+		}
+		editingDomain.getResourceSet().eAdapters().add(problemIndicationAdapter);
+	}
+
+	/**
+	 * Returns a diagnostic describing the errors and warnings listed in the resource
+	 * and the specified exception (if any).
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Diagnostic analyzeResourceProblems(Resource resource, Exception exception) {
+		boolean hasErrors = !resource.getErrors().isEmpty();
+		if (hasErrors || !resource.getWarnings().isEmpty()) {
+			BasicDiagnostic basicDiagnostic =
+				new BasicDiagnostic
+					(hasErrors ? Diagnostic.ERROR : Diagnostic.WARNING,
+					 "org.eclipse.papyrus.moka.trace.model.editor",
+					 0,
+					 getString("_UI_CreateModelError_message", resource.getURI()),
+					 new Object [] { exception == null ? (Object)resource : exception });
+			basicDiagnostic.merge(EcoreUtil.computeDiagnostic(resource, true));
+			return basicDiagnostic;
+		}
+		else if (exception != null) {
+			return
+				new BasicDiagnostic
+					(Diagnostic.ERROR,
+					 "org.eclipse.papyrus.moka.trace.model.editor",
+					 0,
+					 getString("_UI_CreateModelError_message", resource.getURI()),
+					 new Object[] { exception });
+		}
+		else {
+			return Diagnostic.OK_INSTANCE;
+		}
+	}
+
+	/**
+	 * This is the method used by the framework to install your own controls.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void createPages() {
+		// Creates the model from the editor input
+		//
+		createModel();
+
+		// Only creates the other pages if there is something that can be edited
+		//
+		if (!getEditingDomain().getResourceSet().getResources().isEmpty()) {
+			// Create a page for the selection tree view.
+			//
+			{
+				ViewerPane viewerPane =
+					new ViewerPane(getSite().getPage(), MokaTraceServiceEditor.this) {
+						@Override
+						public Viewer createViewer(Composite composite) {
+							Tree tree = new Tree(composite, SWT.MULTI);
+							TreeViewer newTreeViewer = new TreeViewer(tree);
+							return newTreeViewer;
+						}
+						@Override
+						public void requestActivation() {
+							super.requestActivation();
+							setCurrentViewerPane(this);
+						}
+					};
+				viewerPane.createControl(getContainer());
+
+				selectionViewer = (TreeViewer)viewerPane.getViewer();
+				selectionViewer.setContentProvider(new AdapterFactoryContentProvider(adapterFactory));
+				selectionViewer.setUseHashlookup(true);
+
+				selectionViewer.setLabelProvider(new AdapterFactoryLabelProvider(adapterFactory));
+				selectionViewer.setInput(editingDomain.getResourceSet());
+				selectionViewer.setSelection(new StructuredSelection(editingDomain.getResourceSet().getResources().get(0)), true);
+				viewerPane.setTitle(editingDomain.getResourceSet());
+
+				new AdapterFactoryTreeEditor(selectionViewer.getTree(), adapterFactory);
+
+				createContextMenuFor(selectionViewer);
+				int pageIndex = addPage(viewerPane.getControl());
+				setPageText(pageIndex, getString("_UI_SelectionPage_label"));
+			}
+
+			// Create a page for the parent tree view.
+			//
+			{
+				ViewerPane viewerPane =
+					new ViewerPane(getSite().getPage(), MokaTraceServiceEditor.this) {
+						@Override
+						public Viewer createViewer(Composite composite) {
+							Tree tree = new Tree(composite, SWT.MULTI);
+							TreeViewer newTreeViewer = new TreeViewer(tree);
+							return newTreeViewer;
+						}
+						@Override
+						public void requestActivation() {
+							super.requestActivation();
+							setCurrentViewerPane(this);
+						}
+					};
+				viewerPane.createControl(getContainer());
+
+				parentViewer = (TreeViewer)viewerPane.getViewer();
+				parentViewer.setAutoExpandLevel(30);
+				parentViewer.setContentProvider(new ReverseAdapterFactoryContentProvider(adapterFactory));
+				parentViewer.setLabelProvider(new AdapterFactoryLabelProvider(adapterFactory));
+
+				createContextMenuFor(parentViewer);
+				int pageIndex = addPage(viewerPane.getControl());
+				setPageText(pageIndex, getString("_UI_ParentPage_label"));
+			}
+
+			// This is the page for the list viewer
+			//
+			{
+				ViewerPane viewerPane =
+					new ViewerPane(getSite().getPage(), MokaTraceServiceEditor.this) {
+						@Override
+						public Viewer createViewer(Composite composite) {
+							return new ListViewer(composite);
+						}
+						@Override
+						public void requestActivation() {
+							super.requestActivation();
+							setCurrentViewerPane(this);
+						}
+					};
+				viewerPane.createControl(getContainer());
+				listViewer = (ListViewer)viewerPane.getViewer();
+				listViewer.setContentProvider(new AdapterFactoryContentProvider(adapterFactory));
+				listViewer.setLabelProvider(new AdapterFactoryLabelProvider(adapterFactory));
+
+				createContextMenuFor(listViewer);
+				int pageIndex = addPage(viewerPane.getControl());
+				setPageText(pageIndex, getString("_UI_ListPage_label"));
+			}
+
+			// This is the page for the tree viewer
+			//
+			{
+				ViewerPane viewerPane =
+					new ViewerPane(getSite().getPage(), MokaTraceServiceEditor.this) {
+						@Override
+						public Viewer createViewer(Composite composite) {
+							return new TreeViewer(composite);
+						}
+						@Override
+						public void requestActivation() {
+							super.requestActivation();
+							setCurrentViewerPane(this);
+						}
+					};
+				viewerPane.createControl(getContainer());
+				treeViewer = (TreeViewer)viewerPane.getViewer();
+				treeViewer.setContentProvider(new AdapterFactoryContentProvider(adapterFactory));
+				treeViewer.setLabelProvider(new AdapterFactoryLabelProvider(adapterFactory));
+
+				new AdapterFactoryTreeEditor(treeViewer.getTree(), adapterFactory);
+
+				createContextMenuFor(treeViewer);
+				int pageIndex = addPage(viewerPane.getControl());
+				setPageText(pageIndex, getString("_UI_TreePage_label"));
+			}
+
+			// This is the page for the table viewer.
+			//
+			{
+				ViewerPane viewerPane =
+					new ViewerPane(getSite().getPage(), MokaTraceServiceEditor.this) {
+						@Override
+						public Viewer createViewer(Composite composite) {
+							return new TableViewer(composite);
+						}
+						@Override
+						public void requestActivation() {
+							super.requestActivation();
+							setCurrentViewerPane(this);
+						}
+					};
+				viewerPane.createControl(getContainer());
+				tableViewer = (TableViewer)viewerPane.getViewer();
+
+				Table table = tableViewer.getTable();
+				TableLayout layout = new TableLayout();
+				table.setLayout(layout);
+				table.setHeaderVisible(true);
+				table.setLinesVisible(true);
+
+				TableColumn objectColumn = new TableColumn(table, SWT.NONE);
+				layout.addColumnData(new ColumnWeightData(3, 100, true));
+				objectColumn.setText(getString("_UI_ObjectColumn_label"));
+				objectColumn.setResizable(true);
+
+				TableColumn selfColumn = new TableColumn(table, SWT.NONE);
+				layout.addColumnData(new ColumnWeightData(2, 100, true));
+				selfColumn.setText(getString("_UI_SelfColumn_label"));
+				selfColumn.setResizable(true);
+
+				tableViewer.setColumnProperties(new String [] {"a", "b"});
+				tableViewer.setContentProvider(new AdapterFactoryContentProvider(adapterFactory));
+				tableViewer.setLabelProvider(new AdapterFactoryLabelProvider(adapterFactory));
+
+				createContextMenuFor(tableViewer);
+				int pageIndex = addPage(viewerPane.getControl());
+				setPageText(pageIndex, getString("_UI_TablePage_label"));
+			}
+
+			// This is the page for the table tree viewer.
+			//
+			{
+				ViewerPane viewerPane =
+					new ViewerPane(getSite().getPage(), MokaTraceServiceEditor.this) {
+						@Override
+						public Viewer createViewer(Composite composite) {
+							return new TreeViewer(composite);
+						}
+						@Override
+						public void requestActivation() {
+							super.requestActivation();
+							setCurrentViewerPane(this);
+						}
+					};
+				viewerPane.createControl(getContainer());
+
+				treeViewerWithColumns = (TreeViewer)viewerPane.getViewer();
+
+				Tree tree = treeViewerWithColumns.getTree();
+				tree.setLayoutData(new FillLayout());
+				tree.setHeaderVisible(true);
+				tree.setLinesVisible(true);
+
+				TreeColumn objectColumn = new TreeColumn(tree, SWT.NONE);
+				objectColumn.setText(getString("_UI_ObjectColumn_label"));
+				objectColumn.setResizable(true);
+				objectColumn.setWidth(250);
+
+				TreeColumn selfColumn = new TreeColumn(tree, SWT.NONE);
+				selfColumn.setText(getString("_UI_SelfColumn_label"));
+				selfColumn.setResizable(true);
+				selfColumn.setWidth(200);
+
+				treeViewerWithColumns.setColumnProperties(new String [] {"a", "b"});
+				treeViewerWithColumns.setContentProvider(new AdapterFactoryContentProvider(adapterFactory));
+				treeViewerWithColumns.setLabelProvider(new AdapterFactoryLabelProvider(adapterFactory));
+
+				createContextMenuFor(treeViewerWithColumns);
+				int pageIndex = addPage(viewerPane.getControl());
+				setPageText(pageIndex, getString("_UI_TreeWithColumnsPage_label"));
+			}
+
+			getSite().getShell().getDisplay().asyncExec
+				(new Runnable() {
+					 @Override
+					 public void run() {
+						 if (!getContainer().isDisposed()) {
+							 setActivePage(0);
+						 }
+					 }
+				 });
+		}
+
+		// Ensures that this editor will only display the page's tab
+		// area if there are more than one page
+		//
+		getContainer().addControlListener
+			(new ControlAdapter() {
+				boolean guard = false;
+				@Override
+				public void controlResized(ControlEvent event) {
+					if (!guard) {
+						guard = true;
+						hideTabs();
+						guard = false;
+					}
+				}
+			 });
+
+		getSite().getShell().getDisplay().asyncExec
+			(new Runnable() {
+				 @Override
+				 public void run() {
+					 updateProblemIndication();
+				 }
+			 });
+	}
+
+	/**
+	 * If there is just one page in the multi-page editor part,
+	 * this hides the single tab at the bottom.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void hideTabs() {
+		if (getPageCount() <= 1) {
+			setPageText(0, "");
+			if (getContainer() instanceof CTabFolder) {
+				Point point = getContainer().getSize();
+				Rectangle clientArea = getContainer().getClientArea();
+				getContainer().setSize(point.x,  2 * point.y - clientArea.height - clientArea.y);
+			}
+		}
+	}
+
+	/**
+	 * If there is more than one page in the multi-page editor part,
+	 * this shows the tabs at the bottom.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void showTabs() {
+		if (getPageCount() > 1) {
+			setPageText(0, getString("_UI_SelectionPage_label"));
+			if (getContainer() instanceof CTabFolder) {
+				Point point = getContainer().getSize();
+				Rectangle clientArea = getContainer().getClientArea();
+				getContainer().setSize(point.x, clientArea.height + clientArea.y);
+			}
+		}
+	}
+
+	/**
+	 * This is used to track the active viewer.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void pageChange(int pageIndex) {
+		super.pageChange(pageIndex);
+
+		if (contentOutlinePage != null) {
+			handleContentOutlineSelection(contentOutlinePage.getSelection());
+		}
+	}
+
+	/**
+	 * This is how the framework determines which interfaces we implement.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public <T> T getAdapter(Class<T> key) {
+		if (key.equals(IContentOutlinePage.class)) {
+			return showOutlineView() ? key.cast(getContentOutlinePage()) : null;
+		}
+		else if (key.equals(IPropertySheetPage.class)) {
+			return key.cast(getPropertySheetPage());
+		}
+		else if (key.equals(IGotoMarker.class)) {
+			return key.cast(this);
+		}
+		else {
+			return super.getAdapter(key);
+		}
+	}
+
+	/**
+	 * This accesses a cached version of the content outliner.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public IContentOutlinePage getContentOutlinePage() {
+		if (contentOutlinePage == null) {
+			// The content outline is just a tree.
+			//
+			class MyContentOutlinePage extends ContentOutlinePage {
+				@Override
+				public void createControl(Composite parent) {
+					super.createControl(parent);
+					contentOutlineViewer = getTreeViewer();
+					contentOutlineViewer.addSelectionChangedListener(this);
+
+					// Set up the tree viewer.
+					//
+					contentOutlineViewer.setUseHashlookup(true);
+					contentOutlineViewer.setContentProvider(new AdapterFactoryContentProvider(adapterFactory));
+					contentOutlineViewer.setLabelProvider(new AdapterFactoryLabelProvider(adapterFactory));
+					contentOutlineViewer.setInput(editingDomain.getResourceSet());
+
+					// Make sure our popups work.
+					//
+					createContextMenuFor(contentOutlineViewer);
+
+					if (!editingDomain.getResourceSet().getResources().isEmpty()) {
+					  // Select the root object in the view.
+					  //
+					  contentOutlineViewer.setSelection(new StructuredSelection(editingDomain.getResourceSet().getResources().get(0)), true);
+					}
+				}
+
+				@Override
+				public void makeContributions(IMenuManager menuManager, IToolBarManager toolBarManager, IStatusLineManager statusLineManager) {
+					super.makeContributions(menuManager, toolBarManager, statusLineManager);
+					contentOutlineStatusLineManager = statusLineManager;
+				}
+
+				@Override
+				public void setActionBars(IActionBars actionBars) {
+					super.setActionBars(actionBars);
+					getActionBarContributor().shareGlobalActions(this, actionBars);
+				}
+			}
+
+			contentOutlinePage = new MyContentOutlinePage();
+
+			// Listen to selection so that we can handle it is a special way.
+			//
+			contentOutlinePage.addSelectionChangedListener
+				(new ISelectionChangedListener() {
+					 // This ensures that we handle selections correctly.
+					 //
+					 @Override
+					 public void selectionChanged(SelectionChangedEvent event) {
+						 handleContentOutlineSelection(event.getSelection());
+					 }
+				 });
+		}
+
+		return contentOutlinePage;
+	}
+
+	/**
+	 * This accesses a cached version of the property sheet.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public IPropertySheetPage getPropertySheetPage() {
+		PropertySheetPage propertySheetPage =
+			new ExtendedPropertySheetPage(editingDomain, ExtendedPropertySheetPage.Decoration.NONE, null, 0, false) {
+				@Override
+				public void setSelectionToViewer(List<?> selection) {
+					MokaTraceServiceEditor.this.setSelectionToViewer(selection);
+					MokaTraceServiceEditor.this.setFocus();
+				}
+
+				@Override
+				public void setActionBars(IActionBars actionBars) {
+					super.setActionBars(actionBars);
+					getActionBarContributor().shareGlobalActions(this, actionBars);
+				}
+			};
+		propertySheetPage.setPropertySourceProvider(new AdapterFactoryContentProvider(adapterFactory));
+		propertySheetPages.add(propertySheetPage);
+
+		return propertySheetPage;
+	}
+
+	/**
+	 * This deals with how we want selection in the outliner to affect the other views.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void handleContentOutlineSelection(ISelection selection) {
+		if (currentViewerPane != null && !selection.isEmpty() && selection instanceof IStructuredSelection) {
+			Iterator<?> selectedElements = ((IStructuredSelection)selection).iterator();
+			if (selectedElements.hasNext()) {
+				// Get the first selected element.
+				//
+				Object selectedElement = selectedElements.next();
+
+				// If it's the selection viewer, then we want it to select the same selection as this selection.
+				//
+				if (currentViewerPane.getViewer() == selectionViewer) {
+					ArrayList<Object> selectionList = new ArrayList<Object>();
+					selectionList.add(selectedElement);
+					while (selectedElements.hasNext()) {
+						selectionList.add(selectedElements.next());
+					}
+
+					// Set the selection to the widget.
+					//
+					selectionViewer.setSelection(new StructuredSelection(selectionList));
+				}
+				else {
+					// Set the input to the widget.
+					//
+					if (currentViewerPane.getViewer().getInput() != selectedElement) {
+						currentViewerPane.getViewer().setInput(selectedElement);
+						currentViewerPane.setTitle(selectedElement);
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * This is for implementing {@link IEditorPart} and simply tests the command stack.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isDirty() {
+		return ((BasicCommandStack)editingDomain.getCommandStack()).isSaveNeeded();
+	}
+
+	/**
+	 * This is for implementing {@link IEditorPart} and simply saves the model file.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void doSave(IProgressMonitor progressMonitor) {
+		// Save only resources that have actually changed.
+		//
+		final Map<Object, Object> saveOptions = new HashMap<Object, Object>();
+		saveOptions.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED, Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER);
+		saveOptions.put(Resource.OPTION_LINE_DELIMITER, Resource.OPTION_LINE_DELIMITER_UNSPECIFIED);
+
+		// Do the work within an operation because this is a long running activity that modifies the workbench.
+		//
+		WorkspaceModifyOperation operation =
+			new WorkspaceModifyOperation() {
+				// This is the method that gets invoked when the operation runs.
+				//
+				@Override
+				public void execute(IProgressMonitor monitor) {
+					// Save the resources to the file system.
+					//
+					boolean first = true;
+					List<Resource> resources = editingDomain.getResourceSet().getResources();
+					for (int i = 0; i < resources.size(); ++i) {
+						Resource resource = resources.get(i);
+						if ((first || !resource.getContents().isEmpty() || isPersisted(resource)) && !editingDomain.isReadOnly(resource)) {
+							try {
+								long timeStamp = resource.getTimeStamp();
+								resource.save(saveOptions);
+								if (resource.getTimeStamp() != timeStamp) {
+									savedResources.add(resource);
+								}
+							}
+							catch (Exception exception) {
+								resourceToDiagnosticMap.put(resource, analyzeResourceProblems(resource, exception));
+							}
+							first = false;
+						}
+					}
+				}
+			};
+
+		updateProblemIndication = false;
+		try {
+			// This runs the options, and shows progress.
+			//
+			new ProgressMonitorDialog(getSite().getShell()).run(true, false, operation);
+
+			// Refresh the necessary state.
+			//
+			((BasicCommandStack)editingDomain.getCommandStack()).saveIsDone();
+			firePropertyChange(IEditorPart.PROP_DIRTY);
+		}
+		catch (Exception exception) {
+			// Something went wrong that shouldn't.
+			//
+			FumltracemodelEditorPlugin.INSTANCE.log(exception);
+		}
+		updateProblemIndication = true;
+		updateProblemIndication();
+	}
+
+	/**
+	 * This returns whether something has been persisted to the URI of the specified resource.
+	 * The implementation uses the URI converter from the editor's resource set to try to open an input stream.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected boolean isPersisted(Resource resource) {
+		boolean result = false;
+		try {
+			InputStream stream = editingDomain.getResourceSet().getURIConverter().createInputStream(resource.getURI());
+			if (stream != null) {
+				result = true;
+				stream.close();
+			}
+		}
+		catch (IOException e) {
+			// Ignore
+		}
+		return result;
+	}
+
+	/**
+	 * This always returns true because it is not currently supported.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isSaveAsAllowed() {
+		return true;
+	}
+
+	/**
+	 * This also changes the editor's input.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void doSaveAs() {
+		SaveAsDialog saveAsDialog = new SaveAsDialog(getSite().getShell());
+		saveAsDialog.open();
+		IPath path = saveAsDialog.getResult();
+		if (path != null) {
+			IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
+			if (file != null) {
+				doSaveAs(URI.createPlatformResourceURI(file.getFullPath().toString(), true), new FileEditorInput(file));
+			}
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void doSaveAs(URI uri, IEditorInput editorInput) {
+		(editingDomain.getResourceSet().getResources().get(0)).setURI(uri);
+		setInputWithNotify(editorInput);
+		setPartName(editorInput.getName());
+		IProgressMonitor progressMonitor =
+			getActionBars().getStatusLineManager() != null ?
+				getActionBars().getStatusLineManager().getProgressMonitor() :
+				new NullProgressMonitor();
+		doSave(progressMonitor);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void gotoMarker(IMarker marker) {
+		List<?> targetObjects = markerHelper.getTargetObjects(editingDomain, marker);
+		if (!targetObjects.isEmpty()) {
+			setSelectionToViewer(targetObjects);
+		}
+	}
+
+	/**
+	 * This is called during startup.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void init(IEditorSite site, IEditorInput editorInput) {
+		setSite(site);
+		setInputWithNotify(editorInput);
+		setPartName(editorInput.getName());
+		site.setSelectionProvider(this);
+		site.getPage().addPartListener(partListener);
+		ResourcesPlugin.getWorkspace().addResourceChangeListener(resourceChangeListener, IResourceChangeEvent.POST_CHANGE);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setFocus() {
+		if (currentViewerPane != null) {
+			currentViewerPane.setFocus();
+		}
+		else {
+			getControl(getActivePage()).setFocus();
+		}
+	}
+
+	/**
+	 * This implements {@link org.eclipse.jface.viewers.ISelectionProvider}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void addSelectionChangedListener(ISelectionChangedListener listener) {
+		selectionChangedListeners.add(listener);
+	}
+
+	/**
+	 * This implements {@link org.eclipse.jface.viewers.ISelectionProvider}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void removeSelectionChangedListener(ISelectionChangedListener listener) {
+		selectionChangedListeners.remove(listener);
+	}
+
+	/**
+	 * This implements {@link org.eclipse.jface.viewers.ISelectionProvider} to return this editor's overall selection.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public ISelection getSelection() {
+		return editorSelection;
+	}
+
+	/**
+	 * This implements {@link org.eclipse.jface.viewers.ISelectionProvider} to set this editor's overall selection.
+	 * Calling this result will notify the listeners.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setSelection(ISelection selection) {
+		editorSelection = selection;
+
+		for (ISelectionChangedListener listener : selectionChangedListeners) {
+			listener.selectionChanged(new SelectionChangedEvent(this, selection));
+		}
+		setStatusLineManager(selection);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setStatusLineManager(ISelection selection) {
+		IStatusLineManager statusLineManager = currentViewer != null && currentViewer == contentOutlineViewer ?
+			contentOutlineStatusLineManager : getActionBars().getStatusLineManager();
+
+		if (statusLineManager != null) {
+			if (selection instanceof IStructuredSelection) {
+				Collection<?> collection = ((IStructuredSelection)selection).toList();
+				switch (collection.size()) {
+					case 0: {
+						statusLineManager.setMessage(getString("_UI_NoObjectSelected"));
+						break;
+					}
+					case 1: {
+						String text = new AdapterFactoryItemDelegator(adapterFactory).getText(collection.iterator().next());
+						statusLineManager.setMessage(getString("_UI_SingleObjectSelected", text));
+						break;
+					}
+					default: {
+						statusLineManager.setMessage(getString("_UI_MultiObjectSelected", Integer.toString(collection.size())));
+						break;
+					}
+				}
+			}
+			else {
+				statusLineManager.setMessage("");
+			}
+		}
+	}
+
+	/**
+	 * This looks up a string in the plugin's plugin.properties file.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private static String getString(String key) {
+		return FumltracemodelEditorPlugin.INSTANCE.getString(key);
+	}
+
+	/**
+	 * This looks up a string in plugin.properties, making a substitution.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private static String getString(String key, Object s1) {
+		return FumltracemodelEditorPlugin.INSTANCE.getString(key, new Object [] { s1 });
+	}
+
+	/**
+	 * This implements {@link org.eclipse.jface.action.IMenuListener} to help fill the context menus with contributions from the Edit menu.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void menuAboutToShow(IMenuManager menuManager) {
+		((IMenuListener)getEditorSite().getActionBarContributor()).menuAboutToShow(menuManager);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EditingDomainActionBarContributor getActionBarContributor() {
+		return (EditingDomainActionBarContributor)getEditorSite().getActionBarContributor();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public IActionBars getActionBars() {
+		return getActionBarContributor().getActionBars();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public AdapterFactory getAdapterFactory() {
+		return adapterFactory;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void dispose() {
+		updateProblemIndication = false;
+
+		ResourcesPlugin.getWorkspace().removeResourceChangeListener(resourceChangeListener);
+
+		getSite().getPage().removePartListener(partListener);
+
+		adapterFactory.dispose();
+
+		if (getActionBarContributor().getActiveEditor() == this) {
+			getActionBarContributor().setActiveEditor(null);
+		}
+
+		for (PropertySheetPage propertySheetPage : propertySheetPages) {
+			propertySheetPage.dispose();
+		}
+
+		if (contentOutlinePage != null) {
+			contentOutlinePage.dispose();
+		}
+
+		super.dispose();
+	}
+
+	/**
+	 * Returns whether the outline view should be presented to the user.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected boolean showOutlineView() {
+		return true;
+	}
+}
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/MokaTraceServiceModelWizard.java b/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/MokaTraceServiceModelWizard.java
new file mode 100644
index 0000000..2c835f9
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model.editor/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/presentation/MokaTraceServiceModelWizard.java
@@ -0,0 +1,643 @@
+/**
+ * Copyright (c) 2019 CEA LIST and others.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *   CEA LIST - Initial API and implementation
+ * 
+ */
+package org.eclipse.papyrus.moka.trace.model.mokatraceservice.presentation;
+
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.StringTokenizer;
+
+import org.eclipse.emf.common.CommonPlugin;
+
+import org.eclipse.emf.common.util.URI;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+
+import org.eclipse.emf.ecore.EObject;
+
+import org.eclipse.emf.ecore.xmi.XMLResource;
+
+import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;
+
+import org.eclipse.core.resources.IContainer;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.ResourcesPlugin;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+
+import org.eclipse.jface.dialogs.MessageDialog;
+
+import org.eclipse.jface.viewers.IStructuredSelection;
+
+import org.eclipse.jface.wizard.Wizard;
+import org.eclipse.jface.wizard.WizardPage;
+
+import org.eclipse.swt.SWT;
+
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.ModifyEvent;
+
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+
+import org.eclipse.ui.INewWizard;
+import org.eclipse.ui.IWorkbench;
+
+import org.eclipse.ui.actions.WorkspaceModifyOperation;
+
+import org.eclipse.ui.dialogs.WizardNewFileCreationPage;
+
+import org.eclipse.ui.part.FileEditorInput;
+import org.eclipse.ui.part.ISetSelectionTarget;
+
+import org.eclipse.papyrus.moka.trace.model.mokatraceservice.MokaTraceServiceFactory;
+import org.eclipse.papyrus.moka.trace.model.mokatraceservice.MokaTraceServicePackage;
+import org.eclipse.papyrus.moka.trace.model.mokatraceservice.provider.FumltracemodelEditPlugin;
+
+
+import org.eclipse.core.runtime.Path;
+
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.StructuredSelection;
+
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.PartInitException;
+
+
+/**
+ * This is a simple wizard for creating a new model file.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class MokaTraceServiceModelWizard extends Wizard implements INewWizard {
+	/**
+	 * The supported extensions for created files.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final List<String> FILE_EXTENSIONS =
+		Collections.unmodifiableList(Arrays.asList(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_MokaTraceServiceEditorFilenameExtensions").split("\\s*,\\s*")));
+
+	/**
+	 * A formatted list of supported file extensions, suitable for display.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String FORMATTED_FILE_EXTENSIONS =
+		FumltracemodelEditorPlugin.INSTANCE.getString("_UI_MokaTraceServiceEditorFilenameExtensions").replaceAll("\\s*,\\s*", ", ");
+
+	/**
+	 * This caches an instance of the model package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected MokaTraceServicePackage mokaTraceServicePackage = MokaTraceServicePackage.eINSTANCE;
+
+	/**
+	 * This caches an instance of the model factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected MokaTraceServiceFactory mokaTraceServiceFactory = mokaTraceServicePackage.getMokaTraceServiceFactory();
+
+	/**
+	 * This is the file creation page.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected MokaTraceServiceModelWizardNewFileCreationPage newFileCreationPage;
+
+	/**
+	 * This is the initial object creation page.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected MokaTraceServiceModelWizardInitialObjectCreationPage initialObjectCreationPage;
+
+	/**
+	 * Remember the selection during initialization for populating the default container.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IStructuredSelection selection;
+
+	/**
+	 * Remember the workbench during initialization.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IWorkbench workbench;
+
+	/**
+	 * Caches the names of the types that can be created as the root object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected List<String> initialObjectNames;
+
+	/**
+	 * This just records the information.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void init(IWorkbench workbench, IStructuredSelection selection) {
+		this.workbench = workbench;
+		this.selection = selection;
+		setWindowTitle(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_Wizard_label"));
+		setDefaultPageImageDescriptor(ExtendedImageRegistry.INSTANCE.getImageDescriptor(FumltracemodelEditorPlugin.INSTANCE.getImage("full/wizban/NewMokaTraceService")));
+	}
+
+	/**
+	 * Returns the names of the types that can be created as the root object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<String> getInitialObjectNames() {
+		if (initialObjectNames == null) {
+			initialObjectNames = new ArrayList<String>();
+			for (EClassifier eClassifier : mokaTraceServicePackage.getEClassifiers()) {
+				if (eClassifier instanceof EClass) {
+					EClass eClass = (EClass)eClassifier;
+					if (!eClass.isAbstract()) {
+						initialObjectNames.add(eClass.getName());
+					}
+				}
+			}
+			Collections.sort(initialObjectNames, CommonPlugin.INSTANCE.getComparator());
+		}
+		return initialObjectNames;
+	}
+
+	/**
+	 * Create a new model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected EObject createInitialModel() {
+		EClass eClass = (EClass)mokaTraceServicePackage.getEClassifier(initialObjectCreationPage.getInitialObjectName());
+		EObject rootObject = mokaTraceServiceFactory.create(eClass);
+		return rootObject;
+	}
+
+	/**
+	 * Do the work after everything is specified.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean performFinish() {
+		try {
+			// Remember the file.
+			//
+			final IFile modelFile = getModelFile();
+
+			// Do the work within an operation.
+			//
+			WorkspaceModifyOperation operation =
+				new WorkspaceModifyOperation() {
+					@Override
+					protected void execute(IProgressMonitor progressMonitor) {
+						try {
+							// Create a resource set
+							//
+							ResourceSet resourceSet = new ResourceSetImpl();
+
+							// Get the URI of the model file.
+							//
+							URI fileURI = URI.createPlatformResourceURI(modelFile.getFullPath().toString(), true);
+
+							// Create a resource for this file.
+							//
+							Resource resource = resourceSet.createResource(fileURI);
+
+							// Add the initial model object to the contents.
+							//
+							EObject rootObject = createInitialModel();
+							if (rootObject != null) {
+								resource.getContents().add(rootObject);
+							}
+
+							// Save the contents of the resource to the file system.
+							//
+							Map<Object, Object> options = new HashMap<Object, Object>();
+							options.put(XMLResource.OPTION_ENCODING, initialObjectCreationPage.getEncoding());
+							resource.save(options);
+						}
+						catch (Exception exception) {
+							FumltracemodelEditorPlugin.INSTANCE.log(exception);
+						}
+						finally {
+							progressMonitor.done();
+						}
+					}
+				};
+
+			getContainer().run(false, false, operation);
+
+			// Select the new file resource in the current view.
+			//
+			IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
+			IWorkbenchPage page = workbenchWindow.getActivePage();
+			final IWorkbenchPart activePart = page.getActivePart();
+			if (activePart instanceof ISetSelectionTarget) {
+				final ISelection targetSelection = new StructuredSelection(modelFile);
+				getShell().getDisplay().asyncExec
+					(new Runnable() {
+						 @Override
+						 public void run() {
+							 ((ISetSelectionTarget)activePart).selectReveal(targetSelection);
+						 }
+					 });
+			}
+
+			// Open an editor on the new file.
+			//
+			try {
+				page.openEditor
+					(new FileEditorInput(modelFile),
+					 workbench.getEditorRegistry().getDefaultEditor(modelFile.getFullPath().toString()).getId());					 	 
+			}
+			catch (PartInitException exception) {
+				MessageDialog.openError(workbenchWindow.getShell(), FumltracemodelEditorPlugin.INSTANCE.getString("_UI_OpenEditorError_label"), exception.getMessage());
+				return false;
+			}
+
+			return true;
+		}
+		catch (Exception exception) {
+			FumltracemodelEditorPlugin.INSTANCE.log(exception);
+			return false;
+		}
+	}
+
+	/**
+	 * This is the one page of the wizard.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public class MokaTraceServiceModelWizardNewFileCreationPage extends WizardNewFileCreationPage {
+		/**
+		 * Pass in the selection.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		public MokaTraceServiceModelWizardNewFileCreationPage(String pageId, IStructuredSelection selection) {
+			super(pageId, selection);
+		}
+
+		/**
+		 * The framework calls this to see if the file is correct.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		@Override
+		protected boolean validatePage() {
+			if (super.validatePage()) {
+				String extension = new Path(getFileName()).getFileExtension();
+				if (extension == null || !FILE_EXTENSIONS.contains(extension)) {
+					String key = FILE_EXTENSIONS.size() > 1 ? "_WARN_FilenameExtensions" : "_WARN_FilenameExtension";
+					setErrorMessage(FumltracemodelEditorPlugin.INSTANCE.getString(key, new Object [] { FORMATTED_FILE_EXTENSIONS }));
+					return false;
+				}
+				return true;
+			}
+			return false;
+		}
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		public IFile getModelFile() {
+			return ResourcesPlugin.getWorkspace().getRoot().getFile(getContainerFullPath().append(getFileName()));
+		}
+	}
+
+	/**
+	 * This is the page where the type of object to create is selected.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public class MokaTraceServiceModelWizardInitialObjectCreationPage extends WizardPage {
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		protected Combo initialObjectField;
+
+		/**
+		 * @generated
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 */
+		protected List<String> encodings;
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		protected Combo encodingField;
+
+		/**
+		 * Pass in the selection.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		public MokaTraceServiceModelWizardInitialObjectCreationPage(String pageId) {
+			super(pageId);
+		}
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		@Override
+		public void createControl(Composite parent) {
+			Composite composite = new Composite(parent, SWT.NONE); {
+				GridLayout layout = new GridLayout();
+				layout.numColumns = 1;
+				layout.verticalSpacing = 12;
+				composite.setLayout(layout);
+
+				GridData data = new GridData();
+				data.verticalAlignment = GridData.FILL;
+				data.grabExcessVerticalSpace = true;
+				data.horizontalAlignment = GridData.FILL;
+				composite.setLayoutData(data);
+			}
+
+			Label containerLabel = new Label(composite, SWT.LEFT);
+			{
+				containerLabel.setText(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_ModelObject"));
+
+				GridData data = new GridData();
+				data.horizontalAlignment = GridData.FILL;
+				containerLabel.setLayoutData(data);
+			}
+
+			initialObjectField = new Combo(composite, SWT.BORDER);
+			{
+				GridData data = new GridData();
+				data.horizontalAlignment = GridData.FILL;
+				data.grabExcessHorizontalSpace = true;
+				initialObjectField.setLayoutData(data);
+			}
+
+			for (String objectName : getInitialObjectNames()) {
+				initialObjectField.add(getLabel(objectName));
+			}
+
+			if (initialObjectField.getItemCount() == 1) {
+				initialObjectField.select(0);
+			}
+			initialObjectField.addModifyListener(validator);
+
+			Label encodingLabel = new Label(composite, SWT.LEFT);
+			{
+				encodingLabel.setText(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_XMLEncoding"));
+
+				GridData data = new GridData();
+				data.horizontalAlignment = GridData.FILL;
+				encodingLabel.setLayoutData(data);
+			}
+			encodingField = new Combo(composite, SWT.BORDER);
+			{
+				GridData data = new GridData();
+				data.horizontalAlignment = GridData.FILL;
+				data.grabExcessHorizontalSpace = true;
+				encodingField.setLayoutData(data);
+			}
+
+			for (String encoding : getEncodings()) {
+				encodingField.add(encoding);
+			}
+
+			encodingField.select(0);
+			encodingField.addModifyListener(validator);
+
+			setPageComplete(validatePage());
+			setControl(composite);
+		}
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		protected ModifyListener validator =
+			new ModifyListener() {
+				@Override
+				public void modifyText(ModifyEvent e) {
+					setPageComplete(validatePage());
+				}
+			};
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		protected boolean validatePage() {
+			return getInitialObjectName() != null && getEncodings().contains(encodingField.getText());
+		}
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		@Override
+		public void setVisible(boolean visible) {
+			super.setVisible(visible);
+			if (visible) {
+				if (initialObjectField.getItemCount() == 1) {
+					initialObjectField.clearSelection();
+					encodingField.setFocus();
+				}
+				else {
+					encodingField.clearSelection();
+					initialObjectField.setFocus();
+				}
+			}
+		}
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		public String getInitialObjectName() {
+			String label = initialObjectField.getText();
+
+			for (String name : getInitialObjectNames()) {
+				if (getLabel(name).equals(label)) {
+					return name;
+				}
+			}
+			return null;
+		}
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		public String getEncoding() {
+			return encodingField.getText();
+		}
+
+		/**
+		 * Returns the label for the specified type name.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		protected String getLabel(String typeName) {
+			try {
+				return FumltracemodelEditPlugin.INSTANCE.getString("_UI_" + typeName + "_type");
+			}
+			catch(MissingResourceException mre) {
+				FumltracemodelEditorPlugin.INSTANCE.log(mre);
+			}
+			return typeName;
+		}
+
+		/**
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		protected Collection<String> getEncodings() {
+			if (encodings == null) {
+				encodings = new ArrayList<String>();
+				for (StringTokenizer stringTokenizer = new StringTokenizer(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_XMLEncodingChoices")); stringTokenizer.hasMoreTokens(); ) {
+					encodings.add(stringTokenizer.nextToken());
+				}
+			}
+			return encodings;
+		}
+	}
+
+	/**
+	 * The framework calls this to create the contents of the wizard.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+		@Override
+	public void addPages() {
+		// Create a page, set the title, and the initial model file name.
+		//
+		newFileCreationPage = new MokaTraceServiceModelWizardNewFileCreationPage("Whatever", selection);
+		newFileCreationPage.setTitle(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_MokaTraceServiceModelWizard_label"));
+		newFileCreationPage.setDescription(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_MokaTraceServiceModelWizard_description"));
+		newFileCreationPage.setFileName(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_MokaTraceServiceEditorFilenameDefaultBase") + "." + FILE_EXTENSIONS.get(0));
+		addPage(newFileCreationPage);
+
+		// Try and get the resource selection to determine a current directory for the file dialog.
+		//
+		if (selection != null && !selection.isEmpty()) {
+			// Get the resource...
+			//
+			Object selectedElement = selection.iterator().next();
+			if (selectedElement instanceof IResource) {
+				// Get the resource parent, if its a file.
+				//
+				IResource selectedResource = (IResource)selectedElement;
+				if (selectedResource.getType() == IResource.FILE) {
+					selectedResource = selectedResource.getParent();
+				}
+
+				// This gives us a directory...
+				//
+				if (selectedResource instanceof IFolder || selectedResource instanceof IProject) {
+					// Set this for the container.
+					//
+					newFileCreationPage.setContainerFullPath(selectedResource.getFullPath());
+
+					// Make up a unique new name here.
+					//
+					String defaultModelBaseFilename = FumltracemodelEditorPlugin.INSTANCE.getString("_UI_MokaTraceServiceEditorFilenameDefaultBase");
+					String defaultModelFilenameExtension = FILE_EXTENSIONS.get(0);
+					String modelFilename = defaultModelBaseFilename + "." + defaultModelFilenameExtension;
+					for (int i = 1; ((IContainer)selectedResource).findMember(modelFilename) != null; ++i) {
+						modelFilename = defaultModelBaseFilename + i + "." + defaultModelFilenameExtension;
+					}
+					newFileCreationPage.setFileName(modelFilename);
+				}
+			}
+		}
+		initialObjectCreationPage = new MokaTraceServiceModelWizardInitialObjectCreationPage("Whatever2");
+		initialObjectCreationPage.setTitle(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_MokaTraceServiceModelWizard_label"));
+		initialObjectCreationPage.setDescription(FumltracemodelEditorPlugin.INSTANCE.getString("_UI_Wizard_initial_object_description"));
+		addPage(initialObjectCreationPage);
+	}
+
+	/**
+	 * Get the file from the page.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public IFile getModelFile() {
+		return newFileCreationPage.getModelFile();
+	}
+
+}
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model/META-INF/MANIFEST.MF b/plugins/org.eclipse.papyrus.moka.trace.model/META-INF/MANIFEST.MF
index 703204d..bec7e26 100644
--- a/plugins/org.eclipse.papyrus.moka.trace.model/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.papyrus.moka.trace.model/META-INF/MANIFEST.MF
@@ -1,12 +1,16 @@
 Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
-Bundle-Name: Moka Trace Service Model
+Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.papyrus.moka.trace.model;singleton:=true
 Automatic-Module-Name: org.eclipse.papyrus.moka.trace.model
 Bundle-Version: 4.1.0.qualifier
 Bundle-ClassPath: .
-Bundle-Vendor: Eclipse Modeling Project
+Bundle-Vendor: %providerName
+Bundle-Localization: plugin
 Bundle-RequiredExecutionEnvironment: JavaSE-17
-Export-Package: org.eclipse.papyrus.moka.trace.model.mokatraceservice
-Require-Bundle: org.eclipse.emf.ecore;bundle-version="[2.20.0,3.0.0)";visibility:=reexport
+Export-Package: org.eclipse.papyrus.moka.trace.model.mokatraceservice,
+ org.eclipse.papyrus.moka.trace.model.mokatraceservice.impl,
+ org.eclipse.papyrus.moka.trace.model.mokatraceservice.util
+Require-Bundle: org.eclipse.core.runtime,
+ org.eclipse.emf.ecore;bundle-version="[2.20.0,3.0.0)";visibility:=reexport
 Bundle-ActivationPolicy: lazy
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model/plugin.properties b/plugins/org.eclipse.papyrus.moka.trace.model/plugin.properties
new file mode 100644
index 0000000..4275050
--- /dev/null
+++ b/plugins/org.eclipse.papyrus.moka.trace.model/plugin.properties
@@ -0,0 +1,15 @@
+# Copyright (c) 2019 CEA LIST and others.
+# 
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License 2.0
+# which accompanies this distribution, and is available at
+# https://www.eclipse.org/legal/epl-2.0/
+# 
+# SPDX-License-Identifier: EPL-2.0
+# 
+# Contributors:
+#   CEA LIST - Initial API and implementation
+# 
+
+pluginName = Moka Trace Service Model
+providerName = Eclipse Modeling Project
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model/resources/model/mokatraceservice.genmodel b/plugins/org.eclipse.papyrus.moka.trace.model/resources/model/mokatraceservice.genmodel
index e756134..6a58dfc 100644
--- a/plugins/org.eclipse.papyrus.moka.trace.model/resources/model/mokatraceservice.genmodel
+++ b/plugins/org.eclipse.papyrus.moka.trace.model/resources/model/mokatraceservice.genmodel
@@ -32,7 +32,8 @@
   </genAnnotations>
   <foreignModel>mokatraceservice.uml</foreignModel>
   <genPackages xsi:type="genmodel:GenPackage" prefix="MokaTraceService" basePackage="org.eclipse.papyrus.moka.trace.model"
-      disposableProviderFactory="true" ecorePackage="mokatraceservice.ecore#/">
+      disposableProviderFactory="true" childCreationExtenders="true" fileExtensions="mtrace"
+      ecorePackage="mokatraceservice.ecore#/">
     <genClasses xsi:type="genmodel:GenClass" ecoreClass="mokatraceservice.ecore#//MokaTrace"/>
   </genPackages>
 </genmodel:GenModel>
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/impl/MokaTraceServiceFactoryImpl.java b/plugins/org.eclipse.papyrus.moka.trace.model/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/impl/MokaTraceServiceFactoryImpl.java
index 6ee593a..cb7f760 100644
--- a/plugins/org.eclipse.papyrus.moka.trace.model/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/impl/MokaTraceServiceFactoryImpl.java
+++ b/plugins/org.eclipse.papyrus.moka.trace.model/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/impl/MokaTraceServiceFactoryImpl.java
@@ -79,6 +79,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public MokaTrace createMokaTrace() {
 		MokaTraceImpl mokaTrace = new MokaTraceImpl();
 		return mokaTrace;
@@ -89,6 +90,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public MokaTraceServicePackage getMokaTraceServicePackage() {
 		return (MokaTraceServicePackage)getEPackage();
 	}
diff --git a/plugins/org.eclipse.papyrus.moka.trace.model/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/impl/MokaTraceServicePackageImpl.java b/plugins/org.eclipse.papyrus.moka.trace.model/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/impl/MokaTraceServicePackageImpl.java
index abf268d..5c1a628 100644
--- a/plugins/org.eclipse.papyrus.moka.trace.model/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/impl/MokaTraceServicePackageImpl.java
+++ b/plugins/org.eclipse.papyrus.moka.trace.model/src-gen/org/eclipse/papyrus/moka/trace/model/mokatraceservice/impl/MokaTraceServicePackageImpl.java
@@ -103,6 +103,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public EClass getMokaTrace() {
 		return mokaTraceEClass;
 	}
@@ -112,6 +113,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
 	public MokaTraceServiceFactory getMokaTraceServiceFactory() {
 		return (MokaTraceServiceFactory)getEFactoryInstance();
 	}
diff --git a/plugins/org.eclipse.papyrus.moka.trace/src/org/eclipse/papyrus/moka/trace/formater/MokaJsonTraceFileFormater.java b/plugins/org.eclipse.papyrus.moka.trace/src/org/eclipse/papyrus/moka/trace/formater/MokaEcoreTraceFileFormater.java
similarity index 85%
rename from plugins/org.eclipse.papyrus.moka.trace/src/org/eclipse/papyrus/moka/trace/formater/MokaJsonTraceFileFormater.java
rename to plugins/org.eclipse.papyrus.moka.trace/src/org/eclipse/papyrus/moka/trace/formater/MokaEcoreTraceFileFormater.java
index 79339c3..d551c3f 100644
--- a/plugins/org.eclipse.papyrus.moka.trace/src/org/eclipse/papyrus/moka/trace/formater/MokaJsonTraceFileFormater.java
+++ b/plugins/org.eclipse.papyrus.moka.trace/src/org/eclipse/papyrus/moka/trace/formater/MokaEcoreTraceFileFormater.java
@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Copyright (c) 2019 CEA LIST and others.
+ * Copyright (c) 2019, 2024 CEA LIST and others.
  * 
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -10,6 +10,7 @@
  *
  * Contributors:
  *   CEA LIST - Initial API and implementation
+ *   Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Bug 583191
  *   
  *****************************************************************************/
 package org.eclipse.papyrus.moka.trace.formater;
@@ -26,11 +27,11 @@
 import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
 import org.eclipse.papyrus.moka.trace.interfaces.format.ITraceFileFormater;
 
-public class MokaJsonTraceFileFormater extends AbstractTraceFileFormater implements ITraceFileFormater {
+public class MokaEcoreTraceFileFormater extends AbstractTraceFileFormater implements ITraceFileFormater {
 
 	public static final String MOKA_JSON_FORMATER_ID = "org.eclipse.papyrus.moka.trace.formater.mokaJsonFormater"; //$NON-NLS-1$
 	
-	public MokaJsonTraceFileFormater() {
+	public MokaEcoreTraceFileFormater() {
 		super();
 	}
 
@@ -42,7 +43,7 @@
 			m.put("mokaTrace", new XMIResourceFactoryImpl()); //$NON-NLS-1$
 			ResourceSet resSet = new ResourceSetImpl();
 			Resource resource = resSet.createResource(URI
-					.createFileURI(filePath).appendSegment("execution-trace.trace"));
+					.createFileURI(filePath));
 			resource.getContents().add((EObject) trace);
 			try {
 				resource.save(Collections.EMPTY_MAP);
diff --git a/plugins/pom.xml b/plugins/pom.xml
index bc90540..448aca4 100644
--- a/plugins/pom.xml
+++ b/plugins/pom.xml
@@ -49,6 +49,8 @@
 		<module>org.eclipse.papyrus.moka.trace</module>
 		<module>org.eclipse.papyrus.moka.trace.interfaces</module>
 		<module>org.eclipse.papyrus.moka.trace.model</module>
+		<module>org.eclipse.papyrus.moka.trace.model.edit</module>
+		<module>org.eclipse.papyrus.moka.trace.model.editor</module>
 		<module>org.eclipse.papyrus.moka.tracepoint.service</module>
 		<module>org.eclipse.papyrus.moka.ui</module>
 		<module>org.eclipse.papyrus.moka.ui.tracepoint.view</module>
diff --git a/releng/org.eclipse.papyrus.moka.p2/category.xml b/releng/org.eclipse.papyrus.moka.p2/category.xml
index 099d84a..521790e 100644
--- a/releng/org.eclipse.papyrus.moka.p2/category.xml
+++ b/releng/org.eclipse.papyrus.moka.p2/category.xml
@@ -6,6 +6,12 @@
    <feature url="features/org.eclipse.papyrus.moka.feature.source_4.1.0.qualifier.jar" id="org.eclipse.papyrus.moka.feature.source" version="4.1.0.qualifier">
       <category name="org.eclipse.papyrus.moka.category"/>
    </feature>
+   <feature url="features/org.eclipse.papyrus.moka.trace.feature_4.1.0.qualifier.jar" id="org.eclipse.papyrus.moka.trace.feature" version="4.1.0.qualifier">
+      <category name="org.eclipse.papyrus.moka.category"/>
+   </feature>
+   <feature url="features/org.eclipse.papyrus.moka.trace.feature.source_4.1.0.qualifier.jar" id="org.eclipse.papyrus.moka.trace.feature.source" version="4.1.0.qualifier">
+      <category name="org.eclipse.papyrus.moka.category"/>
+   </feature>
    <category-def name="org.eclipse.papyrus.moka.category" label="Moka">
       <description>
          Papyrus Model Execution Tool
