Add the plugin o.p.esf.core.common.ui for the UI tools.

Change-Id: I9e733e56919ef9e378ec8c5c07fa920b58bc20bd
Signed-off-by: Jonathan Dumont <jonathan.dumont@all4tec.net>
diff --git a/core/org.polarsys.esf.core.common.ui/.checkstyle b/core/org.polarsys.esf.core.common.ui/.checkstyle
new file mode 100644
index 0000000..227a385
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/.checkstyle
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<fileset-config file-format-version="1.2.0" simple-config="true" sync-formatter="false">
+  <fileset name="all" enabled="true" check-config-name="Checkstyle ESF" local="false">
+    <file-match-pattern match-pattern="." include-pattern="true"/>
+  </fileset>
+</fileset-config>
diff --git a/core/org.polarsys.esf.core.common.ui/.classpath b/core/org.polarsys.esf.core.common.ui/.classpath
new file mode 100644
index 0000000..a95e090
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/.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.7"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src/main/java"/>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>
diff --git a/core/org.polarsys.esf.core.common.ui/.project b/core/org.polarsys.esf.core.common.ui/.project
new file mode 100644
index 0000000..36b139f
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/.project
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.polarsys.esf.core.common.ui</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>
+		<buildCommand>
+			<name>net.sf.eclipsecs.core.CheckstyleBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>net.sf.eclipsecs.core.CheckstyleNature</nature>
+	</natures>
+</projectDescription>
diff --git a/core/org.polarsys.esf.core.common.ui/META-INF/MANIFEST.MF b/core/org.polarsys.esf.core.common.ui/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..5af96a8
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/META-INF/MANIFEST.MF
@@ -0,0 +1,36 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %Bundle-Name
+Bundle-SymbolicName: org.polarsys.esf.core.common.ui;singleton:=true
+Bundle-Version: 0.7.0.qualifier
+Bundle-Activator: org.polarsys.esf.core.common.ui.CommonUIActivator$Implementation
+Bundle-Vendor: %Bundle-Vendor
+Require-Bundle: org.polarsys.esf.core.common;bundle-version="0.7.0";visibility:=reexport,
+ org.eclipse.emf.edit.ui;bundle-version="2.10.0";visibility:=reexport,
+ org.eclipse.ui;bundle-version="3.106.0",
+ org.eclipse.ui.console;bundle-version="3.5.300",
+ org.eclipse.ui.ide;bundle-version="3.10.0",
+ org.eclipse.ui.navigator.resources;bundle-version="3.4.700",
+ org.eclipse.ui.navigator;bundle-version="3.5.400",
+ org.eclipse.uml2.uml
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
+Bundle-Localization: src/main/resources/properties/plugin
+Bundle-ActivationPolicy: lazy
+Export-Package: org.polarsys.esf.core.common.ui,
+ org.polarsys.esf.core.common.ui.actions,
+ org.polarsys.esf.core.common.ui.adapter,
+ org.polarsys.esf.core.common.ui.console,
+ org.polarsys.esf.core.common.ui.constants,
+ org.polarsys.esf.core.common.ui.editingsupport,
+ org.polarsys.esf.core.common.ui.editor,
+ org.polarsys.esf.core.common.ui.fieldeditor,
+ org.polarsys.esf.core.common.ui.filter,
+ org.polarsys.esf.core.common.ui.job,
+ org.polarsys.esf.core.common.ui.selection,
+ org.polarsys.esf.core.common.ui.statusline,
+ org.polarsys.esf.core.common.ui.treeviewer,
+ org.polarsys.esf.core.common.ui.view,
+ org.polarsys.esf.core.common.ui.view.properties,
+ org.polarsys.esf.core.common.ui.widget,
+ org.polarsys.esf.core.common.ui.widget.listener,
+ org.polarsys.esf.core.common.ui.wizard
diff --git a/core/org.polarsys.esf.core.common.ui/about.html b/core/org.polarsys.esf.core.common.ui/about.html
new file mode 100644
index 0000000..d35d5ae
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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/core/org.polarsys.esf.core.common.ui/build.properties b/core/org.polarsys.esf.core.common.ui/build.properties
new file mode 100644
index 0000000..648ffab
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/build.properties
@@ -0,0 +1,7 @@
+source.. = src/main/java
+output.. = target/classes/
+bin.includes = META-INF/,\
+               .,\
+               src/main/resources/properties/,\
+               src/main/resources/icons/,\
+               plugin.xml
diff --git a/core/org.polarsys.esf.core.common.ui/plugin.xml b/core/org.polarsys.esf.core.common.ui/plugin.xml
new file mode 100644
index 0000000..b2414ff
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/plugin.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+<extension
+       point="org.eclipse.ui.menus">
+    <menuContribution
+          locationURI="toolbar:org.eclipse.ui.main.toolbar">
+           <toolbar
+                 id="org.polarsys.esf.core.common.ui.toolbar.activeproject"
+                 label="%toolbar.activeproject.label">
+              <control
+                    class="org.polarsys.esf.core.common.ui.widget.ActiveProjectControlContribution">
+              </control>
+           </toolbar>
+           <toolbar
+                 id="org.polarsys.esf.core.common.ui.toolbar.filter"
+                 label="%toolbar.filter.label">
+              <control
+                    class="org.polarsys.esf.core.common.ui.actions.FilterPartControlContribution">
+              </control>
+           </toolbar>
+        </menuContribution>
+</extension>
+</plugin>
diff --git a/core/org.polarsys.esf.core.common.ui/pom.xml b/core/org.polarsys.esf.core.common.ui/pom.xml
new file mode 100644
index 0000000..79baf61
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/pom.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
+  xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.polarsys.esf</groupId>
+    <artifactId>esf-infra.core</artifactId>
+    <version>0.7.0-SNAPSHOT</version>
+  </parent>
+
+  <groupId>org.polarsys.esf</groupId>
+  <artifactId>org.polarsys.esf.core.common.ui</artifactId>
+  <packaging>eclipse-plugin</packaging>
+
+</project>
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/CommonUIActivator.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/CommonUIActivator.java
new file mode 100644
index 0000000..ee9954e
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/CommonUIActivator.java
@@ -0,0 +1,212 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui;
+
+import java.util.ResourceBundle;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.emf.common.EMFPlugin;
+import org.eclipse.emf.common.ui.EclipseUIPlugin;
+import org.eclipse.emf.common.util.ResourceLocator;
+import org.eclipse.jface.resource.ImageRegistry;
+import org.polarsys.esf.core.common.messages.Messages;
+
+/**
+ * 
+ * Central singleton for the common ui tools part of ESF.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class CommonUIActivator
+    extends EMFPlugin {
+
+    /** Keep track of the encapsulating singleton. */
+    public static final CommonUIActivator INSTANCE = new CommonUIActivator();
+
+    /** Keep track of the implementation singleton. */
+    private static Implementation sPlugin = null;
+
+    /** Messages class used to find localised string. */
+    private static Messages sMessages = new Messages(ResourceBundle.getBundle(Messages.BUNDLE_NAME));
+
+    /**
+     * The default constructor.
+     */
+    public CommonUIActivator() {
+        super(new ResourceLocator[] {});
+    }
+
+    /**
+     * Returns the singleton instance of the Eclipse plugin, used as resource locator.
+     * 
+     * @return The singleton instance
+     */
+    @Override
+    public ResourceLocator getPluginResourceLocator() {
+        return sPlugin;
+    }
+
+    /**
+     * Returns the singleton instance of the Eclipse plugin.
+     * 
+     * @return The singleton instance
+     */
+    public static Implementation getPlugin() {
+        return sPlugin;
+    }
+
+    /**
+     * @return The messages class used to return localised string
+     */
+    public static Messages getMessages() {
+        return sMessages;
+    }
+
+    /**
+     * Create an Error status with the data given in parameter and log it.
+     * 
+     * @param pMessage The message to log
+     * @param pException The exception to log
+     */
+    public static void logError(final String pMessage, final Exception pException) {
+        // Create the Error status
+        IStatus vStatus = new Status(IStatus.ERROR, sPlugin.getSymbolicName(), IStatus.ERROR, pMessage, pException);
+
+        // Log it
+        INSTANCE.log(vStatus);
+    }
+
+    /**
+     * Create a Warning status with the data given in parameter and log it.
+     * 
+     * @param pMessage The message to log
+     * @param pException The exception to log
+     */
+    public static void logWarning(final String pMessage, final Exception pException) {
+        // Create the Warning status
+        IStatus vStatus = new Status(IStatus.WARNING, sPlugin.getSymbolicName(), IStatus.WARNING, pMessage, pException);
+
+        // Log it
+        INSTANCE.log(vStatus);
+    }
+
+    /**
+     * Create an Info status with the data given in parameter and log it.
+     * 
+     * @param pMessage The message to log
+     * @param pException The exception to log
+     */
+    public static void logInfo(final String pMessage, final Exception pException) {
+        // Create the Info status
+        IStatus vStatus = new Status(IStatus.INFO, sPlugin.getSymbolicName(), IStatus.INFO, pMessage, pException);
+
+        // Log it
+        INSTANCE.log(vStatus);
+    }
+
+    /**
+     * 
+     * Unique implementation of common ui activator.
+     * 
+     * 
+     * @author $Author: jdumont $
+     * @version $Revision: 83 $
+     */
+    public static class Implementation
+        extends EclipseUIPlugin {
+
+        /** Key for icon up image. */
+        public static final String ICON_UP_IMG_KEY = "icon.up"; //$NON-NLS-1$
+
+        /** Key for icon down image. */
+        public static final String ICON_DOWN_IMG_KEY = "icon.down"; //$NON-NLS-1$
+
+        /** Key for icon add image. */
+        public static final String ICON_ADD_IMG_KEY = "icon.add"; //$NON-NLS-1$
+
+        /** Key for icon remove image. */
+        public static final String ICON_REMOVE_IMG_KEY = "icon.remove"; //$NON-NLS-1$
+
+        /** Key for Show advanced fields button. */
+        public static final String ICON_ADVANCED_SHOW_KEY = "icon.showadvanced"; //$NON-NLS-1$
+
+        /** Key for Hide advanced fields button. */
+        public static final String ICON_ADVANCED_HIDE_KEY = "icon.hideadvanced"; //$NON-NLS-1$
+
+        /** Key for expand all image. */
+        public static final String ICON_EXPAND_ALL_KEY = "icon.expandall"; //$NON-NLS-1$
+
+        /** Key for collapse all image. */
+        public static final String ICON_COLLAPSE_ALL_KEY = "icon.collapseall"; //$NON-NLS-1$
+
+        /** Key for the search icon. */
+        public static final String ICON_SEARCH_KEY = "icon.search"; //$NON-NLS-1$
+
+        /** Key for the banner in the probability edition dialog. */
+        public static final String ICON_PROBABILITY_DIALOG_KEY = "banner.probability.dialog"; //$NON-NLS-1$
+
+        /** Key for Weibull probability rule. */
+        public static final String ICON_WEIBULL = "rule.weibull"; //$NON-NLS-1$
+
+        /** Key for Poisson probability rule. */
+        public static final String ICON_POISSON = "rule.poisson"; //$NON-NLS-1$
+
+        /** Key for exponential probability rule. */
+        public static final String ICON_EXPONENTIAL = "rule.exponential"; //$NON-NLS-1$
+
+        /**
+         * Creates an instance.
+         */
+        public Implementation() {
+            super();
+
+            // Remember the static instance.
+            sPlugin = this;
+        }
+
+        @Override
+        protected void initializeImageRegistry(final ImageRegistry pReg) {
+            super.initializeImageRegistry(pReg);
+
+            // Icon paths are not externalised as they are no reason to modify it or to access to it externally
+            String vSymbolicName = getPlugin().getSymbolicName();
+
+            pReg.put(ICON_UP_IMG_KEY, imageDescriptorFromPlugin(vSymbolicName, "icons/icon_up.png")); //$NON-NLS-1$
+
+            pReg.put(ICON_DOWN_IMG_KEY, imageDescriptorFromPlugin(vSymbolicName, "icons/icon_down.png")); //$NON-NLS-1$
+
+            pReg.put(ICON_ADD_IMG_KEY, imageDescriptorFromPlugin(vSymbolicName, "icons/icon_addone.png")); //$NON-NLS-1$
+
+            pReg.put(ICON_REMOVE_IMG_KEY, imageDescriptorFromPlugin(vSymbolicName, "icons/icon_removeone.png")); //$NON-NLS-1$
+
+            pReg.put(ICON_ADVANCED_SHOW_KEY, imageDescriptorFromPlugin(vSymbolicName, "icons/advanced_show.png")); //$NON-NLS-1$
+
+            pReg.put(ICON_ADVANCED_HIDE_KEY, imageDescriptorFromPlugin(vSymbolicName, "icons/advanced_hide.png")); //$NON-NLS-1$
+
+            pReg.put(ICON_EXPAND_ALL_KEY, imageDescriptorFromPlugin(vSymbolicName, "icons/expand_all.gif")); //$NON-NLS-1$
+
+            pReg.put(ICON_COLLAPSE_ALL_KEY, imageDescriptorFromPlugin(vSymbolicName, "icons/collapse_all.gif")); //$NON-NLS-1$
+
+            pReg.put(ICON_SEARCH_KEY, imageDescriptorFromPlugin(vSymbolicName, "icons/search.gif")); //$NON-NLS-1$
+
+            pReg.put(
+                ICON_PROBABILITY_DIALOG_KEY,
+                imageDescriptorFromPlugin(vSymbolicName, "icons/dialog_probability.png")); //$NON-NLS-1$
+            pReg.put(ICON_POISSON, imageDescriptorFromPlugin(vSymbolicName, "icons/rule/icon_poisson_rule.png")); //$NON-NLS-1$
+            pReg.put(ICON_WEIBULL, imageDescriptorFromPlugin(vSymbolicName, "icons/rule/icon_weibull_rule.png")); //$NON-NLS-1$
+            pReg.put(ICON_EXPONENTIAL, imageDescriptorFromPlugin(vSymbolicName, "icons/rule/icon_exponential_rule.png")); //$NON-NLS-1$
+
+        }
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/ActionBarContributorUtils.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/ActionBarContributorUtils.java
new file mode 100644
index 0000000..9b2d6cc
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/ActionBarContributorUtils.java
@@ -0,0 +1,339 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.actions;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.emf.edit.ui.action.CreateChildAction;
+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.MenuManager;
+import org.eclipse.jface.action.SubContributionItem;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.ui.IWorkbenchPart;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+
+/**
+ * Utility class used to centralise shared constants, and shared methods
+ * for all the action bar contributors.
+ *
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public final class ActionBarContributorUtils {
+
+    /** The singleton instance of the utility class. */
+    public static final ActionBarContributorUtils INSTANCE = new ActionBarContributorUtils();
+
+    /** The show properties action id. */
+    public static final String SHOW_PROPERTIES_ACTION_ID = "show_properties_action"; //$NON-NLS-1$
+
+    /** The refresh action id. */
+    public static final String REFRESH_ACTION_ID = "refresh_action"; //$NON-NLS-1$
+
+    /** Id for the collapse all action. */
+    public static final String COLLAPSE_ALL_ACTION_ID = "action.collapseall.id"; //$NON-NLS-1$
+
+    /** Id for the expand all action. */
+    public static final String EXPAND_ALL_ACTION_ID = "action.expandall.id"; //$NON-NLS-1$
+
+    /** The edit separator id. */
+    public static final String EDIT_SEPARATOR_ID = "edit"; //$NON-NLS-1$
+
+    /** The additions separator id. */
+    public static final String ADDITIONS_SEPARATOR_ID = "additions"; //$NON-NLS-1$
+
+    /** The additions end id. */
+    public static final String ADDITIONS_END_SEPARATOR_ID = "additions-end"; //$NON-NLS-1$
+
+    /** The ui actions id. */
+    public static final String UI_ACTIONS_SEPARATOR_ID = "ui-actions"; //$NON-NLS-1$
+
+    /** The create child menu id. */
+    public static final String CREATECHILD_MENU_ID = "createChildMenu"; //$NON-NLS-1$
+
+    /** Separator id, for the toolbar actions linked to the selected element. */
+    public static final String TOOLBAR_SEP_SELECTION_ACTIONS = "toolbar-selection-actions"; //$NON-NLS-1$
+
+    /** Separator id, for the toolbar delete action linked to the selected element. */
+    public static final String TOOLBAR_SEP_DELETE_ACTION = "toolbar-delete-action"; //$NON-NLS-1$
+
+    /** Prefix used to create the id of toolbar actions which create child on the current selection. */
+    public static final String CREATECHILD_ACTION_ID_PREFIX = "selection.createchild.action."; //$NON-NLS-1$
+
+    /** Label for the create child menu. */
+    public static final String CREATECHILD_MENU_LABEL =
+        CommonUIActivator.getMessages().getString(
+            "ActionBarContributorUtils.menu.child.new"); //$NON-NLS-1$
+
+    /** Label for the show properties action. */
+    public static final String SHOW_PROPERTIES_ACTION_LABEL =
+        CommonUIActivator.getMessages().getString(
+            "ActionBarContributorUtils.actions.showpropertiesview"); //$NON-NLS-1$
+
+    /** Label for the refresh action. */
+    public static final String REFRESH_ACTION_LABEL =
+        CommonUIActivator.getMessages().getString(
+            "ActionBarContributorUtils.actions.refresh"); //$NON-NLS-1$
+
+    /** Label for the expand all action. */
+    public static final String EXPAND_ALL_ACTION_LABEL =
+        CommonUIActivator.getMessages().getString(
+            "ActionBarContributorUtils.actions.expandall"); //$NON-NLS-1$
+
+    /** Label for the collapse all action. */
+    public static final String COLLAPSE_ALL_ACTION_LABEL =
+        CommonUIActivator.getMessages().getString(
+            "ActionBarContributorUtils.actions.collapseall"); //$NON-NLS-1$
+
+
+    /**
+     * Private constructor, as it's a utility class.
+     */
+    private ActionBarContributorUtils() {
+    }
+
+    /**
+     * Generate a {@link CreateChildAction}, to add content under the selection. An action is created
+     * for each object described by the given <code>descriptors</code>.
+     *
+     * The action id is automatically generated, and is prefixed by a custom
+     * string {@link #CREATECHILD_ACTION_ID_PREFIX}, to be able to find them easily later.
+     *
+     * @param pWorkbenchPart The part from which the editing domain will be found, if it's an editing domain provider
+     * @param pDescriptors The collection of descriptors corresponding to the child which may be created
+     * @param pSelection The selection containing the object for which the children can be created
+     * @return The collection of actions created
+     */
+    public Collection<IAction> generateCreateChildActionsCollection(
+        final IWorkbenchPart pWorkbenchPart,
+        final Collection<?> pDescriptors,
+        final ISelection pSelection) {
+
+        // Initialise the collection of actions
+        final Collection<IAction> vActionsCollection = new ArrayList<IAction>();
+
+        if (pDescriptors != null) {
+
+            int i = 0;
+
+            // Loop on the given descriptors to create an action for each one
+            for (final Object vDescriptor : pDescriptors) {
+                // Create the action
+                IAction vCreateChildAction = new CreateChildAction(pWorkbenchPart, pSelection, vDescriptor);
+
+                // Set its unique id
+                vCreateChildAction.setId(
+                    ActionBarContributorUtils.CREATECHILD_ACTION_ID_PREFIX.concat(String.valueOf(i++)));
+
+                // Finally add it to the returned collection
+                vActionsCollection.add(vCreateChildAction);
+            }
+        }
+
+        return vActionsCollection;
+    }
+
+    /**
+     * This populates the specified <code>manager</code> with {@link ActionContributionItem}s
+     * based on the {@link IAction}s contained in the given collection,
+     * by inserting them before the specified contribution item <code>contributionID</code>.
+     * If <code>contributionID</code> is <code>null</code>, they are simply added.
+     *
+     * @param pManager The contribution manager to populate
+     * @param pActionsCollection The actions to add in the manager
+     * @param pContributionID The ID defining where the actions must be inserted. May be null
+     */
+    public void populateManager(
+        final IContributionManager pManager,
+        final Collection<? extends IAction> pActionsCollection,
+        final String pContributionID) {
+
+        if (pManager != null && pActionsCollection != null) {
+            // Loop on the actions to add in the manager
+            for (final IAction vAction : pActionsCollection) {
+                if (StringUtils.isNotEmpty(pContributionID)) {
+                    // Insert the action at the right location
+                    pManager.insertBefore(pContributionID, vAction);
+                } else {
+                    // Simply add the action in the manager
+                    pManager.add(vAction);
+                }
+            }
+        }
+    }
+
+
+    /**
+     * This populates the specified <code>manager</code> with {@link MenuManager}s containing
+     * {@link ActionContributionItem}s based on the {@link IAction}s contained in the given collection,
+     * by inserting them before the specified contribution item <code>contributionID</code>.
+     * If <code>contributionID</code> is <code>null</code>, they are simply added.
+     *
+     * @param pManager The contribution manager to populate
+     * @param pSubmenuActionsMap The submenu actions to add in the manager
+     * @param pContributionID The ID defining where the actions must be inserted. May be null
+     */
+    public void populateManager(
+        final IContributionManager pManager,
+        final Map<String, Collection<IAction>> pSubmenuActionsMap,
+        final String pContributionID) {
+
+        if (pManager != null && pSubmenuActionsMap != null) {
+            // Loop on the submenu action to add in the manager
+            for (final Map.Entry<String, Collection<IAction>> vSubmenuActionsMapEntry : pSubmenuActionsMap.entrySet()) {
+
+                // Create the submenu manager from the map entry key
+                MenuManager vSubmenuManager = new MenuManager(vSubmenuActionsMapEntry.getKey());
+
+                // Add the submenu in the given contribution manager
+                if (StringUtils.isNotEmpty(pContributionID)) {
+                    // Insert the action at the right location
+                    pManager.insertBefore(pContributionID, vSubmenuManager);
+                } else {
+                    // Simply add the action in the manager
+                    pManager.add(vSubmenuManager);
+                }
+
+                // Finally populate the submenu with all the linked actions, contained in the map value
+                populateManager(vSubmenuManager, vSubmenuActionsMapEntry.getValue(), null);
+            }
+        }
+    }
+
+    /**
+     * This removes from the specified <code>manager</code> all {@link ActionContributionItem}s
+     * based on the {@link IAction}s contained in the given collection.
+     *
+     * @param pManager The contribution manager to depopulate
+     * @param pActionsCollection The actions to remove from the manager
+     */
+    public void depopulateManager(
+        final IContributionManager pManager,
+        final Collection<? extends IAction> pActionsCollection) {
+
+        if (pManager != null && pActionsCollection != null) {
+            // Loop on the items currently contained in the contribution manager
+            for (final IContributionItem vContributionItem : pManager.getItems()) {
+
+                // Look into sub-contribution items to find the leaf of the menus
+                IContributionItem vSubcontributionItem = vContributionItem;
+                while (vSubcontributionItem instanceof SubContributionItem) {
+                    vSubcontributionItem = ((SubContributionItem) vSubcontributionItem).getInnerItem();
+                }
+
+                // Delete the sub-contribution corresponding to the actions to remove
+                if (vSubcontributionItem instanceof ActionContributionItem) {
+                    IAction vSubcontributionAction = ((ActionContributionItem) vSubcontributionItem).getAction();
+                    if (pActionsCollection.contains(vSubcontributionAction)) {
+                        pManager.remove(vSubcontributionItem);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * This removes from the specified <code>manager</code> all {@link MenuManager}s and their
+     * {@link ActionContributionItem}s based on the {@link IAction}s contained in the given map.
+     *
+     * @param pManager The contribution manager to depopulate
+     * @param pSubmenuActionsMap The submenu actions to remove from the manager
+     */
+    public void depopulateManager(
+        final IContributionManager pManager,
+        final Map<String, Collection<IAction>> pSubmenuActionsMap) {
+
+        if (pManager != null && pSubmenuActionsMap != null) {
+            // Loop on the items currently contained in the contribution manager
+            for (final IContributionItem vContributionItem : pManager.getItems()) {
+
+                if (vContributionItem instanceof MenuManager) {
+                    final MenuManager vSubmenuManager = (MenuManager) vContributionItem;
+
+                    // If the map contains the menu to remove, depopulate the menu and then
+                    // remove it from the parent contribution manager
+                    if (pSubmenuActionsMap.containsKey(vSubmenuManager.getMenuText())) {
+                        depopulateManager(vSubmenuManager, pSubmenuActionsMap.get(vContributionItem));
+                        pManager.remove(vContributionItem);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * This extracts those actions in the given collection whose text is qualified and returns
+     * a map of these actions, keyed by submenu text.
+     *
+     * @param pActionsCollection The collection of actions for which the submenus must be extracted
+     * @return The map of extracted submenus, with their text as key and all theirs actions as value
+     */
+    public Map<String, Collection<IAction>> extractSubmenuActions(final Collection<IAction> pActionsCollection) {
+        // Initialise the map
+        final Map<String, Collection<IAction>> vExtractedSubmenuActionsMap =
+            new LinkedHashMap<String, Collection<IAction>>();
+
+        if (pActionsCollection != null) {
+            // Loop on the given actions collection with an iterator as the collection may be modified
+            Iterator<IAction> vActionsIterator = pActionsCollection.iterator();
+            while (vActionsIterator.hasNext()) {
+                // Get the current action
+                final IAction vAction = vActionsIterator.next();
+
+                // Get the action text, to parse it and extract the submenus
+                // NB : Use an empty String by default to avoid the exception on the tokenizer if null
+                String vTextToTokenize = StringUtils.EMPTY;
+                if (StringUtils.isNotEmpty(vAction.getText())) {
+                    vTextToTokenize = vAction.getText();
+                }
+
+                // Parse the action text to find the submenus to create
+                final StringTokenizer vActionTextTokenizer = new StringTokenizer(vTextToTokenize, "|"); //$NON-NLS-1$
+
+                // Ensure that a submenu is needed
+                if (vActionTextTokenizer.countTokens() == 2) {
+                    // Get the submenu text, and the action text
+                    String vSubMenuText = vActionTextTokenizer.nextToken().trim();
+                    String vActionText = vActionTextTokenizer.nextToken().trim();
+
+                    // Get the collection of action corresponding to this submenu, to populate it
+                    Collection<IAction> vSubmenuActionsCollection = vExtractedSubmenuActionsMap.get(vSubMenuText);
+
+                    if (vSubmenuActionsCollection == null) {
+                        // The collection doesn't already exists, thus create it and add it in the map
+                        vSubmenuActionsCollection = new ArrayList<IAction>();
+                        vExtractedSubmenuActionsMap.put(vSubMenuText, vSubmenuActionsCollection);
+                    }
+
+                    // Then update the current action text and add it in the collection
+                    // of actions associated to the current submenu
+                    vAction.setText(vActionText);
+                    vSubmenuActionsCollection.add(vAction);
+
+                    // Finally remove the current action
+                    vActionsIterator.remove();
+                }
+            }
+        }
+
+        return vExtractedSubmenuActionsMap;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/FilterPartAction.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/FilterPartAction.java
new file mode 100644
index 0000000..283a0c7
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/FilterPartAction.java
@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.actions;
+
+import org.eclipse.jface.action.Action;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.swt.graphics.ImageData;
+import org.polarsys.esf.core.common.ui.filter.FilterPartManager;
+import org.polarsys.esf.core.common.ui.filter.IFilterPartListener;
+
+
+/**
+ * Custom action which allow to activate of deactivate the filter
+ * on a listener instance. The action representation is linked to the
+ * listener image.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class FilterPartAction
+    extends Action {
+
+    /** Reference to the singleton which manages the filter mechanisms. */
+    private static final FilterPartManager FILTER_PART_MANAGER = FilterPartManager.INSTANCE;
+    
+    /** The filter part listener linked to this action instance. */
+    private IFilterPartListener mListener = null;
+
+    /**
+     * Constructor which build an action associated to a listener instance,
+     * and specify if the action is already checked (activated) or not.
+     * 
+     * @param pListener The listener associated to this action instance
+     * @param pChecked If <code>true</code> this action will be checked directly
+     */
+    public FilterPartAction(final IFilterPartListener pListener, final boolean pChecked) {
+        // Call the standard constructor
+        this(pListener);
+        
+        // Update directly the action status
+        setChecked(pChecked);
+    }
+
+    /**
+     * Constructor which build an action associated to a listener instance.
+     * 
+     * @param pListener The listener
+     */
+    public FilterPartAction(final IFilterPartListener pListener) {
+        // Call the parent method
+        super(pListener.getTitle(), IAction.AS_CHECK_BOX);
+        
+        // Remember of the given listener
+        mListener = pListener;
+        
+        // Set the action image with the listener image
+        // Like this, the action representation is directly adapted
+        // to the linked listener instance representation
+        setImageDescriptor(new ImageDescriptor() {
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public ImageData getImageData() {
+                return mListener.getTitleImage().getImageData();
+            }
+        });
+
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * When the action is run, add or remove the listener
+     * according to this action status (checked or not). 
+     */
+    @Override
+    public void run() {
+        if (isChecked()) {
+            FILTER_PART_MANAGER.addFilterPartListener(mListener);
+        } else {
+            FILTER_PART_MANAGER.removeFilterPartListener(mListener);
+        }
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/FilterPartControlContribution.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/FilterPartControlContribution.java
new file mode 100644
index 0000000..b745c8a
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/FilterPartControlContribution.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.actions;
+
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.ui.menus.WorkbenchWindowControlContribution;
+import org.polarsys.esf.core.common.ui.widget.FilterComposite;
+
+/**
+ * Control contribution used to manage the widgets used to apply 
+ * filters on listener parts.
+ *   
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class FilterPartControlContribution
+    extends WorkbenchWindowControlContribution {
+    
+    /** The filter composite. */
+    private FilterComposite mFilterComposite = null;
+
+    /**
+     * The default constructor.
+     */
+    public FilterPartControlContribution() {
+        // Call the parent constructor
+        super();
+    }
+    
+    /**
+     * Creates and returns the control for this contribution item 
+     * under the given parent composite.
+     * 
+     * @param pParent The parent composite
+     * @return The new control
+     */
+    @Override
+    protected Control createControl(final Composite pParent) {
+        // Create and remember of the filter composite 
+        mFilterComposite = new FilterComposite(pParent);
+        
+        return mFilterComposite;
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/NoModifiesActionBarContributor.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/NoModifiesActionBarContributor.java
new file mode 100644
index 0000000..3973d96
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/NoModifiesActionBarContributor.java
@@ -0,0 +1,161 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.actions;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.command.Command;
+import org.eclipse.emf.common.command.UnexecutableCommand;
+import org.eclipse.emf.edit.ui.action.CopyAction;
+import org.eclipse.emf.edit.ui.action.CutAction;
+import org.eclipse.emf.edit.ui.action.DeleteAction;
+import org.eclipse.emf.edit.ui.action.PasteAction;
+import org.eclipse.jface.action.ActionContributionItem;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.Separator;
+
+
+/**
+ * 
+ * Action bar contributor
+ * 
+ * Overridden to remove all editions action, and clean popmenu.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class NoModifiesActionBarContributor
+    extends ViewActionBarContributor {
+
+    /**
+     * Default constructor.
+     */
+    public NoModifiesActionBarContributor() {
+        super();
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * @return an unexecutable command, to handle global delete action.
+     */
+    @Override
+    protected DeleteAction createDeleteAction() {
+        return new DeleteAction() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public Command createCommand(final Collection<?> pSelection) {
+                return UnexecutableCommand.INSTANCE;
+            }
+        };
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * @return an unexecutable command, to handle global cut action.
+     */
+    @Override
+    protected CutAction createCutAction() {
+        return new CutAction() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public Command createCommand(final Collection<?> pSelection) {
+                return UnexecutableCommand.INSTANCE;
+            }
+        };
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * @return an unexecutable command, to handle global paste action.
+     */
+    @Override
+    protected PasteAction createPasteAction() {
+        return new PasteAction() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public Command createCommand(final Collection<?> pSelection) {
+                return UnexecutableCommand.INSTANCE;
+            }
+        };
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * @return an unexecutable command, to handle global copy action.
+     */
+    @Override
+    protected CopyAction createCopyAction() {
+        return new CopyAction() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public Command createCommand(final Collection<?> pSelection) {
+                return UnexecutableCommand.INSTANCE;
+            }
+        };
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * Customise the add global action to remove the Show Properties
+     * which is not useful in this context.
+     */
+    @Override
+    protected void addGlobalActions(final IMenuManager pMenuManager) {
+        
+        // Call the parent method
+        super.addGlobalActions(pMenuManager);
+        
+        // Remove the show properties action
+        pMenuManager.remove(ActionBarContributorUtils.SHOW_PROPERTIES_ACTION_ID);
+    }    
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void menuAboutToShow(final IMenuManager pMenuManager) {
+        // Add our standard marker.
+        if ((style & ADDITIONS_LAST_STYLE) == 0) {
+            pMenuManager.add(new Separator(ActionBarContributorUtils.ADDITIONS_SEPARATOR_ID));
+        }
+        pMenuManager.add(new Separator(ActionBarContributorUtils.EDIT_SEPARATOR_ID));
+
+        pMenuManager.add(new ActionContributionItem(undoAction));
+        pMenuManager.add(new ActionContributionItem(redoAction));
+        pMenuManager.add(new Separator());
+
+        if ((style & ADDITIONS_LAST_STYLE) != 0) {
+            pMenuManager.add(new Separator(ActionBarContributorUtils.ADDITIONS_SEPARATOR_ID));
+            pMenuManager.add(new Separator());
+        }
+        // Add our other standard marker.
+        pMenuManager.add(new Separator(ActionBarContributorUtils.ADDITIONS_END_SEPARATOR_ID));
+
+        addGlobalActions(pMenuManager);
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/ViewActionBarContributor.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/ViewActionBarContributor.java
new file mode 100644
index 0000000..aa899c5
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/actions/ViewActionBarContributor.java
@@ -0,0 +1,450 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.actions;
+
+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.EditingDomainActionBarContributor;
+import org.eclipse.emf.edit.ui.action.ValidateAction;
+import org.eclipse.jface.action.Action;
+import org.eclipse.jface.action.IAction;
+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.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.StructuredSelection;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IPageLayout;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.PartInitException;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+
+/**
+ * This is the action bar contributor used for all the views linked to a resource of ESF.
+ * Its first implementation is coming from hmhanna.
+ * 
+ * It extends {@link EditingDomainActionBarContributor} which provide the standard mechanisms
+ * to provide the actions on an editing domain.
+ *
+ * It implements {@link ISelectionChangedListener} to be able to react when the selection changed in the
+ * active editor, to update the action linked to the current selection.
+ *
+ * This contributor will populate the view tool bar and menus with different kind of actions :
+ * <ul>
+ *  <li>Actions not linked to the current context (ie: expand / collapse tree)</li>
+ *  <li>Actions linked to the current selection when one is set (ie: create children elements)</li>
+ * </ul>
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class ViewActionBarContributor
+    extends EditingDomainActionBarContributor
+    implements ISelectionChangedListener {
+
+    /** Instance of utility class used by the action contributors. */
+    private ActionBarContributorUtils mActionBarContributorUtils = ActionBarContributorUtils.INSTANCE;
+
+    /** This keeps track of the active editor. */
+    private IWorkbenchPart mActivePart = null;
+
+    /** This keeps track of the current selection provider. */
+    private ISelectionProvider mSelectionProvider = null;
+
+    /**
+     * The id of the properties view that will be showed
+     * when the {@link #mShowPropertiesViewAction} run.
+     */
+    private String mPropertyViewsId = IPageLayout.ID_PROP_SHEET;
+
+    /**
+     * This action opens the Properties view.
+     */
+    private IAction mShowPropertiesViewAction =
+        new Action(ActionBarContributorUtils.SHOW_PROPERTIES_ACTION_LABEL) {
+
+            @Override
+            public void run() {
+                try {
+                    ViewActionBarContributor.this.getPage().showView(mPropertyViewsId);
+                } catch (final PartInitException pException) {
+                    CommonUIActivator.INSTANCE.log(pException);
+                }
+            }
+        };
+
+    /**
+     * This action refreshes the viewer of the current editor if the editor implements
+     * {@link org.eclipse.emf.common.ui.viewer.IViewerProvider}.
+     */
+    private IAction mRefreshViewerAction =
+        new Action(ActionBarContributorUtils.REFRESH_ACTION_LABEL) {
+
+            @Override
+            public boolean isEnabled() {
+                return mActivePart instanceof IViewerProvider;
+            }
+
+            @Override
+            public void run() {
+                if (mActivePart instanceof IViewerProvider) {
+                    final Viewer vViewer = ((IViewerProvider) mActivePart).getViewer();
+                    if (vViewer != null) {
+                        vViewer.refresh();
+                    }
+                }
+            }
+        };
+
+    /**
+     * This will contain one {@link org.eclipse.emf.edit.ui.action.CreateChildAction}
+     * for each descriptor generated for the current selection, by the item provider.
+     */
+    private Collection<IAction> mCreateChildActionsCollection = null;
+
+    /**
+     * This creates an instance of the contributor with the default style
+     * {@link EditingDomainActionBarContributor#ADDITIONS_LAST_STYLE}.
+     */
+    public ViewActionBarContributor() {
+        super(ADDITIONS_LAST_STYLE);
+        validateAction = createValidateAction();
+
+        // Initialise the created actions id
+        initialiseActionsId();
+    }
+
+    /**
+     * Initialise the identifier for the actions created by this instance.
+     * This is mandatory to be able to identify the actions in the menus after their insertion.
+     */
+    private void initialiseActionsId() {
+        mRefreshViewerAction.setId(ActionBarContributorUtils.REFRESH_ACTION_ID);
+        mShowPropertiesViewAction.setId(ActionBarContributorUtils.SHOW_PROPERTIES_ACTION_ID);
+    }
+
+    /**
+     * Create and return a new Validate action.
+     * @return The validate action created
+     */
+    protected ValidateAction createValidateAction() {
+        return new ValidateAction();
+    }
+
+    /**
+     * Set the style for managing the separators and the actions.
+     * By default the style is {@link EditingDomainActionBarContributor#ADDITIONS_LAST_STYLE}.
+     * 
+     * @param pStyle The style to set
+     */
+    public void setStyle(final int pStyle) {
+        this.style = pStyle;
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * This adds the separators for 'additions' and 'settings' action in the tool bar.
+     */
+    @Override
+    public void contributeToToolBar(final IToolBarManager pToolBarManager) {
+        pToolBarManager.add(new Separator("views-settings")); //$NON-NLS-1$
+        pToolBarManager.add(new Separator("views-additions")); //$NON-NLS-1$
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * When the active editor changes, this remembers the change and registers
+     * this instance with it as a selection provider.
+     */
+    @Override
+    public void setActiveEditor(final IEditorPart pPart) {
+        // Call the parent method
+        super.setActiveEditor(pPart);
+
+        // Consider the active editor as the active part
+        setActivePart(pPart);
+    }
+
+    /**
+     * When the active part changes, this remembers the change and registers
+     * this instance with it as a selection provider.
+     * 
+     * @param pWorkbenchPart The active workbench part
+     */
+    public void setActivePart(final IWorkbenchPart pWorkbenchPart) {
+        // Ensure that the given part is valid and different from the
+        // current part referenced as active
+        if (pWorkbenchPart != null && !pWorkbenchPart.equals(mActivePart)) {
+            if (mActivePart != null) {
+                deactivate();
+            }
+
+            if (pWorkbenchPart instanceof IEditingDomainProvider) {
+                mActivePart = pWorkbenchPart;
+                activate();
+            }
+
+            mActivePart = pWorkbenchPart;
+            if (mSelectionProvider != null) {
+                mSelectionProvider.removeSelectionChangedListener(this);
+            }
+            if (pWorkbenchPart != null) {
+                mSelectionProvider = pWorkbenchPart.getSite().getSelectionProvider();
+                mSelectionProvider.addSelectionChangedListener(this);
+                if (mSelectionProvider.getSelection() != null) {
+                    selectionChanged(new SelectionChangedEvent(mSelectionProvider, mSelectionProvider.getSelection()));
+                }
+            }
+        }
+        getActionBars().updateActionBars();
+    }
+
+    /**
+     * Set the id of the property view which will be shown with
+     * the action {@link #mShowPropertiesViewAction}.
+     * 
+     * @param pPropertyViewsId The properties view id
+     */
+    public void setPropertyViewsId(final String pPropertyViewsId) {
+        mPropertyViewsId = pPropertyViewsId;
+    }
+
+    /**
+     * @return The active part
+     */
+    public IWorkbenchPart getActivePart() {
+        return mActivePart;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This implements {@link ISelectionChangedListener}, handling {@link SelectionChangedEvent}s
+     * by querying for the children and siblings that can be added to the selected object
+     * and updating the menus accordingly.
+     */
+    @Override
+    public void selectionChanged(final SelectionChangedEvent pEvent) {
+        // Query the new selection for appropriate new child/descriptors
+        Collection<?> vNewChildDescriptorsCollection = null;
+
+        final ISelection vSelection = pEvent.getSelection();
+        if ((vSelection instanceof IStructuredSelection) && (((IStructuredSelection) vSelection).size() == 1)) {
+            final Object vObject = ((IStructuredSelection) vSelection).getFirstElement();
+
+            final EditingDomain vDomain = ((IEditingDomainProvider) mActivePart).getEditingDomain();
+
+            vNewChildDescriptorsCollection = vDomain.getNewChildDescriptors(vObject, null);
+        }
+
+        // Generate actions for selection, then populate and redraw the menus
+        mCreateChildActionsCollection = mActionBarContributorUtils.generateCreateChildActionsCollection(
+            mActivePart,
+            vNewChildDescriptorsCollection,
+            vSelection);
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * This populates the pop-up menu before it appears with the child creation actions.
+     */
+    @Override
+    public void menuAboutToShow(final IMenuManager pMenuManager) {
+        // Call the parent method
+        super.menuAboutToShow(pMenuManager);
+
+        // Create the create child submenu
+        MenuManager vCreateChildSubmenuManager = new MenuManager(ActionBarContributorUtils.CREATECHILD_MENU_ID);
+
+        // Populate the submenu and insert it in the parent menu manager
+        mActionBarContributorUtils.populateManager(vCreateChildSubmenuManager, mCreateChildActionsCollection, null);
+        pMenuManager.insertBefore(ActionBarContributorUtils.EDIT_SEPARATOR_ID, vCreateChildSubmenuManager);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void addGlobalActions(final IMenuManager pMenuManager) {
+        // Insert the show properties action after a custom separator for the ui actions
+        pMenuManager.insertAfter(
+            ActionBarContributorUtils.ADDITIONS_END_SEPARATOR_ID,
+            new Separator(ActionBarContributorUtils.UI_ACTIONS_SEPARATOR_ID));
+        pMenuManager.insertAfter(
+            ActionBarContributorUtils.UI_ACTIONS_SEPARATOR_ID,
+            mShowPropertiesViewAction);
+
+        // Insert the refresh action, and update its state, after the the ui actions separator
+        mRefreshViewerAction.setEnabled(mRefreshViewerAction.isEnabled());
+        pMenuManager.insertAfter(ActionBarContributorUtils.UI_ACTIONS_SEPARATOR_ID, mRefreshViewerAction);
+
+        // Call the parent method to add the others global actions (Validate, etc.)
+        super.addGlobalActions(pMenuManager);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Called when a view is deactivated to deactivate all the linked actions.
+     */
+    @Override
+    public void deactivate() {
+        mActivePart.removePropertyListener(this);
+
+        deleteAction.setActiveWorkbenchPart(null);
+        cutAction.setActiveWorkbenchPart(null);
+        copyAction.setActiveWorkbenchPart(null);
+        pasteAction.setActiveWorkbenchPart(null);
+        undoAction.setActiveWorkbenchPart(null);
+        redoAction.setActiveWorkbenchPart(null);
+
+        if (loadResourceAction != null) {
+            loadResourceAction.setActiveWorkbenchPart(null);
+        }
+
+        if (controlAction != null) {
+            controlAction.setActiveWorkbenchPart(null);
+        }
+
+        if (validateAction != null) {
+            validateAction.setActiveWorkbenchPart(null);
+        }
+
+        ISelectionProvider vSelectionProvider = null;
+        if (mActivePart instanceof ISelectionProvider) {
+            vSelectionProvider = (ISelectionProvider) mActivePart;
+        } else {
+            vSelectionProvider = mActivePart.getSite().getSelectionProvider();
+        }
+
+        if (vSelectionProvider != null) {
+            vSelectionProvider.removeSelectionChangedListener(deleteAction);
+            vSelectionProvider.removeSelectionChangedListener(cutAction);
+            vSelectionProvider.removeSelectionChangedListener(copyAction);
+            vSelectionProvider.removeSelectionChangedListener(pasteAction);
+
+            if (validateAction != null) {
+                vSelectionProvider.removeSelectionChangedListener(validateAction);
+            }
+
+            if (controlAction != null) {
+                vSelectionProvider.removeSelectionChangedListener(controlAction);
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Called when a view is activated to enable all the linked actions.
+     */
+    @Override
+    public void activate() {
+        mActivePart.addPropertyListener(this);
+
+        deleteAction.setActiveWorkbenchPart(mActivePart);
+        cutAction.setActiveWorkbenchPart(mActivePart);
+        copyAction.setActiveWorkbenchPart(mActivePart);
+        pasteAction.setActiveWorkbenchPart(mActivePart);
+        undoAction.setActiveWorkbenchPart(mActivePart);
+        redoAction.setActiveWorkbenchPart(mActivePart);
+
+        if (validateAction != null) {
+            validateAction.setActiveWorkbenchPart(mActivePart);
+        }
+
+        ISelectionProvider vSelectionProvider = null;
+        if (mActivePart instanceof ISelectionProvider) {
+            vSelectionProvider = (ISelectionProvider) mActivePart;
+        } else {
+            vSelectionProvider = mActivePart.getSite().getSelectionProvider();
+        }
+
+        if (vSelectionProvider != null) {
+            vSelectionProvider.addSelectionChangedListener(deleteAction);
+            vSelectionProvider.addSelectionChangedListener(cutAction);
+            vSelectionProvider.addSelectionChangedListener(copyAction);
+            vSelectionProvider.addSelectionChangedListener(pasteAction);
+
+            if (validateAction != null) {
+                vSelectionProvider.addSelectionChangedListener(validateAction);
+            }
+        }
+
+        update();
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Update the actions to the current selection context.
+     */
+    @Override
+    public void update() {
+        // Try to get the selection provider from the active part. It can be the active part itself
+        // if it's a selection provider
+        ISelectionProvider vSelectionProvider = null;
+        if (mActivePart instanceof ISelectionProvider) {
+            vSelectionProvider = (ISelectionProvider) mActivePart;
+        } else if (mActivePart != null) {
+            vSelectionProvider = mActivePart.getSite().getSelectionProvider();
+        }
+
+        if (vSelectionProvider != null) {
+            IStructuredSelection vStructuredSelection = null;
+            if (vSelectionProvider.getSelection() instanceof IStructuredSelection) {
+                vStructuredSelection = (IStructuredSelection) vSelectionProvider.getSelection();
+            } else {
+                vStructuredSelection = StructuredSelection.EMPTY;
+            }
+
+            deleteAction.updateSelection(vStructuredSelection);
+            cutAction.updateSelection(vStructuredSelection);
+            copyAction.updateSelection(vStructuredSelection);
+            pasteAction.updateSelection(vStructuredSelection);
+
+            if (validateAction != null) {
+                validateAction.updateSelection(vStructuredSelection);
+            }
+        }
+
+        // Ensure that the undo and redo action have a domain to update them
+        // In they don't, the update action will throw a NPE
+        if (undoAction.getEditingDomain() != null) {
+            undoAction.update();
+        }
+        if (redoAction.getEditingDomain() != null) {
+            redoAction.update();
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This implementation ensures that a delete action will clean up all references to deleted objects.
+     */
+    @Override
+    protected boolean removeAllReferencesOnDelete() {
+        return true;
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/adapter/PartListenerAdapter.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/adapter/PartListenerAdapter.java
new file mode 100644
index 0000000..13066ae
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/adapter/PartListenerAdapter.java
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.adapter;
+
+import org.eclipse.ui.IPartListener;
+import org.eclipse.ui.IWorkbenchPart;
+
+
+/**
+ * A default implementation of the <code>IPartListener</code> interface.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class PartListenerAdapter implements IPartListener {
+    
+    /**
+     * Default constructor.
+     */
+    public PartListenerAdapter() {
+        // Nothing to do
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void partActivated(final IWorkbenchPart pPart) {
+         // Not implemented
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void partBroughtToTop(final IWorkbenchPart pPart) {
+        // Not implemented
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void partClosed(final IWorkbenchPart pPart) {
+        // Not implemented
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void partDeactivated(final IWorkbenchPart pPart) {
+        // Not implemented
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void partOpened(final IWorkbenchPart pPart) {
+        // Not implemented
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/console/ConsoleUtils.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/console/ConsoleUtils.java
new file mode 100644
index 0000000..cc0b65a
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/console/ConsoleUtils.java
@@ -0,0 +1,82 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.console;
+
+import java.io.PrintStream;
+
+import org.eclipse.ui.console.ConsolePlugin;
+import org.eclipse.ui.console.IConsole;
+import org.eclipse.ui.console.MessageConsole;
+import org.eclipse.ui.console.MessageConsoleStream;
+
+/**
+ * 
+ * Console Utils used with console view.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public final class ConsoleUtils {
+
+    /**
+     * Keep trace of default output stream, to restore it if needed.
+     */
+    private static final PrintStream DEFAULT_OUTSTREAM = System.out;
+
+    /**
+     * Keep trace of default ouput error stream, to restore it if needed.
+     */
+    private static final PrintStream DEFAULT_ERRSTREAM = System.err;
+
+    /**
+     * Console title.
+     */
+    private static final String CONSOLE_TITLE = "Console"; //$NON-NLS-1$
+
+    /**
+     * Private constructor to avoid instantiation.
+     */
+    private ConsoleUtils() {
+    }
+
+    /**
+     * Reroute default output stream to a new console, added to console view.
+     */
+    public static void linkDefaultOutStreamToConsole() {
+        // Create a msg console.
+        final MessageConsole vConsole = new MessageConsole(CONSOLE_TITLE, null);
+
+        // Add it to console manager. If "equivalent" console already exists, does not seem to add it.
+        ConsolePlugin.getDefault().getConsoleManager().addConsoles(
+            new IConsole[] {vConsole });
+
+        final MessageConsoleStream vStream = vConsole.newMessageStream();
+
+        PrintStream vPrintStream = new PrintStream(vStream);
+
+        // Link standard output stream to the console.
+        System.setOut(vPrintStream);
+
+        // Link error output stream to the console.
+        System.setErr(vPrintStream);
+
+    }
+
+    /**
+     * Reset output stream to system one.
+     */
+    public static void unlinkDefaultOutStreamToConsole() {
+
+        System.setOut(DEFAULT_OUTSTREAM);
+        System.setErr(DEFAULT_ERRSTREAM);
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/constants/ImageConstants.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/constants/ImageConstants.java
new file mode 100644
index 0000000..f8c8154
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/constants/ImageConstants.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.constants;
+
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.ui.ISharedImages;
+import org.eclipse.ui.PlatformUI;
+
+/**
+ * Utility class used to store several constants for the images used.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public final class ImageConstants {
+        
+    /** The info icon, shared in the workbench. */
+    public static final Image ICON_INFO = 
+        PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJS_INFO_TSK);
+    
+    /** The warning icon, shared in the workbench. */
+    public static final Image ICON_WARNING = 
+        PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJS_WARN_TSK);
+    
+    /** The error icon, shared in the workbench. */
+    public static final Image ICON_ERROR = 
+        PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJS_ERROR_TSK);
+    
+    /** The disabled clear image. */
+    public static final Image ICON_CLEAR_DISABLED = 
+        PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_ETOOL_CLEAR_DISABLED);
+
+    /** The clear image. */
+    public static final Image ICON_CLEAR = 
+        PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_ETOOL_CLEAR);
+
+    /** The pressed clear image (its the same as the disabled image). */
+    public static final Image ICON_CLEAR_PRESSED = 
+        PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_ETOOL_CLEAR_DISABLED);
+    
+    /**
+     * Default constructor, private as it's a utility class. 
+     */
+    private ImageConstants() {
+    }
+    
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editingsupport/ParameterValueEditingSupport.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editingsupport/ParameterValueEditingSupport.java
new file mode 100644
index 0000000..256d207
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editingsupport/ParameterValueEditingSupport.java
@@ -0,0 +1,217 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.editingsupport;
+
+import java.math.BigDecimal;
+import java.util.Map.Entry;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.jface.viewers.CellEditor;
+import org.eclipse.jface.viewers.ColumnViewer;
+import org.eclipse.jface.viewers.EditingSupport;
+import org.eclipse.jface.viewers.ICellEditorListener;
+import org.eclipse.jface.viewers.ICellEditorValidator;
+import org.eclipse.jface.viewers.TextCellEditor;
+import org.eclipse.jface.viewers.ViewerCell;
+import org.eclipse.swt.widgets.Composite;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+import org.polarsys.esf.core.common.ui.statusline.StatusLinesUtil;
+
+
+/**
+ * Implementation of editing support for set value of probability rule's parameters.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class ParameterValueEditingSupport 
+    extends EditingSupport {
+
+    /** Cell editor for parameter value. */
+    private CellEditor mCellEditor = null;
+    
+    /**
+     * Default constructor.
+     * 
+     * @param pViewer Viewer used to edit the rules parameter
+     */
+    public ParameterValueEditingSupport(final ColumnViewer pViewer) {
+        super(pViewer);
+
+        // Initialise the cell editor to use
+        initialiseCellEditor();
+    }
+
+    /**
+     * Initialise the cell editor, which will manage the value validation.
+     */
+    private void initialiseCellEditor() {
+        // Create the cell editor
+        mCellEditor = new TextCellEditor((Composite) getViewer().getControl());
+        
+        // Add a new validator to ensure that the value is correct
+        mCellEditor.setValidator(new ICellEditorValidator() {
+
+            /**
+             * {@inheritDoc}
+             * 
+             * A parameter value must be a numerical value.
+             */
+            @Override
+            public String isValid(final Object pValue) {
+
+                // Initialise result with valid state
+                String vMessage = null;
+
+                // Verify if value is a non empty string
+                if ((pValue instanceof String) && StringUtils.isNotEmpty((String) pValue)) {
+
+
+                    try {
+                        // Check that value can be converted in big decimal
+                        new BigDecimal((String) pValue);
+                    
+                    } catch (final NumberFormatException pException) {
+                        // Set the error message top warn the user 
+                        vMessage = CommonUIActivator.getMessages()
+                            .getString("ParameterValueEditingSupport.warning.notnumerical"); //$NON-NLS-1$ 
+                    }
+                }
+                
+                return vMessage;
+            }
+        });
+        
+        
+        // Add a new listener on the cell editor to react to the value validation
+        // and display any message to the user
+        mCellEditor.addListener(new ICellEditorListener() {
+
+            /**
+             * {@inheritDoc}
+             * 
+             * This implementation aim is to display error message when the value is not valid.
+             */
+            @Override
+            public void editorValueChanged(final boolean pOldValidState, final boolean pNewValidState) {
+                if (!pNewValidState) {
+                    // The new state is not valid, thus display an error message
+                    StatusLinesUtil.outputMessage(mCellEditor.getErrorMessage(), IStatus.WARNING);
+                } else {
+                    // The new state is valid, clear the status message
+                    StatusLinesUtil.clearMessage();
+                }
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void cancelEditor() {
+                // The new state is valid, clear the status message
+                StatusLinesUtil.clearMessage();
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void applyEditorValue() {
+                // Nothing to do
+            }
+        });
+
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected CellEditor getCellEditor(final Object pElement) {
+        return mCellEditor;
+
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected boolean canEdit(final Object pElement) {
+        return true;
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * The rule's parameters are stored in a map, with the parameter
+     * name as key, and its value as value. The edited object is an entry
+     * of this map, and the value returned by this method must thus be the 
+     * value of this entry.
+     */
+    @Override
+    protected Object getValue(final Object pElement) {
+        Object vValue = null;
+        
+        // Check if the given object is an entry of a map
+        if (pElement instanceof Entry<?, ?>) {
+            // Get the value of this entry, which corresponds to the 
+            // value of the edited parameter, as String
+            vValue = ((Entry<?, ?>) pElement).getValue();
+        }
+        return vValue;
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * The rule's parameters are stored in a map, with the parameter
+     * name as key, and its value as value. The edited object is an entry
+     * of this map, and the value to set must thus be the value of this entry.
+     */
+    @Override
+    protected void setValue(final Object pElement, final Object pValue) {
+        // Check if the given object is an entry of a map
+        if (pElement instanceof Entry<?, ?>) {
+            // Update the entry value with the given value
+            ((Entry) pElement).setValue(pValue);
+        }
+
+        // Update the viewer
+        getViewer().update(pElement, null);
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * If there is no error the value is saved and the status line message is cleared.
+     * Otherwise, display an error message.
+     * 
+     * @param pCellEditor The cell editor
+     * @param pViewerCell The cell on which the cell editor is working
+     */
+    @Override
+    protected void saveCellEditorValue(final CellEditor pCellEditor, final ViewerCell pViewerCell) {
+        
+        // Check if the cell editor consider the value as valid
+        if (pCellEditor.isValueValid()) {
+            // Clear the status message
+            StatusLinesUtil.clearMessage();
+                        
+            // Call the parent method to save the value in the model
+            super.saveCellEditorValue(pCellEditor, pViewerCell);    
+            
+        } else {
+            // The value is not valid, display an error message and don't save the new value
+            StatusLinesUtil.outputMessage(pCellEditor.getErrorMessage(), IStatus.WARNING);
+        }
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editingsupport/ValidatedPropertyEditingSupport.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editingsupport/ValidatedPropertyEditingSupport.java
new file mode 100644
index 0000000..e526b0a
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editingsupport/ValidatedPropertyEditingSupport.java
@@ -0,0 +1,158 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.editingsupport;
+
+import org.eclipse.jface.action.IStatusLineManager;
+import org.eclipse.jface.viewers.CellEditor;
+import org.eclipse.jface.viewers.ColumnViewer;
+import org.eclipse.jface.viewers.ICellEditorListener;
+import org.eclipse.jface.viewers.ViewerCell;
+import org.eclipse.ui.views.properties.IPropertySourceProvider;
+import org.eclipse.ui.views.properties.PropertyEditingSupport;
+import org.polarsys.esf.core.common.ui.constants.ImageConstants;
+
+/**
+ * This class is a custom {@link PropertyEditingSupport} that provides a validation.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class ValidatedPropertyEditingSupport
+    extends PropertyEditingSupport {
+
+    /** The cell editor used by this instance. */
+    private CellEditor mCellEditor = null;
+    
+    /** The status line manager used to display the validation messages. */
+    private IStatusLineManager mStatusLineManager = null;
+
+    /**
+     * The default constructor.
+     * 
+     * @param pViewer The viewer which will allow to display, edit and validate the properties
+     * @param pPropertySourceProvider The property source provider used
+     * @param pPropertyId The id of the property edited
+     * @param pStatusLineManager The status line manager used to display the validation messages
+     */
+    public ValidatedPropertyEditingSupport(
+        final ColumnViewer pViewer, 
+        final IPropertySourceProvider pPropertySourceProvider, 
+        final Object pPropertyId,
+        final IStatusLineManager pStatusLineManager) {
+
+        // Call the parent method
+        super(pViewer, pPropertySourceProvider, pPropertyId);
+        
+        mStatusLineManager = pStatusLineManager;
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * This is overridden, to manage the cell validation and display
+     * the potential messages in the status bar.
+     */
+    @Override
+    protected CellEditor getCellEditor(final Object pObject) {
+        // Try to get the cell editor corresponding to the given objet
+        // by calling the parent method
+        // NB : If the cell is in read only mode, this will return null
+        mCellEditor = super.getCellEditor(pObject);
+
+        if (mCellEditor != null) {
+
+            // If the cell editor is not null, add a new listener on it
+            // to add the validation mechanisms on it
+            mCellEditor.addListener(new ICellEditorListener() {
+
+                /**
+                 * {@inheritDoc}
+                 * 
+                 * This implementation aim is to display error message when the value is not valid.
+                 */
+                @Override
+                public void editorValueChanged(final boolean pOldValidState, final boolean pNewValidState) {
+                    if (!pNewValidState) {
+                        // The new state is not valid, thus display an error message
+                        setStatusLineMessage(mCellEditor.getErrorMessage(), true);
+                    } else {
+                        // The new state is valid, clear the status message
+                        setStatusLineMessage(null, false);
+                    }
+                }
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public void cancelEditor() {
+                    // Simply clear the message on a cancel
+                    setStatusLineMessage(null, false);
+                }
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public void applyEditorValue() {
+                    // Nothing to do
+                }
+            });
+        }
+        
+        return mCellEditor;
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * If there is no error the value is saved and the status line message is cleared.
+     * Otherwise, display an error message.
+     * 
+     * @param pCellEditor the cell-editor
+     * @param pViewerCell the cell the editor is working for
+     */
+    @Override
+    protected void saveCellEditorValue(final CellEditor pCellEditor, final ViewerCell pViewerCell) {
+        
+        // Check if the cell editor consider the value as valid
+        if (pCellEditor.isValueValid()) {
+            // Clear the status message
+            setStatusLineMessage(null, false);
+            
+            // Call the parent method to save the value in the model
+            super.saveCellEditorValue(pCellEditor, pViewerCell);    
+            
+        } else {
+            // The value is not valid, display an error message and don't save the new value
+            setStatusLineMessage(pCellEditor.getErrorMessage(), true);
+        }
+    }
+    
+    /**
+     * Set the message to the status line manager.
+     * It can be treated as an error message or not according to the flag given in parameter.
+     * 
+     * @param pMessage The message to set
+     * @param pIsErrorMsg <code>true</code> if the message is an error message, <code>false</code> otherwise
+     */
+    private void setStatusLineMessage(final String pMessage, final boolean pIsErrorMsg) {
+
+        if (mStatusLineManager != null) {
+            // Update the status message, with an error status or not
+            if (pIsErrorMsg) {
+                mStatusLineManager.setErrorMessage(ImageConstants.ICON_ERROR, pMessage);
+            } else {
+                mStatusLineManager.setMessage(ImageConstants.ICON_INFO, pMessage);
+            }
+        }
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/AbstractActionBarContributor.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/AbstractActionBarContributor.java
new file mode 100644
index 0000000..f3b4ee0
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/AbstractActionBarContributor.java
@@ -0,0 +1,637 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.editor;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+
+import org.apache.commons.lang3.StringUtils;
+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.DeleteAction;
+import org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor;
+import org.eclipse.emf.edit.ui.action.ValidateAction;
+import org.eclipse.jface.action.Action;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.action.IContributionItem;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.MenuManager;
+import org.eclipse.jface.action.Separator;
+import org.eclipse.jface.action.ToolBarManager;
+import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.jface.viewers.AbstractTreeViewer;
+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.IActionBars;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IPageLayout;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.actions.ActionFactory;
+import org.eclipse.ui.handlers.CollapseAllHandler;
+import org.eclipse.ui.handlers.ExpandAllHandler;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+import org.polarsys.esf.core.common.ui.CommonUIActivator.Implementation;
+import org.polarsys.esf.core.common.ui.actions.ActionBarContributorUtils;
+import org.polarsys.esf.core.common.ui.provider.IToolBarManagerProvider;
+
+/**
+ * This is the abstract action bar contributor used for all the multi pages editors.
+ *
+ * It extends {@link EditingDomainActionBarContributor} which provide the standard mechanisms
+ * to provide the actions on an editing domain.
+ *
+ * It implements {@link ISelectionChangedListener} to be able to react when the selection changed in the
+ * active editor, to update the action linked to the current selection.
+ *
+ * This contributor will populate the editor tool bar with different kind of actions :
+ * <ul>
+ *  <li>Actions not linked to the current context (ie: expand / collapse tree)</li>
+ *  <li>Actions linked to the current selection when one is set (ie: create children elements)</li>
+ * </ul>
+ *
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public abstract class AbstractActionBarContributor
+    extends EditingDomainActionBarContributor
+    implements ISelectionChangedListener {
+
+    /** Instance of utility class used by the action contributors. */
+    private ActionBarContributorUtils mActionBarContributorUtils = ActionBarContributorUtils.INSTANCE;
+
+    /** This keeps track of the active editor on which the actions are applied. */
+    private IEditorPart mActiveEditorPart = null;
+
+    /** This keeps track of the current selection provider. */
+    private ISelectionProvider mSelectionProvider = null;
+
+    /** This action opens the Properties view. */
+    private IAction mShowPropertiesViewAction = new Action(ActionBarContributorUtils.SHOW_PROPERTIES_ACTION_LABEL) {
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void run() {
+            try {
+                getPage().showView(IPageLayout.ID_PROP_SHEET);
+            } catch (final PartInitException pException) {
+                CommonUIActivator.logError(
+                    "Error during the opening of the Properties view", //$NON-NLS-1$
+                    pException);
+            }
+        }
+    };
+
+    /** This action expands the active editor content, if possible. */
+    private IAction mExpandAllAction = createExpandAllAction();
+
+    /** This action collapse the active editor content, if possible. */
+    private IAction mCollapseAllAction = createCollapseAllAction();
+
+    /**
+     * This action refreshes the viewer of the current editor if the editor
+     * implements {@link org.eclipse.emf.common.ui.viewer.IViewerProvider}.
+     */
+    private IAction mRefreshViewerAction = new Action(ActionBarContributorUtils.REFRESH_ACTION_LABEL) {
+
+        /**
+         * {@inheritDoc}
+         *
+         * The action is enabled only if the editor implements {@link IViewerProvider}
+         * to provide its owned viewer.
+         */
+        @Override
+        public boolean isEnabled() {
+            return mActiveEditorPart instanceof IViewerProvider;
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void run() {
+            if (mActiveEditorPart instanceof IViewerProvider) {
+                final Viewer vViewer = ((IViewerProvider) mActiveEditorPart).getViewer();
+                if (vViewer != null) {
+                    vViewer.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.
+     */
+    private Collection<IAction> mCreateSelectChildActionsColl = Collections.emptyList();
+
+    /**
+     * This will contain a map of {@link org.eclipse.emf.edit.ui.action.CreateChildAction}s, keyed by sub-menu text
+     * for all the create child action relative to the current selection.
+     */
+    private Map<String, Collection<IAction>> mCreateSelectChildMenuActionsMap = null;
+
+    /** This is the menu manager into which menu contribution items should be added for CreateChild actions. */
+    private IMenuManager mCreateSelectChildMenuManager = null;
+
+    /**
+     * Default constructor.
+     * This creates an instance of the contributor with the default style
+     * {@link EditingDomainActionBarContributor#ADDITIONS_LAST_STYLE}.
+     */
+    public AbstractActionBarContributor() {
+        // Call the parent constructor and ask to add an 'additions' anchor at the end of the menu
+        super(ADDITIONS_LAST_STYLE);
+
+        // Create the parent action specific to the editing domain context
+        // NB : The 'load resource' and 'control' actions are not needed
+        validateAction = new ValidateAction();
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This implementation also call the method to contribute to any toolbar
+     * potentially provided by the active editor.
+     */
+    @Override
+    public void init(final IActionBars pActionBars) {
+        // Call the parent method
+        super.init(pActionBars);
+    }
+
+    /**
+     * Contribute to the editor toolbar, if the active editor provide a tool bar manager.
+     * This method may be called only once as it will create all the actions, even the global
+     * actions which doesn't need to change or be updated after their creation.
+     */
+    public void contributeToEditorToolBar() {
+
+        // Check if the editor provide a custom toolbar manager
+        if (mActiveEditorPart instanceof IToolBarManagerProvider) {
+            // Get the tool bar manager from the active editor
+            ToolBarManager vEditorToolBarManager = ((IToolBarManagerProvider) mActiveEditorPart).getToolBarManager();
+
+            // Use a flag to known if the tool bar content have been modified
+            boolean vNeedToUpdate = false;
+
+            // Add the expand all action if it's not already in it
+            if (vEditorToolBarManager.find(ActionBarContributorUtils.EXPAND_ALL_ACTION_ID) == null) {
+                vEditorToolBarManager.add(mExpandAllAction);
+                vNeedToUpdate = true;
+            }
+
+            // Add the collapse all action if it's not already in it
+            if (vEditorToolBarManager.find(ActionBarContributorUtils.COLLAPSE_ALL_ACTION_ID) == null) {
+                vEditorToolBarManager.add(mCollapseAllAction);
+                vNeedToUpdate = true;
+            }
+
+            // Add the separator for the actions on the selected element, if it's not already in it
+            if (vEditorToolBarManager.find(ActionBarContributorUtils.TOOLBAR_SEP_SELECTION_ACTIONS) == null) {
+                vEditorToolBarManager.add(new Separator(ActionBarContributorUtils.TOOLBAR_SEP_SELECTION_ACTIONS));
+                vNeedToUpdate = true;
+            }
+
+            // Add the delete action to the toolbar if it's not already in it
+            // This action will react to the selection change automatically
+            if (vEditorToolBarManager.find(ActionFactory.DELETE.getId()) == null) {
+                vEditorToolBarManager.add(new Separator(ActionBarContributorUtils.TOOLBAR_SEP_DELETE_ACTION));
+                vEditorToolBarManager.appendToGroup(ActionBarContributorUtils.TOOLBAR_SEP_DELETE_ACTION, deleteAction);
+                vNeedToUpdate = true;
+            }
+
+
+            // Finally update the toolbar if needed
+            if (vNeedToUpdate) {
+                vEditorToolBarManager.update(true);
+
+                vEditorToolBarManager.getControl().pack(true);
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * By default, no menu is added.
+     */
+    @Override
+    public void contributeToMenu(final IMenuManager pMenuManager) {
+        // Nothing to do
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * When the active editor changes, this remembers the change and registers
+     * this instance with it as a selection provider.
+     */
+    @Override
+    public void setActiveEditor(final IEditorPart pPart) {
+        // Call the parent method
+        super.setActiveEditor(pPart);
+
+        // Remember the active editor
+        mActiveEditorPart = pPart;
+
+        // If any selection provider was already registered, remove it
+        if (mSelectionProvider != null) {
+            mSelectionProvider.removeSelectionChangedListener(this);
+        }
+
+        // Then switch to the new selection provider if possible
+        if (mActiveEditorPart != null) {
+            // Get the selection provider from the new active editor
+            mSelectionProvider = mActiveEditorPart.getSite().getSelectionProvider();
+
+            // Register this instance to listen to the change on this selection provider
+            mSelectionProvider.addSelectionChangedListener(this);
+
+            // Fake a selection changed event to update the menus
+            if (mSelectionProvider.getSelection() != null) {
+                selectionChanged(new SelectionChangedEvent(mSelectionProvider, mSelectionProvider.getSelection()));
+            }
+
+        } else {
+            // Reset the selection provider
+            mSelectionProvider = null;
+        }
+
+        // Try to contribute to the tool bar that the active editor may provide
+        contributeToEditorToolBar();
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This implements {@link ISelectionChangedListener}, handling {@link SelectionChangedEvent}s
+     * by querying for the children that can be created under the selected object and updating the menus accordingly.
+     */
+    @Override
+    public void selectionChanged(final SelectionChangedEvent pEvent) {
+        // Recreate the actions linked to the current selection in the contextual menus and in the editor toolbar
+        addCreateSelectChildActions(pEvent.getSelection());
+    }
+
+    /**
+     * Create the new child actions for the current selection, in the context menu
+     * and the editor toolbar.
+     *
+     * @param pSelection The current selection for which the actions must be created
+     */
+    protected void addCreateSelectChildActions(final ISelection pSelection) {
+        // Force to update the action from the current selection,
+        // and recreate the actions in the menu
+        addCreateSelectChildActionsToMenu(pSelection, true);
+
+        // The recreate the actions in the tool bar, but without updating the
+        // actions as the selection has not changed
+        addCreateSelectChildActionsToEditorToolbar(pSelection, false);
+    }
+
+    /**
+     * Create the new child actions for the current selection in the editor context menu.
+     * The actions may be updated according to the given flag value. If no, the list of action
+     * is not updated according to the current selection, but the menu content is refresh even so.
+     *
+     * @param pSelection The current selection for which the actions must be created
+     * @param pUpdateActions If <code>true</code> the list of actions is updated according to the given selection
+     */
+    protected void addCreateSelectChildActionsToMenu(final ISelection pSelection, final boolean pUpdateActions) {
+        // Remove any menu items created for the old selection
+        if (mCreateSelectChildMenuManager != null) {
+            mActionBarContributorUtils.depopulateManager(
+                mCreateSelectChildMenuManager,
+                mCreateSelectChildMenuActionsMap);
+
+            mActionBarContributorUtils.depopulateManager(
+                mCreateSelectChildMenuManager,
+                mCreateSelectChildActionsColl);
+        }
+
+        // Update the list of actions used to create child for the
+        // given selection only if needed
+        if (pUpdateActions) {
+            updateCreateSelectChildActionsCollection(pSelection);
+        }
+
+        // Finally populate and redraw the menus
+        if (mCreateSelectChildMenuManager != null) {
+            mActionBarContributorUtils.populateManager(
+                mCreateSelectChildMenuManager,
+                mCreateSelectChildMenuActionsMap,
+                null);
+
+            mActionBarContributorUtils.populateManager(
+                mCreateSelectChildMenuManager,
+                mCreateSelectChildActionsColl,
+                null);
+
+            mCreateSelectChildMenuManager.update(true);
+        }
+    }
+
+    /**
+     * Create the new child actions for the current selection in the editor toolbar.
+     * The actions may be updated according to the given flag value. If no, the list of action
+     * is not updated according to the current selection, but the toolbar content is refresh even so.
+     *
+     * @param pSelection The current selection for which the actions must be created
+     * @param pUpdateActions If <code>true</code> the list of actions is updated according to the given selection
+     */
+    protected void addCreateSelectChildActionsToEditorToolbar(
+        final ISelection pSelection,
+        final boolean pUpdateActions) {
+
+        // Check if the editor provide a custom toolbar manager
+        if (mActiveEditorPart instanceof IToolBarManagerProvider) {
+            // Use a flag to known if the tool bar content have been modified
+            boolean vNeedToUpdate = false;
+
+            // Get the tool bar manager from the active editor
+            ToolBarManager vEditorToolBarManager = ((IToolBarManagerProvider) mActiveEditorPart).getToolBarManager();
+
+            // Depopulate the tool bar with the potential existing create child actions
+            for (IContributionItem vContributionItem : vEditorToolBarManager.getItems()) {
+                // The actions to remove are identified with their id prefix, thus check it
+                if (StringUtils.startsWith(
+                    vContributionItem.getId(),
+                    ActionBarContributorUtils.CREATECHILD_ACTION_ID_PREFIX)) {
+
+                    // Remove the action
+                    vEditorToolBarManager.remove(vContributionItem);
+                    vNeedToUpdate = true;
+                }
+            }
+
+            // Update the list of actions used to create child for the
+            // given selection only if needed
+            if (pUpdateActions) {
+                updateCreateSelectChildActionsCollection(pSelection);
+            }
+
+            // Then populate the tool bar with the new actions
+            for (IAction vAction : mCreateSelectChildActionsColl) {
+                // Check if the action is not already in the tool bar
+                if (vEditorToolBarManager.find(vAction.getId()) == null) {
+                    // Insert the action
+                    vEditorToolBarManager.appendToGroup(
+                        ActionBarContributorUtils.TOOLBAR_SEP_SELECTION_ACTIONS,
+                        vAction);
+
+                    // Remember that the toolbar must be updated
+                    vNeedToUpdate = true;
+                }
+            }
+
+            // Finally, update the toolbar if needed
+            if (vNeedToUpdate) {
+                vEditorToolBarManager.update(true);
+            }
+        }
+    }
+
+    /**
+     * Generate the list of create child actions corresponding to the selection given in parameter,
+     * and update this instance property {@link #mCreateSelectChildActionsColl} with it.
+     *
+     * The map of menus linked to the created action {@link #mCreateSelectChildMenuActionsMap}, is
+     * also updated.
+     *
+     * @param pSelection The current selection in the active editor
+     */
+    protected void updateCreateSelectChildActionsCollection(final ISelection pSelection) {
+
+        Collection<?> vNewChildDescrCollection = null;
+
+        // Ensure that the selection contains only one element
+        if (pSelection instanceof IStructuredSelection && ((IStructuredSelection) pSelection).size() == 1) {
+            // Get the selected object
+            Object vSelectedObject = ((IStructuredSelection) pSelection).getFirstElement();
+
+            // Get the editing domain from the active editor, and then
+            // query the new selection to find the appropriate new child descriptors
+            EditingDomain vEditingDomain = null;
+            if (mActiveEditorPart instanceof IEditingDomainProvider) {
+                vEditingDomain = ((IEditingDomainProvider) mActiveEditorPart).getEditingDomain();
+
+                // Find the new child actions corresponding to the selected objects
+                // and the editing domain used in the active editor
+                vNewChildDescrCollection = vEditingDomain.getNewChildDescriptors(vSelectedObject, null);
+            }
+        }
+
+        // Generate the actions corresponding to the current selection
+        mCreateSelectChildActionsColl = mActionBarContributorUtils.generateCreateChildActionsCollection(
+            mActiveEditorPart,
+            vNewChildDescrCollection,
+            pSelection);
+
+        // Then update the map menus with the created actions
+        mCreateSelectChildMenuActionsMap =
+            mActionBarContributorUtils.extractSubmenuActions(mCreateSelectChildActionsColl);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This populates the pop-up menu before it appears with the child creation actions.
+     */
+    @Override
+    public void menuAboutToShow(final IMenuManager pMenuManager) {
+        // Call the parent method
+        super.menuAboutToShow(pMenuManager);
+
+        // Create the create child submenu
+        MenuManager vCreateChildSubmenuManager = new MenuManager(ActionBarContributorUtils.CREATECHILD_MENU_LABEL);
+
+        // Populate the submenu and insert it in the parent menu manager
+        mActionBarContributorUtils.populateManager(
+            vCreateChildSubmenuManager,
+            mCreateSelectChildMenuActionsMap,
+            null);
+
+        mActionBarContributorUtils.populateManager(
+            vCreateChildSubmenuManager,
+            mCreateSelectChildActionsColl,
+            null);
+
+        pMenuManager.insertBefore(ActionBarContributorUtils.EDIT_SEPARATOR_ID, vCreateChildSubmenuManager);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void addGlobalActions(final IMenuManager pMenuManager) {
+
+        // Insert the show properties action after a custom separator for the ui actions
+        pMenuManager.insertAfter(
+            ActionBarContributorUtils.ADDITIONS_END_SEPARATOR_ID,
+            new Separator(ActionBarContributorUtils.UI_ACTIONS_SEPARATOR_ID));
+        pMenuManager.insertAfter(
+            ActionBarContributorUtils.UI_ACTIONS_SEPARATOR_ID,
+            mShowPropertiesViewAction);
+
+        // Insert the refresh action, and update its state, after the the ui actions separator
+        mRefreshViewerAction.setEnabled(mRefreshViewerAction.isEnabled());
+        pMenuManager.insertAfter(ActionBarContributorUtils.UI_ACTIONS_SEPARATOR_ID, mRefreshViewerAction);
+
+        // Call the parent method to add the others global actions (Validate, etc.)
+        super.addGlobalActions(pMenuManager);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This implementation ensures that a delete action will clean up all references to deleted objects.
+     */
+    @Override
+    protected boolean removeAllReferencesOnDelete() {
+        return true;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Overridden to ensure that the delete action id is set.
+     */
+    @Override
+    protected DeleteAction createDeleteAction() {
+        // Create the custom action
+        DeleteAction vDeleteAction = new DeleteAction(removeAllReferencesOnDelete());
+
+        // Update the action to set its id
+        vDeleteAction.setId(ActionFactory.DELETE.getId());
+
+        return vDeleteAction;
+    }
+
+    /**
+     * Create the expand all action to apply on the active editor,
+     * if this one is a viewer provider.
+     *
+     * @return The expand all action created
+     */
+    protected IAction createExpandAllAction() {
+        // Get the action image
+        final ImageDescriptor vImageDescriptor =
+            CommonUIActivator.getPlugin().getImageRegistry().getDescriptor(
+                Implementation.ICON_EXPAND_ALL_KEY);
+
+        // Create the action
+        final IAction vExpandAllAction = new Action(
+            ActionBarContributorUtils.EXPAND_ALL_ACTION_LABEL,
+            vImageDescriptor) {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void run() {
+                // Ensure that the active editor is a viewer provider
+                if (mActiveEditorPart instanceof IViewerProvider) {
+                    // Get the viewer from the active editor
+                    final Viewer vActiveViewer = ((IViewerProvider) mActiveEditorPart).getViewer();
+
+                    // Check if the viewer is eligible for an expand action
+                    if (vActiveViewer instanceof AbstractTreeViewer) {
+                        // Prepare the expand action asynchronously, on the UI thread
+                        mActiveEditorPart.getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                            /**
+                             * {@inheritDoc}
+                             */
+                            @Override
+                            public void run() {
+                                // Create the action handler on the viewer
+                                final ExpandAllHandler vExpandAllHandler =
+                                    new ExpandAllHandler((AbstractTreeViewer) vActiveViewer);
+
+                                // And finally execute it
+                                vExpandAllHandler.execute(null);
+                            }
+                        });
+                    }
+                }
+            }
+        };
+
+        // Set the unique id for this action
+        vExpandAllAction.setId(ActionBarContributorUtils.EXPAND_ALL_ACTION_ID);
+
+        return vExpandAllAction;
+    }
+
+    /**
+     * Create the collapse all action to apply on the active editor,
+     * if this one is a viewer provider.
+     *
+     * @return The collapse all action created
+     */
+    protected IAction createCollapseAllAction() {
+        // Get the action image
+        final ImageDescriptor vImageDescriptor =
+            CommonUIActivator.getPlugin().getImageRegistry().getDescriptor(
+                Implementation.ICON_COLLAPSE_ALL_KEY);
+
+        // Create the action
+        final IAction vCollapseAllAction = new Action(
+            ActionBarContributorUtils.COLLAPSE_ALL_ACTION_LABEL,
+            vImageDescriptor) {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void run() {
+                // Ensure that the active editor is a viewer provider
+                if (mActiveEditorPart instanceof IViewerProvider) {
+                    // Get the viewer from the active editor
+                    final Viewer vActiveViewer = ((IViewerProvider) mActiveEditorPart).getViewer();
+
+                    // Check if the viewer is eligible for an expand action
+                    if (vActiveViewer instanceof AbstractTreeViewer) {
+                        // Prepare the expand action asynchronously, on the UI thread
+                        mActiveEditorPart.getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                            /**
+                             * {@inheritDoc}
+                             */
+                            @Override
+                            public void run() {
+                                // Create the action handler on the viewer
+                                final CollapseAllHandler vCollapseAllHandler =
+                                    new CollapseAllHandler((AbstractTreeViewer) vActiveViewer);
+
+                                // And finally execute it
+                                vCollapseAllHandler.execute(null);
+                            }
+                        });
+                    }
+                }
+            }
+        };
+
+        // Set the unique id for this action
+        vCollapseAllAction.setId(ActionBarContributorUtils.COLLAPSE_ALL_ACTION_ID);
+
+        return vCollapseAllAction;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/AbstractMultiPageEditor.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/AbstractMultiPageEditor.java
new file mode 100644
index 0000000..2de9e33
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/AbstractMultiPageEditor.java
@@ -0,0 +1,1651 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.editor;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EventObject;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IResourceChangeEvent;
+import org.eclipse.core.resources.IResourceChangeListener;
+import org.eclipse.core.resources.IResourceDelta;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+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.ui.MarkerHelper;
+import org.eclipse.emf.common.ui.editor.ProblemEditorPart;
+import org.eclipse.emf.common.ui.viewer.IViewerProvider;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.common.util.WrappedException;
+import org.eclipse.emf.ecore.resource.Resource;
+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.IDisposable;
+import org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor;
+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.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.jface.action.IMenuListener;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.IStatusLineManager;
+import org.eclipse.jface.action.MenuManager;
+import org.eclipse.jface.action.Separator;
+import org.eclipse.jface.action.ToolBarManager;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.dialogs.ProgressMonitorDialog;
+import org.eclipse.jface.viewers.IBaseLabelProvider;
+import org.eclipse.jface.viewers.IContentProvider;
+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.StructuredSelection;
+import org.eclipse.jface.viewers.StructuredViewer;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.jface.viewers.TreeViewerColumn;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.jface.viewers.ViewerFilter;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.CTabFolder;
+import org.eclipse.swt.dnd.DND;
+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.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Menu;
+import org.eclipse.swt.widgets.ToolBar;
+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.actions.WorkspaceModifyOperation;
+import org.eclipse.ui.ide.IGotoMarker;
+import org.eclipse.ui.part.MultiPageEditorPart;
+import org.eclipse.ui.views.properties.IPropertySheetPage;
+import org.eclipse.ui.views.properties.IPropertySourceProvider;
+import org.eclipse.ui.views.properties.PropertyColumnLabelProvider;
+import org.eclipse.ui.views.properties.PropertySheet;
+import org.eclipse.ui.views.properties.PropertySheetPage;
+import org.eclipse.uml2.uml.UMLPackage;
+import org.polarsys.esf.core.common.adapter.ProblemIndicationAdapter;
+import org.polarsys.esf.core.common.listener.IProblemIndicationListener;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+import org.polarsys.esf.core.common.ui.adapter.PartListenerAdapter;
+import org.polarsys.esf.core.common.ui.filter.AbstractFilter;
+import org.polarsys.esf.core.common.ui.filter.IFilterPartListener;
+import org.polarsys.esf.core.common.ui.filter.NamePropertyFilter;
+import org.polarsys.esf.core.common.ui.provider.AdapterFactoryColumnLabelProvider;
+import org.polarsys.esf.core.common.ui.provider.IToolBarManagerProvider;
+import org.polarsys.esf.core.common.ui.view.properties.ArrayInputPropertySourceProvider;
+import org.polarsys.esf.core.common.ui.view.properties.PropertySourceProvider;
+import org.polarsys.esf.core.common.ui.widget.TreeViewerUtils;
+import org.polarsys.esf.core.common.visitor.ResourceDeltaVisitor;
+
+/**
+ * This is the abstract base for all the multi page editor, used to create and edit a resource content.
+ * The default implementation will manage a main page with a tree viewer and a toolbar, and a optional page
+ * only displayed if an error is identified in the resource content.
+ *
+ * It extends {@link MultiPageEditorPart} by convenience, even if it actually contains only one page.
+ *
+ * It implements :
+ * <ul>
+ * <li>{@link IEditingDomainProvider} : To provide the editing domain that it edits</li>
+ * <li>{@link ISelectionProvider} : To provide its selection to potential listeners</li>
+ * <li>{@link IMenuListener} : To be able to react when its context menu is going to be opened</li>
+ * <li>{@link IViewerProvider} : To provide its viewer</li>
+ * <li>{@link IGotoMarker} : To be able to react to a 'Go to' action, pointing to an element in its viewer</li>
+ * <li>{@link IToolBarManagerProvider} : To be able to provide the manager of the custom toolbar in the main page</li>
+ * <li>{@link IProblemIndicationListener} : To be able to react to the resources analysis, and warn the user if any
+ * error is detected</li>
+ * <li>{@link IFilterPartListener} : To be able to filter its content according to a text value.</li>
+ * </ul>
+ *
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public abstract class AbstractMultiPageEditor
+    extends MultiPageEditorPart
+    implements IEditingDomainProvider, ISelectionProvider, IMenuListener, IViewerProvider, IGotoMarker,
+    IToolBarManagerProvider, IProblemIndicationListener, IFilterPartListener {
+
+    /** Size of the first column. */
+    private static final int FIRST_COLUMN_DEFAULT_SIZE = 400;
+
+    /** This keeps track of the editing domain that is used to track all changes to the resource. */
+    private AdapterFactoryEditingDomain mEditingDomain = null;
+
+    /** This is the adapter factory used for providing views of the resource content. */
+    private AdapterFactory mAdapterFactory = null;
+
+    /** The property source provider used in the viewer. */
+    private IPropertySourceProvider mPropertySourceProvider = null;
+
+    /**
+     * The listener to plug to the command stack of the editing domain used,
+     * to be warned when any change append.
+     */
+    private CommandStackListener mCommandStackListener = new CommandStackListener() {
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void commandStackChanged(final EventObject pEvent) {
+            // Use an asynchronous UI thread, to call the 'handleCommandStackChanged' method
+            // to react to the commands execution
+            AbstractMultiPageEditor.this.getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public void run() {
+                    handleCommandStackChanged(((CommandStack) pEvent.getSource()).getMostRecentCommand());
+                }
+            });
+        }
+    };
+
+    /** This is the property sheet page provided by the editor. */
+    private PropertySheetPage mPropertySheetPage = null;
+
+    /** This is the tool bar displayed in the main page of the editor. */
+    private ToolBarManager mEditorToolBarManager = null;
+
+    /**
+     * This is the tree viewer displayed in the editor main page,
+     * to edit the resource content.
+     */
+    private TreeViewer mEditorTreeViewer = null;
+
+    /** This listens to the selection in the active viewer. */
+    private ISelectionChangedListener mSelectionChangedListener = null;
+
+    /** This keeps track of all the ISelectionChangedListener that are listening to this editor. */
+    private List<ISelectionChangedListener> mSelectionChangedListenersList = new ArrayList<ISelectionChangedListener>();
+
+    /** This keeps track of the selection of the editor as a whole. */
+    private ISelection mEditorSelection = StructuredSelection.EMPTY;
+
+    /**
+     * The MarkerHelper is responsible for creating workspace resource markers presented
+     * in Eclipse's Problems View.
+     */
+    private MarkerHelper mMarkerHelper = new EditUIMarkerHelper();
+
+    /**
+     * This listens to the parts activation to react when
+     * the properties view or this editor instance becomes active for example.
+     */
+    private IPartListener mPartListener = createPartListener();
+
+    /** Resources that have been removed since last activation. */
+    private List<Resource> mRemovedResourcesList = new ArrayList<Resource>();
+
+    /** Resources that have been changed since last activation from other editors or views. */
+    private List<Resource> mChangedResourcesList = new ArrayList<Resource>();
+
+    /** Resources that have been saved. */
+    private List<Resource> mSavedResourcesList = new ArrayList<Resource>();
+
+    /** Controls whether the problem indication should be updated or not. */
+    private boolean mUpdateProblemIndication = true;
+
+    /** Adapter used to analyse the resources when they are going to be loaded. */
+    private ProblemIndicationAdapter mProblemIndicationAdapter = new ProblemIndicationAdapter();
+
+    /**
+     * This listens for workspace changes to maintain the lists of changed or removed resources.
+     * This is mandatory to treat any edition conflict with other views or editors.
+     */
+    private IResourceChangeListener mWorkspaceChangeListener = new IResourceChangeListener() {
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void resourceChanged(final IResourceChangeEvent pEvent) {
+            // Get the delta identifying all the changes
+            IResourceDelta vDelta = pEvent.getDelta();
+
+            try {
+                // Build the visitor instance and launch it
+                final ResourceDeltaVisitor vVisitor = new ResourceDeltaVisitor(mEditingDomain.getResourceSet());
+                vDelta.accept(vVisitor);
+
+                // Check if any resources have been removed
+                if (!vVisitor.getRemovedResources().isEmpty()) {
+
+                    // Remove from the saved resources those which have been removed
+                    mSavedResourcesList.removeAll(vVisitor.getChangedResources());
+
+                    // Remember of the resources which have been removed
+                    mRemovedResourcesList.addAll(vVisitor.getRemovedResources());
+
+                    // Use an asynchronous UI thread to close the editor if the
+                    // resources used are deleted
+                    getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                        /**
+                         * {@inheritDoc}
+                         */
+                        @Override
+                        public void run() {
+                            if (!isDirty()) {
+                                getSite().getPage().closeEditor(AbstractMultiPageEditor.this, false);
+                            }
+                        }
+                    });
+                }
+
+                // Check if any resources have changed
+                if (!vVisitor.getChangedResources().isEmpty()) {
+
+                    // Loop on the changed resource found by the visitor to update the list
+                    // of resources managed by this editor
+                    for (Resource vResource : vVisitor.getChangedResources()) {
+
+                        // Check if the resource is considered as saved
+                        if (mSavedResourcesList.contains(vResource)) {
+                            // The resource is considered as saved by the editor, thus
+                            // the change found by the visitor is linked to the save action.
+                            // In other words, the resource is not changed from the editor point of view,
+                            // but it can now be removed from the saved resources list to prepare its next change
+                            mSavedResourcesList.remove(vResource);
+                        } else {
+                            // The resource is not considered as saved, the change
+                            // found by the visitor was a real change from an other editor
+                            // Thus add the resource in the corresponding list
+                            mChangedResourcesList.add(vResource);
+                        }
+                    }
+
+                    // Use an asynchronous UI thread to refresh the editor if the
+                    // resources used have changed
+                    getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                        /**
+                         * {@inheritDoc}
+                         */
+                        @Override
+                        public void run() {
+                            if (AbstractMultiPageEditor.this.equals(getSite().getPage().getActiveEditor())) {
+                                handleActivate();
+                            }
+                        }
+                    });
+                }
+
+            } catch (final CoreException pException) {
+                CommonUIActivator.logError("Error due to a resource change", //$NON-NLS-1$
+                    pException);
+            }
+        }
+    };
+
+    /**
+     * Default constructor.
+     */
+    public AbstractMultiPageEditor() {
+        // Call the parent constructor
+        super();
+
+        // Initialise the editing domain used by the editor
+        initializeEditingDomain();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void dispose() {
+        // Disable the problems indication update
+        mUpdateProblemIndication = false;
+
+        // Remove the listeners from the different services
+        // ... The workspace listener
+        ResourcesPlugin.getWorkspace().removeResourceChangeListener(mWorkspaceChangeListener);
+        // ... The parts listener
+        if (mPartListener != null) {
+            getSite().getPage().removePartListener(mPartListener);
+        }
+
+        // Dispose the adapter factory used in the editor
+        if (mAdapterFactory instanceof IDisposable) {
+            ((IDisposable) mAdapterFactory).dispose();
+        }
+
+        // Unregister the active editor from the action bar
+        if (this.equals(getActionBarContributor().getActiveEditor())) {
+            getActionBarContributor().setActiveEditor(null);
+        }
+
+        // Dispose the views provided by this editor
+        // ... The property sheet page
+        if (mPropertySheetPage != null) {
+            mPropertySheetPage.dispose();
+        }
+
+        super.dispose();
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This implementation sets the editor site to the given site, its
+     * input to the given input, and the site's selection provider this editor instance.
+     */
+    @Override
+    public void init(final IEditorSite pSite, final IEditorInput pEditorInput) {
+        // Set the editor site
+        setSite(pSite);
+
+        // Set the editor input and launch an notification for this update
+        setInputWithNotify(pEditorInput);
+
+        // Set the editor title, with the input name
+        setPartName(pEditorInput.getName());
+
+        // Set this instance as selection provider of the site
+        pSite.setSelectionProvider(this);
+
+        // If a part listener is created, register it
+        if (mPartListener != null) {
+            pSite.getPage().addPartListener(mPartListener);
+        }
+
+        // Register to listen to the problems indication
+        mProblemIndicationAdapter.addProblemIndicationListener(this);
+
+        // Finally, add a listener to the workspace resources
+        ResourcesPlugin.getWorkspace().addResourceChangeListener(
+            mWorkspaceChangeListener,
+            IResourceChangeEvent.POST_CHANGE);
+    }
+
+    /**
+     * This sets up the editing domain for the model editor.
+     */
+    protected void initializeEditingDomain() {
+        // Create the adapter factory
+        mAdapterFactory = createAdapterFactory();
+
+        // Create the command stack used to notify this editor as commands are executed
+        CommandStack vCommandStack = createCommandStack();
+
+        // Create the editing domain with the created command stack
+        mEditingDomain =
+            new AdapterFactoryEditingDomain(mAdapterFactory, vCommandStack, new HashMap<Resource, Boolean>());
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This is important for implementing the static methods of {@link AdapterFactoryEditingDomain} and for supporting
+     * {@link org.eclipse.emf.edit.ui.action.CommandAction}.
+     */
+    @Override
+    public EditingDomain getEditingDomain() {
+        return mEditingDomain;
+    }
+
+    /**
+     * Create and return an instance of {@link AdapterFactory} and initialise it with the adapter factories
+     * linked to the manipulated resources.
+     *
+     * @return The created {@link ComposedAdapterFactory}
+     */
+    protected abstract AdapterFactory createAdapterFactory();
+
+    /**
+     * Create and return a default command stack, which allow to react to its changes
+     * using the {@link AbstractMultiPageEditor#handleCommandStackChanged(Command)} method.
+     *
+     * @return The command stack created
+     */
+    protected CommandStack createCommandStack() {
+        // Create the command stack that will notify this editor as commands are executed
+        BasicCommandStack vCommandStack = new BasicCommandStack();
+
+        // Add a listener to set the most recent command's affected objects to be the selection of the viewer with focus
+        vCommandStack.addCommandStackListener(mCommandStackListener);
+
+        return vCommandStack;
+    }
+
+    /**
+     * This method is called when the command stack is changed, to allow the
+     * page to react. By default, this will simply select the objects
+     * affected by the command in the viewer, and refresh the provided property
+     * sheet page.
+     *
+     * @param pMostRecentCommand The most recent command
+     */
+    protected void handleCommandStackChanged(final Command pMostRecentCommand) {
+
+        // Change the editor state to dirty
+        firePropertyChange(IEditorPart.PROP_DIRTY);
+
+        if (pMostRecentCommand != null) {
+
+            // Refresh the tree content
+            // NB : As a same object can be displayed several times in the tree,
+            // the standard refresh which uses the first affected object instance
+            // is not sufficient. A full refresh is mandatory, for example to display
+            // correctly a new child on each object representation, and not only on the first one
+            if (mEditorTreeViewer != null) {
+                mEditorTreeViewer.refresh();
+            }
+
+            // Try to select the objects affected by the last command
+            setSelectionToViewer(pMostRecentCommand.getAffectedObjects());
+        }
+
+        // Refresh the property sheet page content with the new selection
+        if (mPropertySheetPage != null && !mPropertySheetPage.getControl().isDisposed()) {
+            mPropertySheetPage.refresh();
+        }
+    }
+
+    /**
+     * Handles activation of the editor or it's associated views, like the properties view.
+     */
+    protected void handleActivate() {
+
+        // Recompute the read only state of the resources
+        if (mEditingDomain.getResourceToReadOnlyMap() != null) {
+            mEditingDomain.getResourceToReadOnlyMap().clear();
+
+            // Refresh any actions that may become enabled or disabled
+            setSelection(getSelection());
+        }
+
+        if (!mRemovedResourcesList.isEmpty()) {
+            // If some resources have been removed since
+            // the last activation, ask the user if the changes
+            // must be discarded
+            if (handleDirtyConflict()) {
+                // The user has chosen to close the editor and discard the changes
+                getSite().getPage().closeEditor(AbstractMultiPageEditor.this, false);
+            } else {
+                // The user wants to keep the changes, so clear the changes collections
+                mRemovedResourcesList.clear();
+                mChangedResourcesList.clear();
+                mSavedResourcesList.clear();
+            }
+
+        } else if (!mChangedResourcesList.isEmpty()) {
+            // If some resources have been changed since
+            // the last activation, handle it
+
+            // ... First remove form the changes all what has been saved
+            mChangedResourcesList.removeAll(mSavedResourcesList);
+
+            // ... Then handle the changes
+            handleChangedResources();
+
+            // ... And finally clear the changes collections
+            mChangedResourcesList.clear();
+            mSavedResourcesList.clear();
+        }
+    }
+
+    /**
+     * Handles what to do with changed resources on activation.
+     */
+    protected void handleChangedResources() {
+        // Check if some changes have been identified since last activation
+        if (!mChangedResourcesList.isEmpty()) {
+
+            if (!isDirty() || handleDirtyConflict()) {
+                // If the editor is not dirty or if the user has chosen
+                // to discard the changes, the editor resources must be
+                // reloaded, and revalidated
+
+                if (isDirty()) {
+                    // If the editor is dirty, all the resources of the
+                    // current resources set are considered as changed
+                    mChangedResourcesList.addAll(mEditingDomain.getResourceSet().getResources());
+                }
+
+                // Dispose all the commands of the stack
+                mEditingDomain.getCommandStack().flush();
+
+                // Temporary disable the problems indication, while the
+                // diagnostics are updated
+                mUpdateProblemIndication = false;
+
+                // Loop on the resources considered as changed since the last activation
+                // to try to load them and ensure that they are valid
+                for (Resource vResource : mChangedResourcesList) {
+                    if (vResource.isLoaded()) {
+                        // If the resource is already loaded, unload it
+                        vResource.unload();
+
+                        try {
+                            // Then try to reload it
+                            vResource.load(Collections.EMPTY_MAP);
+                        } catch (final IOException pException) {
+                            // An exception as been thrown during the resource load,
+                            // remember of the resource problem
+                            mProblemIndicationAdapter.analyzeResource(vResource, pException);
+                        }
+                    }
+                }
+
+                // If the editor selection points to something which is unloaded,
+                // reset the selection
+                if (AdapterFactoryEditingDomain.isStale(mEditorSelection)) {
+                    setSelection(StructuredSelection.EMPTY);
+                }
+
+                // Finally, reactivate the problems indication
+                mUpdateProblemIndication = true;
+
+                // Finally, get the diagnostic from the problem indication adapter
+                // and update its content
+                updateProblemIndication(mProblemIndicationAdapter.getDiagnostic());
+            }
+        }
+    }
+
+    /**
+     * Shows a dialog that asks if conflicting changes should be discarded.
+     *
+     * @return <code>true</code> if the changes in the editor must be discarded
+     */
+    protected boolean handleDirtyConflict() {
+        return MessageDialog.openQuestion(
+            getSite().getShell(),
+            CommonUIActivator.getMessages().getString("AbstractMultiPageEditor.fileconflict.title"), //$NON-NLS-1$
+            CommonUIActivator.getMessages().getString("AbstractMultiPageEditor.fileconflict.message")); //$NON-NLS-1$
+    }
+
+    /**
+     * This sets the selection into whichever viewer is active.
+     * It can be the viewer in the editor or in one of its linked view.
+     *
+     * @param pSelectionCollection The collection of elements to select
+     */
+    protected void setSelectionToViewer(final Collection<?> pSelectionCollection) {
+
+        // Ensure that the collection to select is valid
+        if (pSelectionCollection != null && !pSelectionCollection.isEmpty()) {
+
+            // Use an asynchronous UI thread to update the selection
+            getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public void run() {
+                    // Try to select the items in the editor content viewer
+                    if (mEditorTreeViewer != null) {
+                        mEditorTreeViewer.setSelection(new StructuredSelection(pSelectionCollection.toArray()), true);
+                    }
+                }
+            });
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This returns the viewer used to edit the resource content,
+     * as required by the {@link IViewerProvider} interface.
+     *
+     * Moreover, it's overridden to return a {@link TreeViewer} instead of a {@link Viewer}.
+     *
+     */
+    @Override
+    public TreeViewer getViewer() {
+        return mEditorTreeViewer;
+    }
+
+    /**
+     * This creates a context menu for the viewer and adds a listener as well registering the menu for extension.
+     *
+     * @param pViewer The viewer for which the context menu will be created
+     */
+    protected void createContextMenuFor(final StructuredViewer pViewer) {
+        // Create the context menu manager
+        MenuManager vContextMenuManager = new MenuManager("#PopUp"); //$NON-NLS-1$
+
+        vContextMenuManager.add(new Separator("additions")); //$NON-NLS-1$
+        vContextMenuManager.setRemoveAllWhenShown(true);
+        vContextMenuManager.addMenuListener(this);
+
+        // Register the menu manager created as the viewer context menu
+        Menu vContextMenu = vContextMenuManager.createContextMenu(pViewer.getControl());
+        pViewer.getControl().setMenu(vContextMenu);
+        getSite().registerContextMenu(vContextMenuManager, new UnwrappingSelectionProvider(pViewer));
+    }
+
+    /**
+     * This creates the drag and drop support mechanisms for the given viewer.
+     *
+     * @param pViewer The viewer for which the drag and drop supports will be created
+     */
+    protected void createDragAndDropSupportFor(final StructuredViewer pViewer) {
+        // Get the drag and drop operations supported
+        int vDndOperations = getDragAndDropSupportedOperations();
+
+        Transfer[] vTransfersArray = new Transfer[] {LocalTransfer.getInstance()};
+
+        // Add the drag and drop support to the viewer
+        pViewer.addDragSupport(vDndOperations, vTransfersArray, new ViewerDragAdapter(pViewer));
+
+        pViewer.addDropSupport(vDndOperations, vTransfersArray, new EditingDomainViewerDropAdapter(
+            mEditingDomain,
+            pViewer));
+    }
+
+    /**
+     * Return an <code>int</code> corresponding to the operations
+     * supported by the drag and drop actions.
+     *
+     * By default, the drag and drop are allowed for a 'move' action only.
+     *
+     * @return The supported drag and drop operation flag
+     */
+    protected int getDragAndDropSupportedOperations() {
+        return DND.DROP_MOVE;
+    }
+
+    /**
+     * This is the method called to load the resource used as input
+     * from the editing domain's resource set.
+     *
+     * This will analyse the resource to find any problem.
+     */
+    protected void initializeInputResource() {
+        // Get the URI of the resource used as input for the editor
+        URI vResourceURI = EditUIUtil.getURI(getEditorInput());
+
+        Exception vException = null;
+        Resource vResource = null;
+
+        try {
+            // Try to load the resource through the editing domain
+            vResource = mEditingDomain.getResourceSet().getResource(vResourceURI, true);
+
+        } catch (final WrappedException pException) {
+            // An exception is thrown during the load, get the resource without loading it
+            vException = pException;
+            vResource = mEditingDomain.getResourceSet().getResource(vResourceURI, false);
+        }
+
+        // Analyse the resource and remember of the resulting diagnostic if there is any error
+        mProblemIndicationAdapter.analyzeResource(vResource, vException);
+
+        // Finally, register the problem indication adapter to the resource set adapter
+        // to listen to the events on the resources
+        mEditingDomain.getResourceSet().eAdapters().add(mProblemIndicationAdapter);
+    }
+
+    /**
+     * Find the initial input used in the viewer of this editor.
+     *
+     * @return The initial input found
+     */
+    protected abstract Object getInitialInput();
+
+    /**
+     * {@inheritDoc}
+     *
+     * This is the method used by the framework to install your own pages
+     * in the editor. This default implementation will create and add a main page,
+     * and prepare the editor to be able to display tabs if other pages are added.
+     */
+    @Override
+    public void createPages() {
+        // Creates the model from the editor input
+        initializeInputResource();
+
+        // Only creates the other pages if there is something that can be edited
+        if (!getEditingDomain().getResourceSet().getResources().isEmpty()) {
+
+            // Create the main page, used to edit the resource content
+            Composite vMainPage = createMainPage();
+
+            // Then add the new page to the editor and set its title
+            final int vPageIndex = addPage(vMainPage);
+            setPageText(vPageIndex, getMainPageTitle());
+
+            // Add optionally others pages
+            createOptionalPages();
+
+            // Use and asynchronous UI thread to activate the new page
+            getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public void run() {
+                    setActivePage(vPageIndex);
+                }
+            });
+
+        }
+
+        // Ensures that this editor will only display the page's tab
+        // area if there are more than one page
+        getContainer().addControlListener(new ControlAdapter() {
+
+            /** Flag used to prevent from untimely resized events. */
+            private boolean mGuard = false;
+
+            /**
+             * {@inheritDoc}
+             *
+             * Hide the tabs during the resizing.
+             */
+            @Override
+            public void controlResized(final ControlEvent pEvent) {
+                // Use a guard to prevent from untimely events as the
+                // tabs hiding will launch resized events
+                if (!mGuard) {
+                    mGuard = true;
+                    hideTabs();
+                    mGuard = false;
+                }
+            }
+        });
+
+        // Finally, get the diagnostic from the problem indication adapter
+        // and update its content
+        updateProblemIndication(mProblemIndicationAdapter.getDiagnostic());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setFocus() {
+        // Set the focus to the active page
+        getControl(getActivePage()).setFocus();
+    }
+
+    /**
+     * If there is just one page in the multi-page editor part,
+     * this hides the single tab at the bottom.
+     */
+    private void hideTabs() {
+        // Ensure that there is just one page
+        if (getPageCount() <= 1) {
+            // Reset the first page text
+            setPageText(0, StringUtils.EMPTY);
+
+            if (getContainer() instanceof CTabFolder) {
+                // Remove the tabs from the container
+                ((CTabFolder) getContainer()).setTabHeight(1);
+                Point vPoint = getContainer().getSize();
+                getContainer().setSize(vPoint.x, vPoint.y + 6);
+            }
+        }
+    }
+
+    /**
+     * If there is more than one page in the multi-page editor part,
+     * this shows the tabs at the bottom.
+     */
+    private void showTabs() {
+        // Ensure that there is more than one page
+        if (getPageCount() > 1) {
+            // Update the page text
+            setPageText(0, getMainPageTitle());
+
+            if (getContainer() instanceof CTabFolder) {
+                // Display the tabs in the container
+                ((CTabFolder) getContainer()).setTabHeight(SWT.DEFAULT);
+                Point vPoint = getContainer().getSize();
+                getContainer().setSize(vPoint.x, vPoint.y - 6);
+            }
+        }
+    }
+
+    /**
+     * Create optional pages. By default, nothing is done.
+     */
+    protected void createOptionalPages() {
+        // Nothing to do
+    }
+
+    /**
+     * Create a composite corresponding to the main page of the editor, containing a
+     * custom toolbar and a tree viewer used to edit the resource content.
+     *
+     * @return The main composite corresponding to the page created
+     */
+    protected Composite createMainPage() {
+        // Create the page main composite
+        Composite vMainComposite = new Composite(getContainer(), SWT.NONE);
+
+        // Set the main composite layout
+        GridLayout vMainLayout = new GridLayout();
+        vMainLayout.horizontalSpacing = 0;
+        vMainLayout.verticalSpacing = 0;
+        vMainLayout.marginHeight = 0;
+        vMainLayout.marginWidth = 0;
+        vMainComposite.setLayout(vMainLayout);
+        vMainComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+
+        // Create the editor toolbar
+        createMainToolbar(vMainComposite);
+
+        // Create and initialise the tree viewer
+        createMainTreeViewer(vMainComposite);
+
+        // Create the context menu for the viewer, once the selection is updated
+        createContextMenuFor(mEditorTreeViewer);
+
+        // Create the drag and drop support for the new viewer
+        createDragAndDropSupportFor(mEditorTreeViewer);
+
+        return vMainComposite;
+    }
+
+    /**
+     * Return the title for the main page created by the method {@link AbstractMultiPageEditor#createMainPage()}.
+     *
+     * @return The main page title
+     */
+    protected abstract String getMainPageTitle();
+
+    /**
+     * Create the tool bar for the main page, in the parent composite
+     * given. This will also create the tool bar manager used to add
+     * the actions in the toolbar.
+     *
+     * @param pParent The parent composite where the toolbar must be created
+     */
+    protected void createMainToolbar(final Composite pParent) {
+        // Create the toolbar at the top of the page main composite
+        // NB : Use the flat style, to allow the display of separator bars, and don't
+        //      set any layout to avoid UI bugs (see ToolBar javadoc)
+        ToolBar vEditorToolBar = new ToolBar(pParent, SWT.FLAT | SWT.RIGHT | SWT.HORIZONTAL);
+        vEditorToolBar.setLayoutData(new GridData(SWT.END, SWT.CENTER, true, false));
+
+        // Create the toolbar manager, linked to the tool bar
+        // It will be this manager which will be used to add actions in the toolbar
+        mEditorToolBarManager = new ToolBarManager(vEditorToolBar);
+    }
+
+    /**
+     * Create the tree viewer in the main page to edit the resource content.
+     * The tree viewer is created in the parent composite given.
+     *
+     * This will also create the selection change listener and attach it to the
+     * tree viewer created.
+     *
+     * Moreover, the tree viewer is directly initialised with the needed label and
+     * content provider, and with its input.
+     *
+     * @param pParent The parent composite where the toolbar must be created
+     */
+    protected void createMainTreeViewer(final Composite pParent) {
+        // Create a tree viewer, allowing multiple selection
+        mEditorTreeViewer = new TreeViewer(pParent, SWT.MULTI | SWT.BORDER | SWT.FULL_SELECTION);
+
+        mEditorTreeViewer.getTree().setLayout(new GridLayout());
+        mEditorTreeViewer.getTree().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+
+        mEditorTreeViewer.getTree().setLinesVisible(true);
+
+        // Add all the known filters to the tree viewer
+        for (AbstractFilter vFilter : getFilters()) {
+            mEditorTreeViewer.addFilter(vFilter);
+        }
+
+        // Create the selection changed listener on the new tree viewer
+        if (mSelectionChangedListener == null) {
+            mSelectionChangedListener = new ISelectionChangedListener() {
+
+                /**
+                 * {@inheritDoc}
+                 *
+                 * This just notifies those things that are affected by the section.
+                 */
+                @Override
+                public void selectionChanged(final SelectionChangedEvent pSelectionChangedEvent) {
+                    setSelection(pSelectionChangedEvent.getSelection());
+                }
+            };
+        }
+
+        // Start listening to the new tree viewer
+        mEditorTreeViewer.addSelectionChangedListener(mSelectionChangedListener);
+
+        // Create the required column for the tree viewer
+        // NB : This column will use the label provider which will be set the
+        // the tree viewer hereafter
+        int vFirstColumnSize = FIRST_COLUMN_DEFAULT_SIZE;
+        if (1 == getFinalColumnNumber()) {
+            // There will be only one column, take a maximum size
+            vFirstColumnSize = FIRST_COLUMN_DEFAULT_SIZE * 2;
+        }
+        createMainTreeViewerRequiredColumn(vFirstColumnSize);
+
+        // Set the behaviour of the tree viewer, to customise how the elements are displayed
+        // and what is the content of the tree
+        mEditorTreeViewer.setContentProvider(createContentProvider());
+        mEditorTreeViewer.setLabelProvider(createLabelProvider());
+
+        // Create the optional columns
+        // NB : These columns will use their own label provider,
+        // defined from the property that they will display
+        createMainTreeViewerOptionalColumns();
+
+        // Once all the columns are added, ensure that the header will be displayed
+        mEditorTreeViewer.getTree().setHeaderVisible(true);
+
+        // Set the viewer input
+        mEditorTreeViewer.setInput(getInitialInput());
+
+        // Then expand the first level if possible to don't display
+        // only the root element by default
+        mEditorTreeViewer.expandToLevel(2);
+    }
+
+    /**
+     * Create the first required column in the tree viewer of the main page.
+     * This column will use the tree viewer label provider.
+     *
+     * In the default implementation, the required column is used to display
+     * the value of the 'name' property, for all the elements.
+     *
+     * @param pInitialSize The initial width of column
+     */
+    protected void createMainTreeViewerRequiredColumn(final int pInitialSize) {
+        // Create the required column, to display the object name
+        createMainTreeViewerColumn(
+            CommonUIActivator.getMessages().getString("AbstractMultiPageEditor.requiredcolumn.header"), //$NON-NLS-1$
+            SWT.LEFT,
+            pInitialSize,
+            UMLPackage.Literals.NAMED_ELEMENT__NAME.getName());
+    }
+
+    /**
+     * Create the others columns in the tree viewer of the main page.
+     * Theses columns will use their own label provider.
+     *
+     * In the default implementation, no column is added.
+     */
+    protected void createMainTreeViewerOptionalColumns() {
+        // Nothing to do by default
+    }
+
+    /**
+     * Return the property source provider to associate to the viewer.
+     * If no property source provider is known, create a default one.
+     *
+     * @return Return the property source provider to associate to the viewer
+     */
+    protected IPropertySourceProvider getPropertySourceProvider() {
+        if (mPropertySourceProvider == null) {
+            mPropertySourceProvider = createPropertySourceProvider();
+        }
+        return mPropertySourceProvider;
+    }
+
+    /**
+     * Create and return a default property source provider based on the adapter factory.
+     *
+     * @return The created property source provider
+     */
+    protected IPropertySourceProvider createPropertySourceProvider() {
+        return new PropertySourceProvider(getAdapterFactory());
+    }
+
+    /**
+     * Create a new column in the tree viewer of the main page.
+     * This column will be initialised with the given name, width and alignment.
+     *
+     * Moreover, if a property Id is given, the column content and behaviour will
+     * be adapted to work on this property.
+     *
+     * @param pColumnName The name of the column
+     * @param pAlignment The column alignment
+     * @param pColumnWidth The column width
+     * @param pPropertyID The ID of the property that this column will display
+     * @return The column created
+     */
+    protected TreeViewerColumn createMainTreeViewerColumn(
+        final String pColumnName,
+        final int pAlignment,
+        final int pColumnWidth,
+        final String pPropertyID) {
+
+        PropertyColumnLabelProvider vLabelProvider = null;
+
+        if (pPropertyID != null) {
+            // Build the label provider, based on the property whose
+            // id is given in parameter
+            vLabelProvider = new PropertyColumnLabelProvider(getPropertySourceProvider(), pPropertyID);
+        }
+
+        // Finally, create the new column
+        // NB : Doesn't set an editing support : the main column is voluntary never editable
+        final TreeViewerColumn vTreeViewerColumn =
+            TreeViewerUtils.createViewerColumn(getViewer(), pColumnName, pAlignment, pColumnWidth, vLabelProvider);
+
+        return vTreeViewerColumn;
+    }
+
+    /**
+     * Create and return a label provider based on the adapter factory
+     * to be able to find the texts and images to display in the viewer.
+     *
+     * @return The created label provider
+     */
+    protected IBaseLabelProvider createLabelProvider() {
+        // Create a custom label provider which is able to
+        // manage the tree viewer with columns
+        IBaseLabelProvider vLabelProvider = new AdapterFactoryColumnLabelProvider(getAdapterFactory());
+
+        return vLabelProvider;
+    }
+
+    /**
+     * Create and return a default content provider.
+     * This will manage directly different kinds of input, like a resource, or
+     * an array, to display their content directly in the viewer.
+     *
+     * @return The created content provider
+     */
+    protected IContentProvider createContentProvider() {
+        return new ArrayInputPropertySourceProvider(getAdapterFactory());
+    }
+
+    /**
+     * Create a new part listener specific to the behaviour of this instance.
+     *
+     * The default implementation will react to the activation of this editor instance
+     * or to the activation of the property sheet page provided.
+     *
+     * @return The part listener created
+     */
+    protected IPartListener createPartListener() {
+        return new PartListenerAdapter() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void partActivated(final IWorkbenchPart pPart) {
+                // Check what is the part activated ...
+                if (pPart instanceof PropertySheet) {
+                    // ... The properties view is activated, check if the page
+                    // activated is the one provided by this editor
+                    if (((PropertySheet) pPart).getCurrentPage().equals(mPropertySheetPage)) {
+                        // Activate the actions linked to this editor instance
+                        getActionBarContributor().setActiveEditor(AbstractMultiPageEditor.this);
+
+                        // React to the associated page activation
+                        handleActivate();
+                    }
+
+                } else if (pPart.equals(AbstractMultiPageEditor.this)) {
+                    // ... The current editor instance is activated
+
+                    // Activate the actions linked to this editor instance
+                    getActionBarContributor().setActiveEditor(AbstractMultiPageEditor.this);
+
+                    // React to the editor instance activation
+                    handleActivate();
+                }
+            }
+        };
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This is how the framework determines which interfaces we implement.
+     */
+    @SuppressWarnings("rawtypes")
+    @Override
+    public Object getAdapter(final Class pKeyClass) {
+        Object vAdapter = null;
+
+        if (pKeyClass.equals(IPropertySheetPage.class)) {
+            // If the expecting result is a properties page, provide
+            // the page corresponding
+            vAdapter = getPropertySheetPage();
+
+        } else if (pKeyClass.equals(IGotoMarker.class)) {
+            // If the expecting result is a marker provider
+            // return the editor instance
+            vAdapter = this;
+
+        } else {
+            // For all the others cases, call the parent method to find an adapter
+            vAdapter = super.getAdapter(pKeyClass);
+        }
+
+        return vAdapter;
+    }
+
+    /**
+     * This accesses a cached version of the property sheet.
+     * If the page doesn't exist, it can be created.
+     *
+     * @return The property sheet page provided by the editor
+     */
+    protected IPropertySheetPage getPropertySheetPage() {
+        // Check if the page already exists
+        if (mPropertySheetPage == null) {
+
+            // Create a new property sheet page, which
+            // will use the editor editing domain
+            mPropertySheetPage = new ExtendedPropertySheetPage(mEditingDomain) {
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public void setSelectionToViewer(final List<?> pSelection) {
+                    // Set the selection to the editor viewer
+                    AbstractMultiPageEditor.this.setSelectionToViewer(pSelection);
+                    AbstractMultiPageEditor.this.setFocus();
+                }
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public void setActionBars(final IActionBars pActionBars) {
+                    // Call the parent method to prepare the standard actions
+                    super.setActionBars(pActionBars);
+
+                    // Add the global actions (undo, redo, etc.)
+                    getActionBarContributor().shareGlobalActions(this, pActionBars);
+                }
+            };
+
+            // Set the property source provider to the property sheet page,
+            // using the editor adapter factory
+            mPropertySheetPage.setPropertySourceProvider(new PropertySourceProvider(mAdapterFactory));
+        }
+
+        return mPropertySheetPage;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This simply tests the command stack to known if there is unsaved changes.
+     */
+    @Override
+    public boolean isDirty() {
+        return ((BasicCommandStack) mEditingDomain.getCommandStack()).isSaveNeeded();
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This simply saves the resources of the managed editing domain, which are not opened in read-only.
+     */
+    @Override
+    public void doSave(final IProgressMonitor pProgressMonitor) {
+        // Save only resources that have actually changed
+        final Map<Object, Object> vSaveOptions = new HashMap<Object, Object>();
+        vSaveOptions.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED, Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER);
+
+        // Do the work within an operation because this is a long running activity that modifies the workbench
+        WorkspaceModifyOperation vWorkspaceModifyOperation = new WorkspaceModifyOperation() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void execute(final IProgressMonitor pMonitor) {
+                // Loop on the resources to save them to the file system
+                boolean vIsFirstResource = true;
+                for (Resource vResource : mEditingDomain.getResourceSet().getResources()) {
+                    // Check if the resource is not in read only mode, and if the resource content
+                    // is not empty and is persisted. Moreover, the first resource not in read only
+                    // is always saved
+                    if (!mEditingDomain.isReadOnly(vResource)
+                        && (vIsFirstResource || !vResource.getContents().isEmpty() || isPersisted(vResource))) {
+
+                        try {
+                            // Get the time when the resource was previously saved or loaded
+                            long vTimeStamp = vResource.getTimeStamp();
+
+                            // Try to save the resource
+                            vResource.save(vSaveOptions);
+
+                            // Check if the resource time stamp changed, this means that the save
+                            // was really effective, and thus remember the resource in the
+                            // saved resources collection
+                            if (vResource.getTimeStamp() != vTimeStamp) {
+                                mSavedResourcesList.add(vResource);
+                            }
+
+                        } catch (final IOException pException) {
+                            // An error occurred during the save, analyse the resource and add the
+                            // result to the diagnostics map
+                            mProblemIndicationAdapter.analyzeResource(vResource, pException);
+                        }
+
+                        // Remember that a resource has been saved, the followings won't be the first one
+                        vIsFirstResource = false;
+                    }
+                }
+            }
+        };
+
+        // Temporary disable the problems update while the save will be performed
+        mUpdateProblemIndication = false;
+
+        // Run the save action, and show progress
+        try {
+            new ProgressMonitorDialog(getSite().getShell()).run(true, false, vWorkspaceModifyOperation);
+
+            // Refresh the dirty state once the save is done
+            ((BasicCommandStack) mEditingDomain.getCommandStack()).saveIsDone();
+            firePropertyChange(IEditorPart.PROP_DIRTY);
+
+        } catch (final InvocationTargetException pException) {
+            CommonUIActivator.logError("Error during the save of the resource", pException); //$NON-NLS-1$
+        } catch (final InterruptedException pException) {
+            CommonUIActivator.logError("Save of the resource interrupted", pException); //$NON-NLS-1$
+        }
+
+        // Re-enable the problems update and do it
+        mUpdateProblemIndication = true;
+
+        // Finally, get the diagnostic from the problem indication adapter
+        // and update its content
+        updateProblemIndication(mProblemIndicationAdapter.getDiagnostic());
+    }
+
+    /**
+     * 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.
+     *
+     * This means that if a file already exists at the resource URI location, the resource is considered as persisted.
+     *
+     * @param pResource The resource to check
+     * @return <code>true</code> if the resource is persisted, this means if a file exists at the resource URI location
+     */
+    private boolean isPersisted(final Resource pResource) {
+        boolean vIsPersisted = false;
+
+        InputStream vResourceStream = null;
+        try {
+            // Try to open a stream to the resource URI location
+            vResourceStream = mEditingDomain.getResourceSet().getURIConverter().createInputStream(pResource.getURI());
+            if (vResourceStream != null) {
+                // The stream can be opened, the resource is thus rightly persisted to a file
+                vIsPersisted = true;
+            }
+
+        } catch (final IOException pException) {
+            // A stream can't be opened to the resource URI location, just
+            // set the flag value but don't log anything
+            vIsPersisted = false;
+
+        } finally {
+            // Close the stream
+            if (vResourceStream != null) {
+                try {
+                    vResourceStream.close();
+                } catch (final IOException pException) {
+                    CommonUIActivator.logError("Error during the close of a stream", //$NON-NLS-1$
+                        pException);
+                }
+            }
+        }
+
+        return vIsPersisted;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This always returns false because it is not currently supported.
+     */
+    @Override
+    public boolean isSaveAsAllowed() {
+        return false;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Not implemented for this editor.
+     */
+    @Override
+    public void doSaveAs() {
+        // Not implemented
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void gotoMarker(final IMarker pMarker) {
+        // Get the objects pointed by the given marker
+        List<?> vTargetObjects = mMarkerHelper.getTargetObjects(mEditingDomain, pMarker);
+
+        if (!vTargetObjects.isEmpty()) {
+            // Update the selection to focus on the objects corresponding to the marker
+            setSelectionToViewer(vTargetObjects);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void addSelectionChangedListener(final ISelectionChangedListener pListener) {
+        mSelectionChangedListenersList.add(pListener);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void removeSelectionChangedListener(final ISelectionChangedListener pListener) {
+        mSelectionChangedListenersList.remove(pListener);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public ISelection getSelection() {
+        return mEditorSelection;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Calling this result will notify the listeners, and update the status line content.
+     */
+    @Override
+    public void setSelection(final ISelection pSelection) {
+        // Update the selection
+        mEditorSelection = pSelection;
+
+        // Warn all the registered listeners
+        for (ISelectionChangedListener vListener : mSelectionChangedListenersList) {
+            vListener.selectionChanged(new SelectionChangedEvent(this, pSelection));
+        }
+
+        // Update the status line content
+        updateStatusLineManager(pSelection);
+    }
+
+    /**
+     * Update the status line manager according to the selection given in parameter.
+     *
+     * @param pSelection The selection used to build the status line message
+     */
+    protected void updateStatusLineManager(final ISelection pSelection) {
+
+        // Find the status line manager from the action bar
+        IStatusLineManager vStatusLineManager = getActionBars().getStatusLineManager();
+
+        if (vStatusLineManager != null) {
+            String vMessage = StringUtils.EMPTY;
+
+            if (pSelection instanceof IStructuredSelection) {
+                // Cast the selection
+                IStructuredSelection vStructuredSelection = (IStructuredSelection) pSelection;
+                int vSelectionSize = vStructuredSelection.size();
+
+                // Adapt the status message according to the selection size
+                switch (vStructuredSelection.size()) {
+                    case 0:
+                        vMessage =
+                            CommonUIActivator.getMessages().getString(
+                                "AbstractMultiPageEditor.statusline.noobjectselected"); //$NON-NLS-1$
+                        break;
+
+                    case 1:
+                        // Get the text corresponding to the selected object
+                        String vText =
+                            new AdapterFactoryItemDelegator(mAdapterFactory).getText(vStructuredSelection
+                                .getFirstElement());
+
+                        vMessage =
+                            CommonUIActivator.getMessages().getString(
+                                "AbstractMultiPageEditor.statusline.singleobjectselected", //$NON-NLS-1$
+                                new Object[] {vText});
+                        break;
+
+                    default:
+                        vMessage =
+                            CommonUIActivator.getMessages().getString(
+                                "AbstractMultiPageEditor.statusline.multiobjectsselected", //$NON-NLS-1$
+                                new Object[] {vSelectionSize});
+                        break;
+                }
+            }
+
+            // Update the status line message
+            vStatusLineManager.setMessage(vMessage);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * This implementation will notify the action bar contributor that the menu is about to be shown.
+     */
+    @Override
+    public void menuAboutToShow(final IMenuManager pMenuManager) {
+        ((IMenuListener) getEditorSite().getActionBarContributor()).menuAboutToShow(pMenuManager);
+    }
+
+    /**
+     * @return The action bar contributor managed by this editor site.
+     */
+    protected EditingDomainActionBarContributor getActionBarContributor() {
+        return (EditingDomainActionBarContributor) getEditorSite().getActionBarContributor();
+    }
+
+    /**
+     * @return The action bar managed by the action bar contributor of this editor.
+     */
+    protected IActionBars getActionBars() {
+        return getActionBarContributor().getActionBars();
+    }
+
+    /**
+     * @return The adapter factory used in this editor.
+     */
+    protected AdapterFactory getAdapterFactory() {
+        return mAdapterFactory;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public ToolBarManager getToolBarManager() {
+        return mEditorToolBarManager;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Updates the problems indication with the information described in the specified diagnostic.
+     */
+    @Override
+    public void updateProblemIndication(final Diagnostic pDiagnostic) {
+        // Ensure that the problems indication can be updated
+        if (mUpdateProblemIndication) {
+
+            // Use and asynchronous UI thread to update the problems indication if needed
+            // This can create a second page for the problems
+            getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public void run() {
+
+                    // Get the last editor page index
+                    int vLastEditorPageIndex = getPageCount() - 1;
+
+                    // Check if the last editor page is a already 'Problems' page
+                    if (vLastEditorPageIndex >= 0 && getEditor(vLastEditorPageIndex) instanceof ProblemEditorPart) {
+                        // The problem page is ready, update its content with the root diagnostic,
+                        // and if it corresponds to an error, activate the problem page
+                        ((ProblemEditorPart) getEditor(vLastEditorPageIndex)).setDiagnostic(pDiagnostic);
+                        if (pDiagnostic.getSeverity() != Diagnostic.OK) {
+                            setActivePage(vLastEditorPageIndex);
+                        }
+
+                    } else if (pDiagnostic.getSeverity() != Diagnostic.OK) {
+                        // The problem page is not already created, so do it
+                        ProblemEditorPart vProblemEditorPart = new ProblemEditorPart();
+
+                        // Update the problem page content with the root diagnostic
+                        vProblemEditorPart.setDiagnostic(pDiagnostic);
+                        vProblemEditorPart.setMarkerHelper(mMarkerHelper);
+
+                        try {
+                            // Once that the problem page has been created, add it to the editor,
+                            // activate it and display the tabs to allow the user to navigate between
+                            // the different pages
+                            addPage(++vLastEditorPageIndex, vProblemEditorPart, getEditorInput());
+                            setPageText(vLastEditorPageIndex, vProblemEditorPart.getPartName());
+                            setActivePage(vLastEditorPageIndex);
+                            showTabs();
+
+                        } catch (final PartInitException pException) {
+                            CommonUIActivator.logError("Error during the problem page creation", //$NON-NLS-1$
+                                pException);
+                        }
+                    }
+
+                    // Finally, manage the markers
+                    if (mMarkerHelper.hasMarkers(mEditingDomain.getResourceSet())) {
+                        mMarkerHelper.deleteMarkers(mEditingDomain.getResourceSet());
+                        if (pDiagnostic.getSeverity() != Diagnostic.OK) {
+                            try {
+                                mMarkerHelper.createMarkers(pDiagnostic);
+                            } catch (final CoreException pException) {
+                                CommonUIActivator.logError("Error during the markers creation", //$NON-NLS-1$
+                                    pException);
+                            }
+                        }
+                    }
+
+                }
+            });
+        }
+    }
+
+    /**
+     * Return the filters that will be associated to the viewer during its creation.
+     * By default, this returns a table of filters containing a new {@link NamePropertyFilter} filter.
+     *
+     * @return The table of filters to associate to the viewer
+     */
+    protected AbstractFilter[] getFilters() {
+        return new AbstractFilter[] {new NamePropertyFilter()};
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * For a multi page editor, the filter is applied on the
+     * current viewer.
+     */
+    @Override
+    public void filterTextChanged(final String pNewFilterText) {
+        TreeViewer vViewer = getViewer();
+
+        if (vViewer != null) {
+            // Loop on the registered filters to apply the new text
+            for (final ViewerFilter vViewerFilter : vViewer.getFilters()) {
+                if (vViewerFilter instanceof AbstractFilter) {
+                    ((AbstractFilter) vViewerFilter).setFilter(pNewFilterText);
+                }
+            }
+
+            // Finally refresh the viewer content
+            refreshViewer();
+        }
+    }
+
+    /**
+     * Refresh the viewer.
+     */
+    protected void refreshViewer() {
+        // Use an asynchronous UI thread to refresh the viewer
+        getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void run() {
+                TreeViewer vViewer = getViewer();
+
+                // Ensure that the viewer is still available
+                if (vViewer != null && !vViewer.getControl().isDisposed()) {
+                    synchronized (vViewer) {
+                        vViewer.refresh();
+                    }
+                }
+            }
+        });
+    }
+
+    /**
+     * @return The final number of column, including the first one. This is used to calculate a correct size even for
+     * first column
+     */
+    protected int getFinalColumnNumber() {
+        return 1;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/ArchiveActionBarContributor.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/ArchiveActionBarContributor.java
new file mode 100644
index 0000000..082231a
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/ArchiveActionBarContributor.java
@@ -0,0 +1,164 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.editor;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.command.Command;
+import org.eclipse.emf.common.command.UnexecutableCommand;
+import org.eclipse.emf.edit.ui.action.CopyAction;
+import org.eclipse.emf.edit.ui.action.CutAction;
+import org.eclipse.emf.edit.ui.action.PasteAction;
+import org.eclipse.emf.edit.ui.action.RedoAction;
+import org.eclipse.emf.edit.ui.action.UndoAction;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.Separator;
+import org.polarsys.esf.core.common.ui.actions.ActionBarContributorUtils;
+
+/**
+ * This is the action bar contributor used to edit the archived files.
+ * 
+ * This contributor avoid any action which can modify the archive content.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class ArchiveActionBarContributor
+    extends EmptyActionBarContributor {
+
+    /**
+     * Default constructor.
+     */
+    public ArchiveActionBarContributor() {
+        // Call the parent constructor
+        super();
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * Overridden to hide all the edit actions like undo, redo, cut, copy, paste, etc.
+     */
+    @Override
+    public void menuAboutToShow(final IMenuManager pMenuManager) {
+        // Add the standard addition marker at the beginning if needed
+        if ((style & ADDITIONS_LAST_STYLE) == 0) {
+            pMenuManager.add(new Separator(ActionBarContributorUtils.ADDITIONS_SEPARATOR_ID));
+        }
+
+        // Add the standard edit marker but not all the related actions
+        pMenuManager.add(new Separator(ActionBarContributorUtils.EDIT_SEPARATOR_ID));
+
+        // Add the standard addition marker at the end if needed
+        if ((style & ADDITIONS_LAST_STYLE) != 0) {
+            pMenuManager.add(new Separator(ActionBarContributorUtils.ADDITIONS_SEPARATOR_ID));
+        }
+
+        // Add the standard additions-end marker
+        pMenuManager.add(new Separator(ActionBarContributorUtils.ADDITIONS_END_SEPARATOR_ID));
+
+        // Finally add all the global actions
+        addGlobalActions(pMenuManager);
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * Avoid the copy action.
+     */
+    @Override
+    protected CopyAction createCopyAction() {
+
+        CopyAction vAction = new CopyAction() {
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public Command createCommand(final Collection<?> pSelection) {
+                return UnexecutableCommand.INSTANCE;
+            }
+        };
+        
+        return vAction;
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * Avoid the paste action.
+     */
+    @Override
+    protected PasteAction createPasteAction() {
+        
+        PasteAction vAction = new PasteAction() {
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public Command createCommand(final Collection<?> pSelection) {
+                return UnexecutableCommand.INSTANCE;
+            }
+        };
+        
+        return vAction;
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * Avoid the cut action.
+     */
+    @Override
+    protected CutAction createCutAction() {
+        
+        CutAction vAction = new CutAction() {
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public Command createCommand(final Collection<?> pSelection) {
+                return UnexecutableCommand.INSTANCE;
+            }
+        };
+        
+        return vAction;
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * Avoid the undo action.
+     */
+    @Override
+    protected UndoAction createUndoAction() {
+        
+        // Create the action and disable it
+        UndoAction vAction = super.createUndoAction();
+        vAction.setEnabled(false);
+        
+        return vAction;
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * Avoid the redo action.
+     */
+    @Override
+    protected RedoAction createRedoAction() {
+        
+        // Create the action and disable it
+        RedoAction vAction = super.createRedoAction();
+        vAction.setEnabled(false);
+        
+        return vAction;
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/EmptyActionBarContributor.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/EmptyActionBarContributor.java
new file mode 100644
index 0000000..20de5ba
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/editor/EmptyActionBarContributor.java
@@ -0,0 +1,107 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.editor;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.command.Command;
+import org.eclipse.emf.common.command.UnexecutableCommand;
+import org.eclipse.emf.edit.ui.action.DeleteAction;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.Separator;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.ui.actions.ActionFactory;
+import org.polarsys.esf.core.common.ui.actions.ActionBarContributorUtils;
+
+/**
+ * This is the empty action bar contributor.
+ * It doesn't allow to add or delete elements from the input model.
+ * 
+ * It's primary used is for the propagation tree editor, and overridden
+ * for the archived file editors.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class EmptyActionBarContributor
+    extends AbstractActionBarContributor {
+
+    /**
+     * Default constructor.
+     */
+    public EmptyActionBarContributor() {
+        // Call the parent constructor
+        super();
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * Overridden to avoid the creation of new elements in the model.
+     * This implementation disable the creation of action in the context menu
+     * and in the editor tool bar.
+     */
+    @Override
+    protected void addCreateSelectChildActions(final ISelection pSelection) {
+        // Do nothing voluntary
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * Overridden to ensure there is no delete action possible.
+     */
+    @Override
+    protected DeleteAction createDeleteAction() {
+
+        DeleteAction vAction = new DeleteAction(removeAllReferencesOnDelete()) {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public Command createCommand(final Collection<?> pSelection) {
+                return UnexecutableCommand.INSTANCE;
+            }
+        };
+
+        vAction.setId(ActionFactory.DELETE.getId());
+
+        return vAction;
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * Overridden to hide all the edit actions like undo, redo, cut, copy, paste, etc.
+     */
+    @Override
+    public void menuAboutToShow(final IMenuManager pMenuManager) {
+        // Add the standard addition marker at the beginning if needed
+        if ((style & ADDITIONS_LAST_STYLE) == 0) {
+            pMenuManager.add(new Separator(ActionBarContributorUtils.ADDITIONS_SEPARATOR_ID));
+        }
+
+        // Add the standard edit marker but not all the related actions
+        pMenuManager.add(new Separator(ActionBarContributorUtils.EDIT_SEPARATOR_ID));
+
+        // Add the standard addition marker at the end if needed
+        if ((style & ADDITIONS_LAST_STYLE) != 0) {
+            pMenuManager.add(new Separator(ActionBarContributorUtils.ADDITIONS_SEPARATOR_ID));
+        }
+
+        // Add the standard additions-end marker
+        pMenuManager.add(new Separator(ActionBarContributorUtils.ADDITIONS_END_SEPARATOR_ID));
+
+        // Finally add all the global actions
+        addGlobalActions(pMenuManager);
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/fieldeditor/BooleanGroupFieldEditor.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/fieldeditor/BooleanGroupFieldEditor.java
new file mode 100644
index 0000000..58278d0
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/fieldeditor/BooleanGroupFieldEditor.java
@@ -0,0 +1,295 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.fieldeditor;
+
+import org.eclipse.jface.preference.FieldEditor;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Group;
+
+/**
+ * A field editor for an enumeration type preference.
+ * The choices are presented as a list of check buttons.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class BooleanGroupFieldEditor
+    extends FieldEditor {
+
+    /**
+     * List of check button entries of the form [label,key].
+     */
+    private String[][] mLabelsAndValues = null;
+
+    /**
+     * Number of columns into which to arrange the check buttons.
+     */
+    private int mNumColumns = 1;
+
+    /**
+     * Indent used for the first column of the check button matrix.
+     */
+    private int mIndent = HORIZONTAL_GAP;
+
+    /**
+     * The box of check buttons, or <code>null</code> if none
+     * (before creation and after disposal).
+     */
+    private Composite mCheckBox = null;
+
+    /**
+     * The check buttons, or <code>null</code> if none
+     * (before creation and after disposal).
+     */
+    private Button[] mBooleanButtons = null;
+
+    /**
+     * Whether to use a Group control.
+     */
+    private boolean mUseGroup = false;
+
+    /**
+     * Constructor with default presentation.
+     * 
+     * @param pLabelText the label text of the field editor
+     * @param pNumColumns the number of columns for the check button presentation
+     * @param pLabelAndValues list of check button [label, value] entries;
+     * the value is returned when the check button is selected
+     * @param pParent the parent of the field editor's control
+     */
+    public BooleanGroupFieldEditor(
+        final String pLabelText,
+        final int pNumColumns,
+        final String[][] pLabelAndValues,
+        final Composite pParent) {
+        this(pLabelText, pNumColumns, pLabelAndValues, pParent, false);
+    }
+
+    /**
+     * Constructor with choice to display group presentation.
+     * 
+     * @param pLabelText the label text of the group field editor
+     * @param pNumColumns the number of columns for the check button presentation
+     * @param pLabelAndValues list of check button [label, key]
+     * @param pParent the parent of the field editor's control
+     * @param pUseGroup whether to use a Group control to contain the check buttons
+     */
+    public BooleanGroupFieldEditor(
+        final String pLabelText,
+        final int pNumColumns,
+        final String[][] pLabelAndValues,
+        final Composite pParent,
+        final boolean pUseGroup) {
+        mLabelsAndValues = pLabelAndValues;
+        mNumColumns = pNumColumns;
+        mUseGroup = pUseGroup;
+        setLabelText(pLabelText);
+        createControl(pParent);
+    }
+
+    /**
+     * Returns this field editor's check group control.
+     * 
+     * @param pParent The parent to create the checkBox in
+     * @return the check group control
+     */
+    public Composite getCheckBoxControl(final Composite pParent) {
+        if (mCheckBox == null) {
+
+            Font vFont = pParent.getFont();
+
+            if (mUseGroup) {
+                Group vGroup = new Group(pParent, SWT.NONE);
+                vGroup.setFont(vFont);
+                String vText = getLabelText();
+                if (vText != null) {
+                    vGroup.setText(vText);
+                }
+
+                mCheckBox = vGroup;
+                GridLayout vLayout = new GridLayout();
+                vLayout.horizontalSpacing = HORIZONTAL_GAP;
+                vLayout.numColumns = mNumColumns;
+                mCheckBox.setLayout(vLayout);
+            } else {
+
+                mCheckBox = new Composite(pParent, SWT.NONE);
+                GridLayout vLayout = new GridLayout();
+                vLayout.marginWidth = 0;
+                vLayout.marginHeight = 0;
+                vLayout.horizontalSpacing = HORIZONTAL_GAP;
+                vLayout.numColumns = mNumColumns;
+                mCheckBox.setLayout(vLayout);
+                mCheckBox.setFont(vFont);
+            }
+
+            initialiseButtonsArray(pParent);
+
+        } else {
+            checkParent(mCheckBox, pParent);
+        }
+        return mCheckBox;
+    }
+
+    /**
+     * Initialise all button of group with associated label value.
+     * 
+     * @param pParent The parent to create CheckBoxes in
+     */
+    private void initialiseButtonsArray(final Composite pParent) {
+        mBooleanButtons = new Button[mLabelsAndValues.length];
+        Font vFont = pParent.getFont();
+        for (int i = 0; i < mLabelsAndValues.length; i++) {
+            Button vCheckButton = new Button(mCheckBox, SWT.CHECK | SWT.LEFT);
+            mBooleanButtons[i] = vCheckButton;
+            String[] vLabelAndValue = mLabelsAndValues[i];
+            vCheckButton.setText(vLabelAndValue[0]);
+            vCheckButton.setData(vLabelAndValue[1]);
+            vCheckButton.setFont(vFont);
+
+        }
+    }
+
+    /**
+     * 
+     * {@inheritDoc}
+     */
+    @Override
+    protected void adjustForNumColumns(final int pNumColumns) {
+        Control vControl = getLabelControl();
+        if (vControl != null) {
+            ((GridData) vControl.getLayoutData()).horizontalSpan = pNumColumns;
+        }
+        ((GridData) mCheckBox.getLayoutData()).horizontalSpan = pNumColumns;
+
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void doFillIntoGrid(final Composite pParent, final int pNumColumns) {
+
+        if (mUseGroup) {
+            Control vControl = getCheckBoxControl(pParent);
+            GridData vDataLayout = new GridData(GridData.FILL_HORIZONTAL);
+            vControl.setLayoutData(vDataLayout);
+        } else {
+
+            Control vControl = getLabelControl(pParent);
+            GridData vDataLayout = new GridData();
+            vDataLayout.horizontalSpan = pNumColumns;
+            vControl.setLayoutData(vDataLayout);
+            vControl = getCheckBoxControl(pParent);
+            vDataLayout = new GridData();
+            vDataLayout.horizontalSpan = pNumColumns;
+            vDataLayout.horizontalIndent = mIndent;
+            vControl.setLayoutData(vDataLayout);
+        }
+
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void doLoad() {
+        for (int vIndex = 0; vIndex < mLabelsAndValues.length; vIndex++) {
+            String[] vBoxValues = mLabelsAndValues[vIndex];
+            Button vCheckBox = mBooleanButtons[vIndex];
+            boolean vStoreValue = getPreferenceStore().getBoolean(vBoxValues[1]);
+            vCheckBox.setSelection(vStoreValue);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void doLoadDefault() {
+        for (int vIndex = 0; vIndex < mLabelsAndValues.length; vIndex++) {
+            String[] vBoxValues = mLabelsAndValues[vIndex];
+            Button vCheckBox = mBooleanButtons[vIndex];
+            boolean vStoreValue = getPreferenceStore().getDefaultBoolean(vBoxValues[1]);
+            vCheckBox.setSelection(vStoreValue);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void doStore() {
+
+        for (int vIndex = 0; vIndex < mBooleanButtons.length; vIndex++) {
+            Button vCheckbox = mBooleanButtons[vIndex];
+            String[] vBoxValues = mLabelsAndValues[vIndex];
+            getPreferenceStore().setValue(vBoxValues[1], vCheckbox.getSelection());
+        }
+
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * This is overridden to be able to manage the case of this group field editor,
+     * which hasn't only one preference name, but one by boolean field. Thus, the standard
+     * mechanism to restore the default value is not working. 
+     */
+    @Override
+    public void store() {
+        // Ensure that a valid preference store is known
+        if (getPreferenceStore() != null) {
+
+            // Check if the values must be restored to the default ones
+            if (presentsDefaultValue()) {
+                // Loop on all the boolean fields to restore each of them to their default value
+                for (int vIndex = 0; vIndex < mBooleanButtons.length; vIndex++) {
+                    String[] vBoxValues = mLabelsAndValues[vIndex];
+                    getPreferenceStore().setToDefault(vBoxValues[1]);
+                }
+                
+            } else {
+                // Otherwise, call the standard method to store the current values
+                doStore();
+            }
+        }
+    }
+
+    /**
+     * 
+     * {@inheritDoc}
+     */
+    @Override
+    public int getNumberOfControls() {
+        return 1;
+    }
+
+    /**
+     * Sets the indent used for the first column of the boolean button matrix.
+     * 
+     * @param pIndent the indent (in pixels)
+     */
+    public void setIndent(final int pIndent) {
+        if (pIndent < 0) {
+            mIndent = 0;
+        } else {
+            mIndent = pIndent;
+        }
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/AbstractFilter.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/AbstractFilter.java
new file mode 100644
index 0000000..a177213
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/AbstractFilter.java
@@ -0,0 +1,189 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.filter;
+
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.jface.viewers.ViewerFilter;
+
+/**
+ * Abstract filter used as parent for any viewer filter implementation,
+ * based on a regular expression pattern.
+ *
+ * The different implementations must implement the {@link AbstractFilter#getFilterPropertyValue(Object)}
+ * method, which is used to define on which property the filter must be applied.
+ * For example, the ToStringFilter will simply base the filter on the result of the toString
+ * method applied on the object.
+ *
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public abstract class AbstractFilter
+    extends ViewerFilter {
+
+    /** The 'slash' character. */
+    private static final String SLASH_CHAR = "\\"; //$NON-NLS-1$
+
+    /** The 'slash' regular expression. */
+    private static final String SLASH_CHAR_REGEX = "\\\\"; //$NON-NLS-1$
+
+    /** The 'dot' character. */
+    private static final String DOT_CHAR = "."; //$NON-NLS-1$
+
+    /** The 'dot' regular expression. */
+    private static final String DOT_CHAR_REGEX = "\\."; //$NON-NLS-1$
+
+    /** The 'any string' character. */
+    private static final String ANY_STRING = "*"; //$NON-NLS-1$
+
+    /** The 'any string' regular expression. */
+    private static final String ANY_STRING_REGEX = ".*"; //$NON-NLS-1$
+
+    /** The 'any' character. */
+    private static final String ANY_CHARACTER = "?"; //$NON-NLS-1$
+
+    /** The 'any character' regular expression. */
+    private static final String ANY_CHARACTER_REGEX = ".?"; //$NON-NLS-1$
+
+    /** The pattern used to do the filter. */
+    private Pattern mPattern = null;
+
+    /**
+     * Default constructor.
+     */
+    public AbstractFilter() {
+        super();
+    }
+
+    /**
+     * Setter for the filter. It takes a String in parameter
+     * and used it to build the filter pattern, using a regular expression.
+     *
+     * @param pFilterText The text used to build the filter pattern
+     */
+    public void setFilter(final String pFilterText) {
+        if (StringUtils.isEmpty(pFilterText)) {
+            // Reset the pattern is the text is empty
+            mPattern = null;
+
+        } else {
+            // Format the given filter text to build a pattern expression
+            String vFormatedFilterText = pFilterText;
+            vFormatedFilterText = vFormatedFilterText.replace(SLASH_CHAR, SLASH_CHAR_REGEX);
+            vFormatedFilterText = vFormatedFilterText.replace(DOT_CHAR, DOT_CHAR_REGEX);
+            vFormatedFilterText = vFormatedFilterText.replace(ANY_STRING, ANY_STRING_REGEX);
+            vFormatedFilterText = vFormatedFilterText.replace(ANY_CHARACTER, ANY_CHARACTER_REGEX);
+            vFormatedFilterText = ANY_STRING_REGEX + vFormatedFilterText + ANY_STRING_REGEX;
+
+            // Finally build the corresponding pattern
+            mPattern = Pattern.compile(vFormatedFilterText);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Return <code>true</code> if an element must be displayed. This means that the node or at
+     * least one of its children matches the filter.
+     *
+     * @param pViewer The viewer containing all the elements
+     * @param pParentElement The parent of the element to check
+     * @param pElement The element to check
+     * @return <code>true</code> if the element must be displayed
+     */
+    @Override
+    public boolean select(final Viewer pViewer, final Object pParentElement, final Object pElement) {
+
+        boolean vSelectElement = true;
+
+        // Ensure that the current pattern value is valid
+        if (mPattern != null) {
+
+            // Check if the current element matches the filter
+            vSelectElement = isMatchesWithFilter(pElement);
+
+            // If the current element is not selected by the filter,
+            // ensure that a valid viewer is known to check if one of
+            // its children is selected
+            if (!vSelectElement && pViewer instanceof TreeViewer) {
+                // Cast the viewer
+                final TreeViewer vTreeViewer = (TreeViewer) pViewer;
+
+                // Get the content provider of the viewer, and extract the children
+                // of the current element from it
+                final ITreeContentProvider vTreeContentProvider =
+                    (ITreeContentProvider) vTreeViewer.getContentProvider();
+                final Object[] vChildrenArray = vTreeContentProvider.getChildren(pElement);
+
+                if (vChildrenArray.length != 0) {
+                    // If there is any children, check if one of them is selected by the filter
+                    vSelectElement = isAnyChildrenMatchesWithFilter(pViewer, pElement, vChildrenArray);
+                }
+            }
+        }
+        return vSelectElement;
+    }
+
+    /**
+     * Return <code>true</code> if any children matches with the filter.
+     *
+     * @param pViewer The viewer containing all the elements
+     * @param pElement The element to check
+     * @param pChildrensArray The array of children to check
+     * @return <code>true</code> if any children matches with the filter
+     */
+    private boolean isAnyChildrenMatchesWithFilter(
+        final Viewer pViewer,
+        final Object pElement,
+        final Object[] pChildrensArray) {
+
+        boolean vFound = false;
+
+        // Loop on the children to check if any matches with the filter,
+        // or if any of its owned children matches
+        for (int i = 0; i < pChildrensArray.length && !vFound; i++) {
+            vFound = isMatchesWithFilter(pChildrensArray[i]) || select(pViewer, pElement, pChildrensArray[i]);
+        }
+
+        return vFound;
+    }
+
+    /**
+     * Return <code>true</code> if the element given in parameter
+     * matches with the filter.
+     *
+     * @param pElement The element to check
+     * @return <code>true</code> if the element matches with the filter
+     */
+    private boolean isMatchesWithFilter(final Object pElement) {
+        // Get the filter value
+        String vFilterValue = getFilterPropertyValue(pElement);
+
+        // Remove all the controls characters like the carriage return
+        String vFormatedFilterValue = vFilterValue;
+        // TODO : Reimplement StringFormater.removeControlChars(vFilterValue);
+
+        // Try to apply the filter pattern, to know if the value is matching
+        return mPattern.matcher(vFormatedFilterValue).matches();
+    }
+
+    /**
+     * Return the property value on which the filter must be applied.
+     *
+     * @param pElement The element used as source to get the property value
+     * @return Return the property value on which the filter must be applied
+     */
+    protected abstract String getFilterPropertyValue(final Object pElement);
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/FilterPartManager.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/FilterPartManager.java
new file mode 100644
index 0000000..26fb317
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/FilterPartManager.java
@@ -0,0 +1,219 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.filter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.ui.IPartListener;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.PlatformUI;
+import org.polarsys.esf.core.common.ui.adapter.PartListenerAdapter;
+
+/**
+ * Manager for the filter part mechanism.
+ * 
+ * This is a singleton, which will manage the list of available and active
+ * filter listeners.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public final class FilterPartManager {
+
+    /** Keep track of this singleton instance. */
+    public static final FilterPartManager INSTANCE = new FilterPartManager();
+
+    /** The default filter text. */
+    public static final String DEFAULT_FILTER_TEXT = StringUtils.EMPTY;
+
+    /** The list of all available parts that implement the interface {@link IFilterPartListener}. */
+    private List<IFilterPartListener> mAvailablePartListenersList = new ArrayList<IFilterPartListener>();
+
+    /** The list of all the parts which are currently listening the change of the text filter. */
+    private List<IFilterPartListener> mActivePartListenersList = new ArrayList<IFilterPartListener>();
+
+    /** The current text used to filter. */
+    private String mFilterText = DEFAULT_FILTER_TEXT;
+
+    /**
+     * Part listener used to react to the close and the opening of any
+     * part, to remember of all the available part listeners.
+     */
+    private final IPartListener mPartListener = new PartListenerAdapter() {
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void partClosed(final IWorkbenchPart pPart) {
+            if (pPart instanceof IFilterPartListener) {
+                // Remove the part from the current filter listener
+                mActivePartListenersList.remove(pPart);
+
+                // Remove the part from the available filter listener
+                FilterPartManager.this.removeAvailableFilterPartListener((IFilterPartListener) pPart);
+            }
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void partOpened(final IWorkbenchPart pPart) {
+            if (pPart instanceof IFilterPartListener) {
+                // Add the part to the available filter listener
+                FilterPartManager.this.addAvailableFilterPartListener((IFilterPartListener) pPart);
+            }
+        }
+
+    };
+
+    /**
+     * Private constructor, as it's a singleton.
+     */
+    private FilterPartManager() {
+        // Register the part listener to the active workbench
+        PlatformUI.getWorkbench().getActiveWorkbenchWindow().getPartService().addPartListener(mPartListener);
+    }
+    
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void finalize() throws Throwable {
+        // Unregister the part listener from the active workbench
+        if (mPartListener != null) {
+            IWorkbenchWindow vWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
+                
+            if (vWorkbenchWindow != null) {
+                vWorkbenchWindow.getPartService().removePartListener(mPartListener);
+            }
+        }
+        
+        // The call the parent method
+        super.finalize();
+    }
+
+    /**
+     * Add a listener as an available filter part listener.
+     * Has no effect if an identical listener is already registered.
+     * 
+     * @param pFiltrePartListener The filter part listener to add
+     */
+    private void addAvailableFilterPartListener(final IFilterPartListener pFiltrePartListener) {
+        mAvailablePartListenersList.add(pFiltrePartListener);
+    }
+
+    /**
+     * Remove the given filter part listener from the available listeners.
+     * Has no affect if an identical listener is not registered.
+     * 
+     * @param pFiltrePartListener The filter part listener to remove
+     */
+    private void removeAvailableFilterPartListener(final IFilterPartListener pFiltrePartListener) {
+        mAvailablePartListenersList.remove(pFiltrePartListener);
+    }
+
+    /**
+     * Add a listener for filter text changes, and apply directly
+     * the filter is any value is currently specified.
+     * 
+     * Has no effect if an identical listener is already registered.
+     * 
+     * @param pFiltrePartListener The filter part listener to register
+     */
+    public void addFilterPartListener(final IFilterPartListener pFiltrePartListener) {
+        // Add the given part in the active listeners list
+        mActivePartListenersList.add(pFiltrePartListener);
+
+        // Remove the given part from the available listeners list,
+        // as it is now an active listener
+        mAvailablePartListenersList.remove(pFiltrePartListener);
+
+        // If there is currently any filter value, notify the listener to apply the filter directly
+        if (!DEFAULT_FILTER_TEXT.equals(mFilterText)) {
+            pFiltrePartListener.filterTextChanged(mFilterText);
+        }
+    }
+
+    /**
+     * Remove the given listener from the active listeners and
+     * remember of it by adding it to the available listeners list.
+     * 
+     * Has no affect if an identical listener is not registered.
+     * 
+     * @param pFiltrePartListener The filter part listener to remove
+     */
+    public void removeFilterPartListener(final IFilterPartListener pFiltrePartListener) {
+        // Remove the listener from the active ones
+        mActivePartListenersList.remove(pFiltrePartListener);
+
+        // Remember of the listener by adding it to the available listeners list
+        mAvailablePartListenersList.add(pFiltrePartListener);
+
+        // If there is currently any filter value, notify the listener
+        // to reset its filter
+        if (!DEFAULT_FILTER_TEXT.equals(mFilterText)) {
+            // Notify the listener to reset its filter with the default value
+            pFiltrePartListener.filterTextChanged(DEFAULT_FILTER_TEXT);
+        }
+    }
+
+    /**
+     * @return The list of available part listeners
+     */
+    public List<IFilterPartListener> getAvailablePartListenersList() {
+        return mAvailablePartListenersList;
+    }
+
+    /**
+     * @return The list of active part listeners
+     */
+    public List<IFilterPartListener> getActivePartListenersList() {
+        return mActivePartListenersList;
+    }
+
+    /**
+     * Notify all the active listeners that the filter text has change
+     * to allow them to apply the new filter value.
+     */
+    private void fireFilterTextChanged() {
+        for (final IFilterPartListener vListener : mActivePartListenersList) {
+            vListener.filterTextChanged(mFilterText);
+        }
+    }
+
+    /**
+     * Update the filter text value and notify all the listeners
+     * that the filter has changed.
+     * 
+     * @param pFilterText The new filter text to apply
+     */
+    public void updateFilterText(final String pFilterText) {
+        // Update the filter value
+        mFilterText = pFilterText;
+
+        // Notify all the listeners
+        fireFilterTextChanged();
+    }
+
+    /**
+     * Reset the filter text value and notify all the listeners
+     * that the filter has been reseted.
+     */
+    public void resetFilterText() {
+        // Update the filter value with the default text
+        updateFilterText(DEFAULT_FILTER_TEXT);
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/IFilterPartListener.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/IFilterPartListener.java
new file mode 100644
index 0000000..98a4ddc
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/IFilterPartListener.java
@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.filter;
+
+import org.eclipse.ui.IWorkbenchPart;
+
+
+/**
+ * Interface for all the workbench parts which are listening to the changes on the filter text box.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public interface IFilterPartListener extends IWorkbenchPart {
+
+    /**
+     * Method called when the filter text changed.
+     * 
+     * @param pText The new filter text
+     */
+    void filterTextChanged(String pText);
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/NamePropertyFilter.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/NamePropertyFilter.java
new file mode 100644
index 0000000..bc24684
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/NamePropertyFilter.java
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.filter;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.uml2.uml.NamedElement;
+
+/**
+ * Custom implementation of filter, using the name property
+ * of the object on which is applied the filter.
+ *
+ * The object must implements {@link IAbstractNamedObject}, otherwise
+ * the parent {@link ToStringFilter} is applied.
+ *
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class NamePropertyFilter
+    extends ToStringFilter {
+
+    /**
+     * Default constructor.
+     */
+    public NamePropertyFilter() {
+        super();
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Return the result of the {@link #toString()} method applied
+     * on the element, to apply the filter on this value.
+     *
+     * @return The value of the {@link #toString()} method applied on the given element
+     */
+    @Override
+    protected String getFilterPropertyValue(final Object pElement) {
+        String vFilteredValue = StringUtils.EMPTY;
+
+        if (pElement instanceof NamedElement) {
+            // Get the name value to apply the filter
+            vFilteredValue = ((NamedElement) pElement).getName();
+        } else {
+            // Call the parent method to get the toString value to apply the filter
+            vFilteredValue = super.getFilterPropertyValue(pElement);
+        }
+
+        return vFilteredValue;
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/ToStringFilter.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/ToStringFilter.java
new file mode 100644
index 0000000..855ffa2
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/filter/ToStringFilter.java
@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.filter;
+
+/**
+ * Basic implementation of filter, using the toString method
+ * to get the object property on which is applied the filter.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class ToStringFilter
+    extends AbstractFilter {
+
+    /**
+     * Default constructor.
+     */
+    public ToStringFilter() {
+        super();
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * Return the result of the {@link #toString()} method applied
+     * on the element, to apply the filter on this value.
+     * 
+     * @return The value of the {@link #toString()} method applied on the given element
+     */
+    @Override
+    protected String getFilterPropertyValue(final Object pElement) {
+        return pElement.toString();
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/FocusViewJob.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/FocusViewJob.java
new file mode 100644
index 0000000..4cb1c19
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/FocusViewJob.java
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.job;
+
+import java.text.MessageFormat;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.progress.UIJob;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+
+/**
+ * UI Job which display and activate desired view.
+ * 
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class FocusViewJob
+    extends UIJob {
+
+    /** Message when it is impossible to activate desired view. */
+    private static final String ERROR_LOG_MESSAGE = "Impossible to activate view with ID {0}"; //$NON-NLS-1$
+
+    /** ID of view to show. */
+    private String mIdDisplayedView = null;
+
+    /**
+     * Default constructor.
+     * 
+     * @param pJobName Name of Job.
+     * @param pSelectedViewId ID of view to display.
+     */
+    public FocusViewJob(final String pJobName, final String pSelectedViewId) {
+        super(pJobName);
+        mIdDisplayedView = pSelectedViewId;
+    }
+
+    /**
+     * Default constructor with defined display.
+     * 
+     * @param pJobDisplay Display in which job is executed.
+     * @param pJobName Name for job.
+     * @param pSelectedViewId Id of view to display.
+     */
+    public FocusViewJob(final Display pJobDisplay, final String pJobName, final String pSelectedViewId) {
+        super(pJobDisplay, pJobName);
+        mIdDisplayedView = pSelectedViewId;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public IStatus runInUIThread(final IProgressMonitor pMonitor) {
+        // OK Status
+        IStatus vReturnStatus = Status.OK_STATUS;
+
+        try {
+            PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage()
+                .showView(mIdDisplayedView);
+        } catch (final PartInitException pException) {
+            vReturnStatus =
+                new Status(IStatus.ERROR, CommonUIActivator.getPlugin().getSymbolicName(), MessageFormat.format(
+                    ERROR_LOG_MESSAGE,
+                    mIdDisplayedView), pException);
+
+        }
+        return vReturnStatus;
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/RunnableLoadModel.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/RunnableLoadModel.java
new file mode 100644
index 0000000..677e561
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/RunnableLoadModel.java
@@ -0,0 +1,67 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.job;
+
+import java.lang.reflect.InvocationTargetException;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.jface.operation.IRunnableWithProgress;
+import org.eclipse.uml2.uml.Model;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+
+/**
+ *
+ * Show a progress while ESF file load.
+ *
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class RunnableLoadModel
+    implements IRunnableWithProgress {
+
+    /** Label of loading ESF file task. */
+    private static final String TASK_SA_LOADING = CommonUIActivator.getMessages()
+        .getString("RunnableLoadModel.task.sa"); //$NON-NLS-1$
+
+    /** Model file URI. */
+    private URI mModelUri = null;
+
+    /** Loaded model. */
+    private Model mModel = null;
+
+    /**
+     * Default constructor.
+     *
+     * @param pURI Model file path.
+     */
+    public RunnableLoadModel(final URI pURI) {
+        mModelUri = pURI;
+    }
+
+    /**
+     * @return Loaded model.
+     */
+    public Model getLoadingModel() {
+        return mModel;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void run(final IProgressMonitor pMonitor) throws InvocationTargetException, InterruptedException {
+        pMonitor.beginTask(TASK_SA_LOADING, IProgressMonitor.UNKNOWN);
+        // TODO : Load the model ...
+        // mModel = ResourceLoaderFactory.getInstance().getModelLoader().loadFromURI(mModelUri);
+        pMonitor.done();
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/ShowReportPerspectiveJob.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/ShowReportPerspectiveJob.java
new file mode 100644
index 0000000..f5efa7e
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/ShowReportPerspectiveJob.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.job;
+
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.WorkbenchException;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+
+/**
+ * Job used to offer to the user to open Report perspective.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 90 $
+ * 
+ */
+public class ShowReportPerspectiveJob
+    implements Runnable {
+
+    /** Message of dialog box. */
+    private static final String PERSPECTIVE_DIALOG_MSG =
+        CommonUIActivator.getMessages().getString("ShowReportPerspectiveJob.msg.dialogbox"); //$NON-NLS-1$
+
+    /** Title of dialog box. */
+    private static final String PERSPECTIVE_DIALOG_TITLE =
+        CommonUIActivator.getMessages().getString("ShowReportPerspectiveJob.title.dialogbox"); //$NON-NLS-1$
+
+    /** Id of reports perspective. */
+    private static final String ID_PERSPECTIVE_REPORTS = "org.polarsys.esf.core.ui.perspective.reports"; //$NON-NLS-1$
+
+    /**
+     * Default constructor.
+     */
+    public ShowReportPerspectiveJob() {
+    }
+
+    @Override
+    public void run() {
+        // Get current window
+        IWorkbenchWindow vCurrentWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
+
+        // Check if reports perspective is not the current one
+        if (!ID_PERSPECTIVE_REPORTS.equals(vCurrentWindow.getActivePage().getPerspective().getId())) {
+
+            // Ask to the user if he wants to change its perspective
+            boolean vReturnCode = MessageDialog.openQuestion(
+                vCurrentWindow.getShell(),
+                PERSPECTIVE_DIALOG_TITLE,
+                PERSPECTIVE_DIALOG_MSG);
+
+            if (vReturnCode) {
+                try {
+                    // Open the reports perspective
+                    PlatformUI.getWorkbench().showPerspective(
+                        ID_PERSPECTIVE_REPORTS,
+                        vCurrentWindow);
+
+                } catch (final WorkbenchException pException) {
+                    CommonUIActivator.logError(pException.getMessage(), pException);
+                }
+            }
+
+        }
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/StatusChangeAdapter.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/StatusChangeAdapter.java
new file mode 100644
index 0000000..5d5fec6
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/job/StatusChangeAdapter.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.job;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.jobs.IJobChangeEvent;
+import org.eclipse.core.runtime.jobs.JobChangeAdapter;
+import org.eclipse.ui.statushandlers.StatusManager;
+
+/**
+ * Listener adapter check returned status job to display OK status.
+ * Eclipse display automatically Error status.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class StatusChangeAdapter
+    extends JobChangeAdapter {
+
+    /**
+     * Default constructor.
+     */
+    public StatusChangeAdapter() {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void done(final IJobChangeEvent pEvent) {
+
+        // Get status from listened job
+        IStatus vStatusJob = pEvent.getResult();
+
+        // Check if status must be display
+        if (vStatusJob.isOK()) {
+            StatusManager.getManager().handle(vStatusJob);
+        }
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/AdapterFactoryColumnLabelProvider.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/AdapterFactoryColumnLabelProvider.java
new file mode 100644
index 0000000..c309950
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/AdapterFactoryColumnLabelProvider.java
@@ -0,0 +1,59 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.provider;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
+import org.eclipse.swt.graphics.Image;
+
+/**
+ * Overridden because first column (index 0) must used getText and not getColumnText on label provider, 
+ * which return null.
+ * 
+ * It is because ItemProviderAdapter (Supertype of all item provider of model) implementation of getColumnText
+ * return <code>null</code>.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class AdapterFactoryColumnLabelProvider
+    extends AdapterFactoryLabelProvider {
+
+    /**
+     * Default constructor.
+     * 
+     * @param pAdapterFactory Factory able to create label provider for model.
+     */
+    public AdapterFactoryColumnLabelProvider(final AdapterFactory pAdapterFactory) {
+        super(pAdapterFactory);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public String getColumnText(final Object pObject, final int pColumnIndex) {
+        String vText = super.getText(pObject);
+
+        return vText;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Image getColumnImage(final Object pObject, final int pColumnIndex) {
+        Image vImage = super.getImage(pObject);
+
+        return vImage;
+    }
+    
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/FileLabelProvider.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/FileLabelProvider.java
new file mode 100644
index 0000000..5397d13
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/FileLabelProvider.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.provider;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jface.viewers.ILabelProvider;
+import org.eclipse.jface.viewers.LabelProvider;
+
+/**
+ * Label provider for display name file in combo box.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class FileLabelProvider
+    extends LabelProvider
+    implements ILabelProvider {
+
+    /**
+     * Default constructor.
+     */
+    public FileLabelProvider() {
+        super();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public String getText(final Object pElement) {
+        String vDiplayedText = StringUtils.EMPTY;
+
+        // If element is an file, return file name
+        if (pElement instanceof IFile) {
+            IFile vFile = (IFile) pElement;
+
+            vDiplayedText = vFile.getProjectRelativePath().toOSString();
+
+        }
+
+        return vDiplayedText;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/FirstColumnLabelProvider.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/FirstColumnLabelProvider.java
new file mode 100644
index 0000000..acb385a
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/FirstColumnLabelProvider.java
@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.provider;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
+import org.eclipse.swt.graphics.Image;
+
+/**
+ * Overridden because first column (index 0) must used getText and not getColumnText on label provider, which return
+ * null.
+ * 
+ * It is because ItemProviderAdapter (Supertype of all item provider of model) implementation of getColumnText
+ * return null.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class FirstColumnLabelProvider
+    extends AdapterFactoryLabelProvider {
+
+    /**
+     * Default constructor.
+     * 
+     * @param pAdapterFactory Factory able to create label provider for model.
+     */
+    public FirstColumnLabelProvider(final AdapterFactory pAdapterFactory) {
+        super(pAdapterFactory);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public String getColumnText(final Object pObject, final int pColumnIndex) {
+        String vText = StringUtils.EMPTY;
+
+        vText = super.getText(pObject);
+
+        return vText;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Image getColumnImage(final Object pObject, final int pColumnIndex) {
+        Image vImage = null;
+
+        vImage = super.getImage(pObject);
+
+        return vImage;
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/IToolBarManagerProvider.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/IToolBarManagerProvider.java
new file mode 100644
index 0000000..2562577
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/IToolBarManagerProvider.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.provider;
+
+import org.eclipse.jface.action.ToolBarManager;
+
+/**
+ * An interface for all the editors which want to provide their own tool bar manager.
+ * This allows for external classes (like the actions contributors) to access to the
+ * toolbar manager getter even if they don't know their concrete implementation.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public interface IToolBarManagerProvider {
+    
+    /**
+     * Return the tool bar manager provided by the concrete instance.
+     * @return The tool bar manager provided
+     */
+    ToolBarManager getToolBarManager();
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/WorkspaceContentProvider.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/WorkspaceContentProvider.java
new file mode 100644
index 0000000..51c9005
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/provider/WorkspaceContentProvider.java
@@ -0,0 +1,215 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.provider;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceVisitor;
+import org.eclipse.core.resources.IWorkspace;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+import org.eclipse.jface.viewers.Viewer;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+
+/**
+ *
+ * Workspace content provider for Import Wizard.
+ *
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class WorkspaceContentProvider
+    implements ITreeContentProvider {
+
+    /**
+     * Creates a new ContainerContentProvider.
+     */
+    public WorkspaceContentProvider() {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void dispose() {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Object[] getChildren(final Object pElement) {
+
+        // Default result
+        Object[] vChildren = new Object[0];
+
+        if (pElement instanceof IWorkspace) {
+
+            IWorkspace vWorkspace = (IWorkspace) pElement;
+
+            // Visit workspace
+            WorkspaceVisitor vWorkspaceVisitor = new WorkspaceVisitor();
+            try {
+                vWorkspace.getRoot().accept(vWorkspaceVisitor, 1, false);
+            } catch (final CoreException pException) {
+                CommonUIActivator.logError("Fail to visit workspace", //$NON-NLS-1$
+                    pException);
+            }
+
+            IProject[] vAllProjects = vWorkspaceVisitor.getSAProjects();
+
+            vChildren = vAllProjects;
+
+        }
+
+        return vChildren;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Object[] getElements(final Object pElement) {
+        return getChildren(pElement);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Object getParent(final Object pElement) {
+        return null;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean hasChildren(final Object pElement) {
+        return getChildren(pElement).length > 0;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void inputChanged(final Viewer pViewer, final Object pOldInput, final Object pNewInput) {
+    }
+
+    /**
+     *
+     * Implemented Resource Visitor which return all project containing ESF file.
+     *
+     *
+     * @author $Author: jdumont $
+     * @version $Revision: 83 $
+     */
+    private class WorkspaceVisitor
+        implements IResourceVisitor {
+
+        /** ESF Projects list to fill. */
+        private List<IProject> mSAProjects = new ArrayList<IProject>();
+
+        /**
+         * Default constructor.
+         */
+        public WorkspaceVisitor() {
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public boolean visit(final IResource pResource) throws CoreException {
+
+            // Check Project resource
+            if (pResource instanceof IProject) {
+                IProject vProject = (IProject) pResource;
+
+                // It is not possible to visit closed project.
+                if (vProject.isAccessible()) {
+
+                    // Visit project to determine if it is ESF project
+                    ProjectVisitor vVisitor = new ProjectVisitor();
+                    vProject.accept(vVisitor);
+
+                    if (vVisitor.isSAProject()) {
+                        mSAProjects.add(vProject);
+                    }
+                }
+            }
+
+            // Need to explore all project
+            return true;
+        }
+
+        /**
+         * @return All ESF Project in workspace.
+         */
+        public IProject[] getSAProjects() {
+            return mSAProjects.toArray(new IProject[mSAProjects.size()]);
+        }
+
+    }
+
+    /**
+     * Implement resource visitor to explore Project and detect a file ESF.
+     *
+     * @author $Author: jdumont $
+     * @version $Revision: 83 $
+     */
+    private class ProjectVisitor
+        implements IResourceVisitor {
+
+        /** If Project contain ESF file. */
+        private boolean mContainSAFile = false;
+
+        /**
+         * Default constructor.
+         */
+        public ProjectVisitor() {
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public boolean visit(final IResource pResource) throws CoreException {
+            boolean vContinueVisit = !mContainSAFile;
+
+            // Check other file only while a sa file is not found.
+            // Visitor explore all neighbours before stop itself.
+            if (vContinueVisit && pResource instanceof IFile) {
+                IFile vFile = (IFile) pResource;
+                // Check if extension file is sa
+                // TODO : Check the right extension ...
+                mContainSAFile = "uml".equals(vFile.getFileExtension());
+
+                vContinueVisit = !mContainSAFile;
+            }
+
+            // if ESF file found, visit is stopped
+            return vContinueVisit;
+        }
+
+        /**
+         * @return if project contain a ESF file.
+         */
+        public boolean isSAProject() {
+            return mContainSAFile;
+        }
+
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/selection/ISelectionHelper.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/selection/ISelectionHelper.java
new file mode 100644
index 0000000..81e8f0f
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/selection/ISelectionHelper.java
@@ -0,0 +1,62 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.selection;
+
+import java.util.List;
+
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+
+/**
+ * 
+ * Used to get a set of file, for an event or a projet.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public interface ISelectionHelper {
+
+    /**
+     * @param pExtensionFilters Extension filters for selection
+     */
+    void setExtensionFilters(String[] pExtensionFilters);
+
+    /**
+     * @return The extension filters
+     */
+    String[] getExtensionFilters();
+
+    /**
+     * Initialise helper with event.
+     * 
+     * @param pEvent Execution event from where files are found
+     */
+    void initFromSelection(ExecutionEvent pEvent);
+
+    /**
+     * @return All files from root project selection according to extension filter
+     */
+    List<IFile> getFilteredFiles();
+
+    /**
+     * Get the files under selection.
+     * 
+     * @return Files under selection, otherwise an empty array
+     */
+    IFile[] getSelectedFiles();
+
+    /**
+     * @return The project selected based on current file selection.
+     */
+    IProject getSelectedProject();
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/selection/SelectAndRevealResourceJob.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/selection/SelectAndRevealResourceJob.java
new file mode 100644
index 0000000..ccb39fc
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/selection/SelectAndRevealResourceJob.java
@@ -0,0 +1,84 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.selection;
+
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.ui.IPageLayout;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.part.ISetSelectionTarget;
+import org.eclipse.ui.progress.UIJob;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+
+/**
+ * Job to select a resource in project explorer and reveal it.
+ * The resource content is also refreshed.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ * 
+ */
+public class SelectAndRevealResourceJob
+    extends UIJob {
+
+    /** Title for the job. */
+    private static final String JOB_TITLE =
+        CommonUIActivator.getMessages().getString("SelectAndRevealResourceJob.title"); //$NON-NLS-1$
+
+    /** Resource to select and reveal. */
+    private IResource mResource = null;
+
+    /**
+     * Default constructor.
+     * 
+     * @param pResource Resource to select and reveal
+     */
+    public SelectAndRevealResourceJob(final IResource pResource) {
+        super(JOB_TITLE);
+        mResource = pResource;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public IStatus runInUIThread(final IProgressMonitor pMonitor) {
+        if (mResource != null) {
+            try {
+                // Refresh the resource content
+                mResource.refreshLocal(IResource.DEPTH_INFINITE, pMonitor);
+            } catch (final CoreException pException) {
+                CommonUIActivator.logError("Resource refresh failed", pException); //$NON-NLS-1$
+            }
+
+            // Get Project Explorer view
+            IWorkbench vWorkbench = PlatformUI.getWorkbench();
+            IWorkbenchPage vActivePage = vWorkbench.getActiveWorkbenchWindow().getActivePage();
+            IWorkbenchPart vActivePart = vActivePage.findView(IPageLayout.ID_PROJECT_EXPLORER);
+
+            // Select and reveal the new resource in Project Explorer
+            if (vActivePart instanceof ISetSelectionTarget) {
+                ISelection vTargetSelection = new StructuredSelection(mResource);
+                ((ISetSelectionTarget) vActivePart).selectReveal(vTargetSelection);
+            }
+        }
+        return Status.OK_STATUS;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/selection/SelectionHelper.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/selection/SelectionHelper.java
new file mode 100644
index 0000000..7c715a0
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/selection/SelectionHelper.java
@@ -0,0 +1,231 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.selection;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.ITreeSelection;
+import org.eclipse.jface.viewers.TreePath;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.handlers.HandlerUtil;
+import org.polarsys.esf.core.common.project.ProjectFinder;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+
+/**
+ * Helper to define models on which action will be executed. Models are found in function of Active part
+ * selection.
+ *
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class SelectionHelper
+    implements ISelectionHelper {
+
+    /** Message when project visit failed. */
+    private static final String ERROR_PROJECT_VISIT_MESSAGE = "Impossible to visit current project"; //$NON-NLS-1$
+
+    /** File filters extension. */
+    private String[] mExtensionFilters = null;
+
+    /** List of filtered files in root project of selection. */
+    private List<IFile> mModelFiles = null;
+
+    /** Selected files. */
+    private IFile[] mSelectedFiles = new IFile[] {};
+
+    /** Current project. */
+    private IProject mCurrentProject = null;
+
+    /**
+     * Default constructor.
+     */
+    public SelectionHelper() {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void initFromSelection(final ExecutionEvent pEvent) {
+        // Protect against null parameter
+        if (pEvent != null) {
+            mModelFiles = new ArrayList<IFile>();
+            // Get active part
+            IWorkbenchWindow vActivePart = HandlerUtil.getActiveWorkbenchWindow(pEvent);
+
+            if (vActivePart != null) {
+                // Get selection
+                ISelection vCurrentSelection = getCurrentSelection(vActivePart);
+
+                // Ensure that the selection is a tree selection, to be able to
+                // work with the path of the selected object
+                if (vCurrentSelection instanceof ITreeSelection) {
+
+                    // Get the current project from the selection
+                    IProject vCurrentProject = getCurrentProject((ITreeSelection) vCurrentSelection);
+
+                    // Get all the ESF files included in the project
+                    mModelFiles.addAll(getFilesFromProject(vCurrentProject));
+
+                    // Check if ESF file is selected
+                    initCurrentSelectedFile(vCurrentSelection);
+                }
+            }
+        }
+    }
+
+    /**
+     * Check current selection to determine if user selected a file matching the extension. If yes, this selection
+     * is saved.
+     *
+     * @param pSelection Selection to check.
+     */
+    private void initCurrentSelectedFile(final ISelection pSelection) {
+        IStructuredSelection vSelection = (IStructuredSelection) pSelection;
+        List<String> vFiltersList = Arrays.asList(mExtensionFilters);
+
+        List<IFile> vSelectedFiles = new ArrayList<>();
+
+        for (Object vElementUnderSelection : vSelection.toArray()) {
+            if (vElementUnderSelection instanceof IFile
+                && (vFiltersList.contains(((IFile) vElementUnderSelection).getFileExtension()) || vFiltersList
+                    .isEmpty())) {
+                vSelectedFiles.add((IFile) vElementUnderSelection);
+            }
+        }
+
+        mSelectedFiles = vSelectedFiles.toArray(mSelectedFiles);
+    }
+
+    /**
+     * Get current selection from active part.
+     *
+     * @param pActivePart Part from which get current selection.
+     * @return Current selection.
+     */
+    private ISelection getCurrentSelection(final IWorkbenchWindow pActivePart) {
+        return pActivePart.getSelectionService().getSelection();
+    }
+
+    /**
+     * Get the current project from the given selection.
+     *
+     * @param pTreeSelection Selection from where the project is searched. Must not be <code>null</code>
+     * @return Current project in which selection is made, otherwise <code>null</code>
+     */
+    private IProject getCurrentProject(final ITreeSelection pTreeSelection) {
+        mCurrentProject = null;
+
+        // Get the paths of the selected objects
+        TreePath[] vPathsArray = pTreeSelection.getPaths();
+
+        // Ensure that at least one path has been found
+        // NB : It means that at least one object is selected
+        if (vPathsArray.length > 0) {
+            // Get the path of the first selected object
+            TreePath vSelectedPath = vPathsArray[0];
+
+            int vIndex = 0;
+            Object vCurrentObject = null;
+
+            // Loop on the selected object of this tree selection until a project is found
+            // NB : In most of the case it's directly the root, but the user can show working sets
+            //      as root elements, etc.
+            while (mCurrentProject == null && vIndex < vSelectedPath.getSegmentCount()) {
+                // Get the current object
+                vCurrentObject = vSelectedPath.getSegment(vIndex);
+
+                // Check if this is a resource (project or file) and get its project
+                if (vCurrentObject instanceof IResource) {
+                    // Remember of the project, this will stop the loop
+                    mCurrentProject = ((IResource) vCurrentObject).getProject();
+                }
+
+                vIndex++;
+            }
+        }
+
+        return mCurrentProject;
+    }
+
+    /**
+     * Get all files according to extension filter into project.
+     *
+     * @param pProject Project which is explored
+     * @return List of found files.
+     */
+    private List<IFile> getFilesFromProject(final IProject pProject) {
+        List<IFile> vProjectSAFiles = new ArrayList<IFile>();
+
+        // Protect against null parameter and closed project
+        if (pProject != null && pProject.isAccessible()) {
+            ProjectFinder vFinder = new ProjectFinder(pProject);
+
+            try {
+                vProjectSAFiles.addAll(vFinder.findAllFiles(mExtensionFilters));
+            } catch (final CoreException pException) {
+                CommonUIActivator.logError(ERROR_PROJECT_VISIT_MESSAGE, pException);
+            }
+        }
+
+        return vProjectSAFiles;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public List<IFile> getFilteredFiles() {
+        return mModelFiles;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public IFile[] getSelectedFiles() {
+        return mSelectedFiles;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setExtensionFilters(final String[] pExtensionFilter) {
+        mExtensionFilters = pExtensionFilter;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public String[] getExtensionFilters() {
+        return mExtensionFilters;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public IProject getSelectedProject() {
+        return mCurrentProject;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/statusline/StatusLinesUtil.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/statusline/StatusLinesUtil.java
new file mode 100644
index 0000000..d45db05
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/statusline/StatusLinesUtil.java
@@ -0,0 +1,199 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.statusline;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.jface.action.IStatusLineManager;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.ui.IEditorActionBarContributor;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IViewPart;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.part.EditorActionBarContributor;
+import org.polarsys.esf.core.common.ui.constants.ImageConstants;
+
+/**
+ * Utility class used to work with the status lines.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public final class StatusLinesUtil {
+
+    /**
+     * Private constructor, as it's a utility class.
+     */
+    private StatusLinesUtil() {
+    }
+
+    /**
+     * Clear the message in the active status line.
+     */
+    public static void clearMessage() {
+        // Get the active part if possible
+        IWorkbenchPart vWorkbenchPart = 
+            PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
+        
+        if (vWorkbenchPart != null) {
+            // Clear the message
+            outputMessage(vWorkbenchPart, null, IStatus.OK);
+        }
+    }
+    
+    /**
+     * Clear the message in the status line of the given part.
+     * @param pPart The part from which the status line is found
+     */
+    public static void clearMessage(final IWorkbenchPart pPart) {
+        // Clear the message
+        outputMessage(pPart, null, IStatus.OK);
+    }
+    
+    /**
+     * Outputs a message to the active part's status line. Does nothing if the
+     * status line manager cannot be determined from the part.
+     * The message severity is given in parameter, based on the constants
+     * from {@link IStatus}.
+     * <p>
+     * Can be invoked from a non-UI thread.
+     * 
+     * @param pMessage The message to display
+     * @param pSeverity The severity of the message (ie : IStatus.OK, etc.)
+     */
+    public static void outputMessage(final String pMessage, final int pSeverity) {
+        // Get the active part if possible
+        IWorkbenchPart vWorkbenchPart = 
+            PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
+        
+        if (vWorkbenchPart != null) {
+            // Display the message
+            outputMessage(vWorkbenchPart, pMessage, pSeverity);
+        }
+    }
+    
+    /**
+     * Outputs a message to the part's status line. Does nothing if the
+     * status line manager cannot be determined from the part.
+     * The message severity is given in parameter, based on the constants
+     * from {@link IStatus}.
+     * <p>
+     * Can be invoked from a non-UI thread.
+     * 
+     * @param pPart The part from which the status line can be found
+     * @param pMessage The message to display
+     * @param pSeverity The severity of the message (ie : IStatus.OK, etc.)
+     */
+    public static void outputMessage(final IWorkbenchPart pPart, final String pMessage, final int pSeverity) {
+
+        // Get the status line manager from the part
+        final IStatusLineManager vStatusLineManager = getStatusLineManager(pPart);
+
+        // Ensure that the status line manager can be found
+        if (vStatusLineManager != null) {
+
+            // Get the current display
+            Display vWorkbenchDisplay = null;
+            if (PlatformUI.isWorkbenchRunning()) {
+                vWorkbenchDisplay = PlatformUI.getWorkbench().getDisplay();
+            } else {
+                vWorkbenchDisplay = Display.getDefault();
+            }
+            
+            // Check if the current thread is an UI thread
+            if (Thread.currentThread().equals(vWorkbenchDisplay.getThread())) {
+                // Already on the UI thread, the message can be set directly
+                StatusLinesUtil.setMessage(vStatusLineManager, pMessage, pSeverity);
+            
+            } else {
+                // Not on the UI thread, must use an asynchronous update
+                vWorkbenchDisplay.asyncExec(new Runnable() {
+                    /**
+                     * {@inheritDoc}
+                     */
+                    @Override
+                    public void run() {
+                        // Set the message
+                        StatusLinesUtil.setMessage(vStatusLineManager, pMessage, pSeverity);
+                    }
+                });
+            }
+        }
+    }
+    
+    /**
+     * 
+     * @param pStatusLineManager The status line manager used to display the message.
+     * @param pMessage The message to display
+     * @param pSeverity The message severity
+     */
+    private static void setMessage(
+        final IStatusLineManager pStatusLineManager, 
+        final String pMessage, 
+        final int pSeverity) {
+        
+        switch (pSeverity) {
+            case IStatus.ERROR:
+                pStatusLineManager.setErrorMessage(pMessage);
+                break;
+
+            case IStatus.WARNING:
+                pStatusLineManager.setMessage(ImageConstants.ICON_WARNING, pMessage);
+                break;
+                
+            case IStatus.INFO:
+                pStatusLineManager.setMessage(ImageConstants.ICON_INFO, pMessage);
+                break;
+                
+            case IStatus.OK:          
+            default:
+                // Simply display the message
+                pStatusLineManager.setMessage(pMessage);
+                break;
+        }
+    }
+
+    /**
+     * Return the status line manager linked to the actions bar of the given part.
+     * 
+     * @param pPart The part from which the status line is searched
+     * @return The status line manager found, or null.
+     */
+    private static IStatusLineManager getStatusLineManager(final IWorkbenchPart pPart) {
+        
+        IStatusLineManager vStatusLineManager = null;
+
+        if (pPart instanceof IViewPart) {
+            // ... Get the status line from a simple view
+            
+            // Cast the part
+            IViewPart vViewPart = (IViewPart) pPart;
+
+            // Get the status line manager
+            vStatusLineManager = vViewPart.getViewSite().getActionBars().getStatusLineManager();
+
+        } else if (pPart instanceof IEditorPart) {
+            // ... Get the status line from an editor
+            
+            // Cast the part
+            IEditorPart vEditorPart = (IEditorPart) pPart;
+
+            // Get the status line manager from the editor action bar contributor
+            IEditorActionBarContributor vContributor = vEditorPart.getEditorSite().getActionBarContributor();
+            if (vContributor instanceof EditorActionBarContributor) {
+                vStatusLineManager = ((EditorActionBarContributor) vContributor).getActionBars().getStatusLineManager();
+            }
+        }
+        
+        return vStatusLineManager;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/treeviewer/CheckboxTreeSelectionHelper.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/treeviewer/CheckboxTreeSelectionHelper.java
new file mode 100644
index 0000000..d396eda
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/treeviewer/CheckboxTreeSelectionHelper.java
@@ -0,0 +1,452 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.treeviewer;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.eclipse.jface.viewers.CheckStateChangedEvent;
+import org.eclipse.jface.viewers.CheckboxTreeViewer;
+import org.eclipse.jface.viewers.ICheckStateListener;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+
+/**
+ * Adds selection behaviour to CheckboxTreeSelectionHelper.
+ * 
+ * Checking an element affects the following changes:
+ * <ol>
+ * <li>changes all descendants to the same check state</li>
+ * <li>if all siblings of the element are selected (and the element itself), sets parent element to checked state</li>
+ * <li>if some but not all siblings are in a checked state (including the element itself), parent is grayed</li>
+ * <li>if all siblings (and the element itself) are unchecked, parent is unchecked</li>
+ * <li>previous logic is applied to all ancestors of the element until the root is reached</li>
+ * </ol>
+ * 
+ * If specified, there is a limitation applied on the number of final selected elements too. What is a final element is
+ * based on external strategy.
+ * 
+ * Example usage: <br>
+ * <br>
+ * <code>
+ *  CheckboxTreeSelectionHelper.attach(myCheckboxTreeViewer, myContentProvider);<br>
+ *  myCheckboxTreeViewer.setInput(myInput);
+ * </code>
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public final class CheckboxTreeSelectionHelper {
+
+    /** Message when there is no content provider to set. */
+    private static final String MISSING_CONTENT_PROVIDER_ERROR = "Content provider is required"; //$NON-NLS-1$
+
+    /** The viewer. */
+    private CheckboxTreeViewer mViewer = null;
+
+    /** The content provider. */
+    private ITreeContentProvider mContentProvider = null;
+
+    /** Maximum number of final nodes selected. A final node is a node which is count as an item by the user. */
+    private int mMaximumFinalNodesSelected = 1;
+
+    /** Current number of final nodes selected. */
+    private int mCurrentFinalNodesSelected = 0;
+
+    /** Strategy for final node determination. */
+    private IFinalNodeStrategy mNodeStrategy = null;
+
+    /**
+     * Instantiates a new checkbox tree selection helper.
+     * 
+     * @param pViewer The viewer
+     * @param pContentProvider The content provider
+     * @param pMaxFinalNodesSelected The maximum final nodes selected
+     * @param pFinalNodeStrategy Strategy for final node determination
+     */
+    private CheckboxTreeSelectionHelper(final CheckboxTreeViewer pViewer,
+        final ITreeContentProvider pContentProvider,
+        final int pMaxFinalNodesSelected,
+        final IFinalNodeStrategy pFinalNodeStrategy) {
+        mViewer = pViewer;
+
+        mMaximumFinalNodesSelected = pMaxFinalNodesSelected;
+        mNodeStrategy = pFinalNodeStrategy;
+
+        // Check if content provider is not null
+        if (pContentProvider != null) {
+            mContentProvider = pContentProvider;
+        } else {
+            throw new IllegalArgumentException(MISSING_CONTENT_PROVIDER_ERROR);
+        }
+
+        init();
+    }
+
+    /**
+     * Initialise the listener and set the content provider if necessary.
+     */
+    private void init() {
+
+        mViewer.addCheckStateListener(new CheckBoxStateListener());
+
+        // Update content provider viewer with this current provider
+        if (!mViewer.getContentProvider().equals(mContentProvider)) {
+            mViewer.setContentProvider(mContentProvider);
+        }
+
+    }
+
+    /**
+     * @return <code>true</code> if a final node can be added, <code>false</code> otherwise
+     */
+    private boolean canAddFinalNode() {
+        return (mCurrentFinalNodesSelected < mMaximumFinalNodesSelected) || (mMaximumFinalNodesSelected == 0);
+    }
+
+    /**
+     * Check if the current node is final or not.
+     * What is final is just up to the user of this class. Final is more than just "no child". By example, if the user
+     * must choose a file, a folder without files is not a final node, even if it has no child.
+     * 
+     * @param pNode The node to evaluate
+     * @return <code>true</code> if it is a final node, <code>false</code> otherwise
+     */
+    private boolean isFinalNode(final Object pNode) {
+        boolean vResult = false;
+
+        if (mNodeStrategy != null) {
+            vResult = mNodeStrategy.isFinal(pNode);
+        }
+
+        return vResult;
+    }
+
+    /**
+     * Attach content provider and tree viewer with singleton instance of helper.
+     * Use the default behaviour for selection limitation : no limitation.
+     * 
+     * @param pViewer The viewer
+     * @param pContentProvider The content provider
+     * @return The checkbox tree selection helper
+     */
+    public static CheckboxTreeSelectionHelper attach(
+        final CheckboxTreeViewer pViewer,
+        final ITreeContentProvider pContentProvider) {
+        return new CheckboxTreeSelectionHelper(pViewer, pContentProvider, 0, null);
+    }
+
+    /**
+     * Attach content provider and tree viewer with singleton instance of helper.
+     * 
+     * @param pViewer The viewer
+     * @param pContentProvider The content provider
+     * @param pMaxFinalNodesSelected The maximum final nodes selected
+     * @param pFinalNodeStrategy Strategy for final node determination
+     * @return The checkbox tree selection helper
+     */
+    public static CheckboxTreeSelectionHelper attach(
+        final CheckboxTreeViewer pViewer,
+        final ITreeContentProvider pContentProvider,
+        final int pMaxFinalNodesSelected,
+        final IFinalNodeStrategy pFinalNodeStrategy) {
+        return new CheckboxTreeSelectionHelper(pViewer, pContentProvider, pMaxFinalNodesSelected, pFinalNodeStrategy);
+    }
+
+    /**
+     * Update tree.
+     * 
+     * @param pNode Current node
+     * @param pCheckedElements All checked elements
+     * @param pChecked New state for current node
+     */
+    private void updateTree(final Object pNode, final List<Object> pCheckedElements, final boolean pChecked) {
+
+        // Get descendants of current node
+        // NB : The list is built by depth, this order is important
+        //      for the following loop
+        List<Object> vDescendantsList = getDescendants(pNode);
+
+        // Create set from checked tree elements list
+        Set<Object> vCheckedSet = new HashSet<Object>(pCheckedElements);
+
+        // Iterate on each descendant, by depth. This is not only direct descendants, but also indirect too.
+        // Moreover, the loop is stopped when the limit of allowed selected element is reached. 
+        for (int i = 0; i < vDescendantsList.size() && canAddFinalNode(); i++) {
+            // Get the current descendant
+            Object vDescendant = vDescendantsList.get(i);
+
+            boolean vIsFinal = isFinalNode(vDescendant);
+            boolean vOriginalState = mViewer.getChecked(vDescendant);
+
+            // Erase gray state of descendant
+            mViewer.setGrayChecked(vDescendant, false);
+
+            // If it is an uncheck or if no more final node can be selected, there will only have uncheck action
+            boolean vCanCheck = pChecked && canAddFinalNode();
+            boolean vShouldHaveCheck = pChecked && !canAddFinalNode();
+
+            // There is still room left for selection
+            if (vCanCheck) {
+                mViewer.setChecked(vDescendant, pChecked);
+
+                // If it is a final node, count it
+                if (vIsFinal) {
+                    mCurrentFinalNodesSelected++;
+                }
+
+                vCheckedSet.add(vDescendant);
+
+            } else {
+                // If it is an unchecked, reduce the number of final node already selected
+                if (vIsFinal && !pChecked && vOriginalState) {
+                    mCurrentFinalNodesSelected--;
+                }
+
+                // No more room left, unselect each one, no matter if it is a final node or not
+                mViewer.setChecked(vDescendant, vCanCheck);
+
+                vCheckedSet.remove(vDescendant);
+
+            }
+
+            if (vShouldHaveCheck) {
+                // It is mandatory to keep a correct behavior.
+                // A final node should have been selected it there was still room free. Like it is not the case, the
+                // behavior coming from parent is bad and must be corrected
+                updateAncestors(vDescendant, vCheckedSet);
+            }
+        }
+
+        // Update ancestor's node
+        updateAncestors(pNode, vCheckedSet);
+    }
+
+    /**
+     * Update recursively ancestors.
+     * 
+     * @param pChild An element for which ancestors will be updated
+     * @param pCheckedElements Current already checked elements
+     */
+    private void updateAncestors(final Object pChild, final Set<Object> pCheckedElements) {
+        // Get parent's child
+        Object vParent = mContentProvider.getParent(pChild);
+        if (vParent != null) {
+
+            // Determine gray state of parent with child state
+            boolean vIsGrayed = mViewer.getChecked(pChild) && mViewer.getGrayed(pChild);
+
+            if (vIsGrayed) {
+                // if child is grayed then everything up should be grayed as well
+                mViewer.setGrayChecked(vParent, true);
+            } else {
+
+                // Get parent's children
+                Object[] vChildren = mContentProvider.getChildren(vParent);
+
+                // Filter by known checked elements
+                List<Object> vCloned = new ArrayList<Object>();
+                vCloned.addAll(Arrays.asList(vChildren));
+                vCloned.removeAll(pCheckedElements);
+
+                if (vCloned.isEmpty()) {
+                    // Every child is checked
+                    mViewer.setGrayed(vParent, false);
+                    mViewer.setChecked(vParent, true);
+
+                    // Add parent to checked elements set
+                    pCheckedElements.add(vParent);
+                } else {
+
+                    // Verify if parent is only checked
+                    if (mViewer.getChecked(vParent) && !mViewer.getGrayed(vParent)) {
+                        pCheckedElements.remove(vParent);
+                    }
+
+                    // Erase gray state of parent
+                    mViewer.setGrayChecked(vParent, false);
+
+                    // Some children selected but not all
+                    if (vCloned.size() < vChildren.length) {
+                        mViewer.setGrayChecked(vParent, true);
+                    }
+                }
+            }
+
+            // Recursive call on parent
+            updateAncestors(vParent, pCheckedElements);
+        }
+    }
+
+    /**
+     * Gets the descendants.
+     * 
+     * @param pNode The node
+     * @return The descendants
+     */
+    private List<Object> getDescendants(final Object pNode) {
+        List<Object> vDescendantsList = new ArrayList<Object>();
+        getDescendantsHelper(vDescendantsList, pNode);
+        return vDescendantsList;
+    }
+
+    /**
+     * Help to construct the list of descendants for a given node.
+     * The list built must follow a specific order to ensure that when the 
+     * descendant are browsed, it's made by depth first, and not on siblings children first.
+     * 
+     * @param pDescendantsList The descendants list, which will be modified recursively and build by depth
+     * @param pNode The node for which descendants are searched recursively
+     */
+    private void getDescendantsHelper(final List<Object> pDescendantsList, final Object pNode) {
+        // Get the children of the current node
+        Object[] vChildren = mContentProvider.getChildren(pNode);
+        
+        // Loop on the children found
+        for (Object vChild : vChildren) {
+            // Add the current child to the descendant list
+            pDescendantsList.add(vChild);
+            
+            // Make a recursive call to add its own children just after him
+            // NB : It's sibling elements will be added on the next loop iteration
+            getDescendantsHelper(pDescendantsList, vChild);
+        }
+    }
+
+    /**
+     * Gets the checked elements (excluding grayed out elements).
+     * 
+     * @return The checked elements
+     */
+    public List<Object> getCheckedElements() {
+        List<Object> vCheckedElements = new ArrayList<Object>(Arrays.asList(mViewer.getCheckedElements()));
+        vCheckedElements.removeAll(getGrayedElements());
+        return vCheckedElements;
+    }
+
+    /**
+     * Gets the grayed elements.
+     * 
+     * @return The grayed elements
+     */
+    public List<Object> getGrayedElements() {
+        return Arrays.asList(mViewer.getGrayedElements());
+    }
+
+    /**
+     * @return The maximum of final node allowed in selection
+     */
+    public int getMaximumFinalNodesSelected() {
+        return mMaximumFinalNodesSelected;
+    }
+
+    /**
+     * @param pMaximumFinalNodesSelected The maximum of final node allowed in selection
+     */
+    public void setMaximumFinalNodesSelected(final int pMaximumFinalNodesSelected) {
+        mMaximumFinalNodesSelected = pMaximumFinalNodesSelected;
+    }
+
+    /**
+     * @return The current number of final nodes selected
+     */
+    public int getCurrentFinalNodesSelected() {
+        return mCurrentFinalNodesSelected;
+    }
+
+    /**
+     * @param pCurrentFinalNodesSelected The current number of final nodes selected
+     */
+    public void setCurrentFinalNodesSelected(final int pCurrentFinalNodesSelected) {
+        mCurrentFinalNodesSelected = pCurrentFinalNodesSelected;
+    }
+
+    /**
+     * @return The final node strategy
+     */
+    public IFinalNodeStrategy getNodeStrategy() {
+        return mNodeStrategy;
+    }
+
+    /**
+     * @param pNodeStrategy The final node strategy to set
+     */
+    public void setNodeStrategy(final IFinalNodeStrategy pNodeStrategy) {
+        mNodeStrategy = pNodeStrategy;
+    }
+
+    /**
+     * 
+     * Class used as listener for the selected state of each element in tree viewer.
+     * 
+     * @author $Author: jdumont $
+     * @version $Revision: 83 $
+     */
+    private class CheckBoxStateListener
+        implements ICheckStateListener {
+
+        /**
+         * Default constructor.
+         */
+        public CheckBoxStateListener() {
+        }
+
+        /**
+         * {@inheritDoc}
+         * 
+         * Overridden to manually manage the grayed items.
+         */
+        @Override
+        public void checkStateChanged(final CheckStateChangedEvent pEvent) {
+
+            // Get element
+            Object vNode = pEvent.getElement();
+            boolean vChecked = pEvent.getChecked();
+            boolean vFinalNode = isFinalNode(vNode);
+
+            if (vChecked) {
+                // If it is a check, check if there is still room left. Otherwise uncheck it
+                if (!canAddFinalNode()) {
+                    mViewer.setChecked(vNode, false);
+                    vChecked = false;
+                } else {
+                    // If it is a final node keep track of selected final nodes number
+                    if (vFinalNode) {
+                        mCurrentFinalNodesSelected++;
+                    }
+                }
+            } else if (vFinalNode) {
+                // It is an uncheck on a final node
+                mCurrentFinalNodesSelected--;
+            }
+
+            // Erase gray state of state node
+            if (mViewer.getGrayed(vNode)) {
+                mViewer.setGrayChecked(vNode, false);
+            }
+
+            // Get all checked elements
+            List<Object> vCheckedElements = getCheckedElements();
+
+            /*
+             * Update tree according to :
+             * - Current node
+             * - Current checked elements
+             * - New state of current node
+             */
+            updateTree(vNode, vCheckedElements, vChecked);
+        }
+
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/treeviewer/FileFinalNodeStrategy.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/treeviewer/FileFinalNodeStrategy.java
new file mode 100644
index 0000000..e70bfa4
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/treeviewer/FileFinalNodeStrategy.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.treeviewer;
+
+import org.eclipse.core.resources.IFile;
+
+/**
+ * Validate node only if it is a file.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class FileFinalNodeStrategy
+    implements IFinalNodeStrategy {
+
+    /**
+     * Default constructor.
+     */
+    public FileFinalNodeStrategy() {
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * @return <code>true</code> if pNode is a file, <code>false</code> otherwise
+     */
+    @Override
+    public boolean isFinal(final Object pNode) {
+        return pNode instanceof IFile;
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/treeviewer/IFinalNodeStrategy.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/treeviewer/IFinalNodeStrategy.java
new file mode 100644
index 0000000..b7a3f5b
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/treeviewer/IFinalNodeStrategy.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.treeviewer;
+
+/**
+ * Behaviour used to check if a node is final or not in a tree.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public interface IFinalNodeStrategy {
+
+    /**
+     * Check if the current node is final or not.
+     * What is final is just up to the user of this contract. Final can be more than just "no child". By example, if the
+     * user must choose a file, a folder without files is not a final node, even if it has no child.
+     * 
+     * @param pNode The node to evaluate
+     * @return <code>true</code> if it is a final node, <code>false</code> otherwise
+     */
+    boolean isFinal(final Object pNode);
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractColumnViewerPage.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractColumnViewerPage.java
new file mode 100644
index 0000000..af3f5e3
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractColumnViewerPage.java
@@ -0,0 +1,531 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.view;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.jface.action.Action;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.viewers.ArrayContentProvider;
+import org.eclipse.jface.viewers.ColumnLabelProvider;
+import org.eclipse.jface.viewers.ColumnViewer;
+import org.eclipse.jface.viewers.EditingSupport;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.jface.viewers.ViewerColumn;
+import org.eclipse.jface.window.Window;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.dialogs.ListSelectionDialog;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+
+/**
+ * Abstract base of all the Pages to use in a PageBookView,
+ * and which includes a tree.
+ *
+ * This implementation doesn't manage the columns in the tree,
+ * but it inherits of all the standard mechanisms like the filters, the editing domain mechanisms, etc.
+ *
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public abstract class AbstractColumnViewerPage
+    extends AbstractPage {
+
+    /**
+     * Name of the required column.
+     * The required column is mandatory and can't be hidden.
+     */
+    private String mRequiredColumnName = null;
+
+    /** Arrays of the optional columns names, which can be displayed in the tree view. */
+    private String[] mColumnsNamesArray = null;
+
+    /**
+     * Default constructor, which allows to specify if the viewer must be read only or not.
+     *
+     * @param pReadOnlyMode <code>true</code> if this view is in read only mode, <code>false</code> otherwise
+     */
+    public AbstractColumnViewerPage(final boolean pReadOnlyMode) {
+        // Call the advanced constructor with default values
+        this(StringUtils.EMPTY, new String[0], pReadOnlyMode);
+    }
+
+    /**
+     * Advanced constructor which takes the name of the required column, an array with the optional columns name,
+     * and a boolean which specifies if the viewer must be in read only mode or not.
+     *
+     * The required column will mandatory be visible and can't be hidden.
+     *
+     * @param pRequiredColumnName The name of the required column name
+     * @param pColumnsName The array of optional columns name. This list must not contain the required column name
+     * @param pReadOnlyMode <code>true</code> if this view is in read only mode, <code>false</code> otherwise
+     */
+    public AbstractColumnViewerPage(
+        final String pRequiredColumnName,
+        final String[] pColumnsName,
+        final boolean pReadOnlyMode) {
+
+        // Call the parent constructor
+        super(pReadOnlyMode);
+
+        // Remember the given columns names
+        mRequiredColumnName = pRequiredColumnName;
+        mColumnsNamesArray = pColumnsName.clone();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void setViewerProviders() {
+        // We call the createRequiredViewerColumn() and then we associate
+        // the providers to associate the default label provider to the required column
+        createRequiredViewerColumn();
+        super.setViewerProviders();
+        createInitialViewerColumns();
+    }
+
+    /**
+     * Create the required column in the viewer.
+     * @return The created column
+     */
+    protected abstract ViewerColumn createRequiredViewerColumn();
+
+    /**
+     * Create the initial viewer columns, from the optional ones, which must be initially displayed.
+     * By default, no optional columns are initially displayed.
+     */
+    protected void createInitialViewerColumns() {
+        // Nothing to do
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected abstract ColumnViewer createViewer(final Composite pParent);
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public ColumnViewer getViewer() {
+        return (ColumnViewer) super.getViewer();
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Overridden to add the actions for the columns, the headers and the lines visibility.
+     */
+    @Override
+    protected void addMenuBarActions() {
+        addColumnsVisibilityAction();
+        addMenuBarSeparator();
+        addHideHeaderAction();
+        addHideLinesAction();
+        super.addMenuBarActions();
+    }
+
+    /**
+     * Add the columns visibility action to the menu bar.
+     */
+    protected void addColumnsVisibilityAction() {
+        addMenuBarAction(createColumnsVisibilityAction());
+    }
+
+    /**
+     * Add the hide header action to the menu bar.
+     */
+    protected void addHideHeaderAction() {
+        addMenuBarAction(createHideHeaderAction(isViewerHeaderInitiallyVisible()));
+    }
+
+    /**
+     * Add the hide lines action to the menu bar.
+     */
+    protected void addHideLinesAction() {
+        addMenuBarAction(createHideLinesAction(isViewerLinesInitiallyVisible()));
+    }
+
+    /**
+     * Return <code>true</code>if the header of the viewer is initially visible.
+     * @return <code>true</code>if the header of the viewer is initially visible.
+     */
+    protected abstract boolean isViewerHeaderInitiallyVisible();
+
+    /**
+     * Return <code>true</code>if the lines of the viewer are initially visible.
+     * @return <code>true</code>if the lines of the viewer are initially visible.
+     */
+    protected abstract boolean isViewerLinesInitiallyVisible();
+
+    /**
+     * Create and return the columns visibility action
+     * linked to the managed viewer.
+     *
+     * @return A new instance of the column visibility action
+     */
+    protected IAction createColumnsVisibilityAction() {
+        return new ColumnsVisibilityAction();
+    }
+
+    /**
+     * Create and return the hide lines action.
+     *
+     * @param pVisible <code>true</code> if the lines are visible by default, <code>false</code> otherwise
+     * @return A new instance of the hide lines action
+     */
+    protected IAction createHideLinesAction(final boolean pVisible) {
+        // Create the action, with the right label and display it as a checkbox
+        final Action vHideLinesAction = new Action(
+            CommonUIActivator.getMessages().getString("AbstractColumnViewerPage.action.showlines"), //$NON-NLS-1$
+            IAction.AS_CHECK_BOX) {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void run() {
+                AbstractColumnViewerPage.this.setLinesVisible(isChecked());
+            }
+        };
+
+        // Set the initial state to the action
+        vHideLinesAction.setChecked(pVisible);
+
+        return vHideLinesAction;
+    }
+
+    /**
+     * Create and return the hide header action.
+     *
+     * @param pVisible <code>true</code> if the header is visible by default, <code>false</code> otherwise
+     * @return A new instance of the hide header action
+     */
+    protected IAction createHideHeaderAction(final boolean pVisible) {
+        // Create the action, with the right label and display it as a checkbox
+        final Action vHideHeaderAction = new Action(
+            CommonUIActivator.getMessages().getString("AbstractColumnViewerPage.action.showheaders"), //$NON-NLS-1$
+            IAction.AS_CHECK_BOX) {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void run() {
+                AbstractColumnViewerPage.this.setHeaderVisible(isChecked());
+            }
+        };
+
+        // Set the initial state to the action
+        vHideHeaderAction.setChecked(pVisible);
+
+        return vHideHeaderAction;
+    }
+
+    /**
+     * Set the visibility of the lines in the viewer.
+     *
+     * @param pVisible <code>true</code> if the lines must be visible, <code>false</code> otherwise
+     */
+    public abstract void setLinesVisible(final boolean pVisible);
+
+    /**
+     * Set the visibility of the header in the viewer.
+     *
+     * @param pVisible <code>true</code> if the header must be visible, <code>false</code> otherwise
+     */
+    public abstract void setHeaderVisible(final boolean pVisible);
+
+    /**
+     * Create a new column at the end of the viewer, with the name given in parameter.
+     *
+     * @param pColumnName The name of the column
+     * @return The created tree viewer column, or null if the concrete implementation of this page doesn't support
+     *         the column viewers
+     */
+    protected abstract ViewerColumn createViewerColumn(final String pColumnName);
+
+    /**
+     * Create a new column in the viewer, at the specified location, with the name given in parameter.
+     *
+     * @param pColumnName The name of the column
+     * @param pIndex The location index where the column must be created in the viewer
+     * @return The created tree viewer column, or null if the concrete implementation of this page doesn't support
+     *         the column viewers
+     */
+    protected abstract ViewerColumn createViewerColumn(final String pColumnName, final int pIndex);
+
+    /**
+     * Create a new column at the end of the viewer, with the name given in parameter, and associate to it a
+     * label provider also given in parameter.
+     *
+     * @param pColumnName The name of the column
+     * @param pColumnLabelProvider The column label provider to use in the column
+     *
+     * @return The created tree viewer column, or null if the concrete implementation of this page doesn't support
+     *         the column viewers
+     */
+    protected abstract ViewerColumn createViewerColumn(
+        final String pColumnName,
+        final ColumnLabelProvider pColumnLabelProvider);
+
+    /**
+     * Create a new column at the end of the viewer, with the name given in parameter, and associate to it a
+     * label provider and an editing support also given in parameter.
+     *
+     * @param pColumnName The name of the column
+     * @param pColumnLabelProvider The column label provider to use in the column
+     * @param pEditingSupport The editing support to use in the column
+     *
+     * @return The created tree viewer column, or null if the concrete implementation of this page doesn't support
+     *         the column viewers
+     */
+    protected abstract ViewerColumn createViewerColumn(
+        final String pColumnName,
+        final ColumnLabelProvider pColumnLabelProvider,
+        final EditingSupport pEditingSupport);
+
+    /**
+     * Create a new column at the end of the viewer, with the name given in parameter, and associate to it a
+     * label provider and an editing support according to the property whose ID is given in parameter.
+     *
+     * @param pColumnName The name of the column
+     * @param pPropertyID The id of the property to display in the column
+     *
+     * @return The created tree viewer column, or null if the concrete implementation of this page doesn't support
+     *         the column viewers
+     */
+    protected abstract ViewerColumn createViewerColumn(final String pColumnName, final String pPropertyID);
+
+    /**
+     * Show a list of columns whose name is given in parameter.
+     *
+     * @param pColumnsNamesArray The array of the columns names to display.
+     */
+    protected void showColumns(final String[] pColumnsNamesArray) {
+        boolean vRefreshNeeded = false;
+
+        if (pColumnsNamesArray != null) {
+            // Loop on the names to find and display the corresponding column
+            for (String vColumnName : pColumnsNamesArray) {
+                // Check if the column in not already visible
+                if (!isColumnVisible(vColumnName)) {
+                    // Show the column and remember that a refresh is needed on the tree
+                    vRefreshNeeded = showColumn(vColumnName) || vRefreshNeeded;
+                }
+            }
+
+            // Refresh the tree content if at least one new column is displayed
+            if (vRefreshNeeded) {
+                getViewer().refresh();
+            }
+        }
+    }
+
+    /**
+     * Hide a list of columns, whose name is given in parameter.
+     *
+     * @param pColumnsNamesArray The array of the columns names to hide.
+     */
+    protected void hideColumns(final String[] pColumnsNamesArray) {
+        if (pColumnsNamesArray != null) {
+            // Loop on the names to find and hide the corresponding column
+            for (final String vColumnName : pColumnsNamesArray) {
+                // Check if the column is really visible and then hide it
+                if (isColumnVisible(vColumnName)) {
+                    hideColumn(vColumnName);
+                }
+            }
+        }
+    }
+
+    /**
+     * Show a column, whose name is given in parameter.
+     * The column may be created if needed.
+     *
+     * @param pColumnName The column name
+     * @return <code>true</code> if a column was found and shown, <code>false</code> otherwise
+     */
+    protected abstract boolean showColumn(final String pColumnName);
+
+    /**
+     * Hide the column whose name is given in parameter.
+     *
+     * @param pColumnName The column name
+     * @return <code>true</code> if a column was found and hidden, <code>false</code> otherwise
+     */
+    protected abstract boolean hideColumn(final String pColumnName);
+
+    /**
+     * Return a map containing in key the name of the columns
+     * and in value a flag specifying if it is currently visible or not.
+     *
+     * This map will contain the name of all the optional columns which may
+     * be added in the viewer, but not the required column which is considered
+     * as always visible.
+     *
+     * @return A map containing in key the name of the columns in the viewer,
+     *         and in value a flag specifying if the column is visible or not
+     */
+    protected Map<String, Boolean> getColumnsVisibility() {
+        // Create the returned map
+        final Map<String, Boolean> vColumnsVisibilityMap = new HashMap<String, Boolean>(mColumnsNamesArray.length);
+
+        // Loop on the names of optional columns
+        for (final String vColumnName : mColumnsNamesArray) {
+            // Add in the map the corresponding key and flag value
+            vColumnsVisibilityMap.put(vColumnName, isColumnVisible(vColumnName));
+        }
+
+        return vColumnsVisibilityMap;
+    }
+
+    /**
+     * Return the names of the optional columns which can be displayed in the tree view.
+     *
+     * @return The names of the optional columns which can be displayed in the tree view.
+     */
+    public String[] getColumnsName() {
+        return mColumnsNamesArray;
+    }
+
+    /**
+     * Return the name of the required column for the tree view.
+     *
+     * @return The required column name
+     */
+    public String getRequiredColumnName() {
+        return mRequiredColumnName;
+    }
+
+    /**
+     * Return <code>true</code> if a column exists in the viewer,
+     * and <code>false</code> otherwise.
+     *
+     * @param pColumnName The name of the column to check
+     * @return <code>true</code> if the table column is visible, <code>false</code> otherwise
+     */
+    protected abstract boolean isColumnVisible(final String pColumnName);
+
+    /**
+     * Custom action used to manage and change the visibility of the columns of the viewer.
+     *
+     * @author  $Author: jdumont $
+     * @version $Revision: 83 $
+     */
+    private class ColumnsVisibilityAction
+        extends Action {
+
+        /**
+         * Default constructor.
+         */
+        ColumnsVisibilityAction() {
+            super(CommonUIActivator.getMessages()
+                .getString("AbstractColumnViewerPage.menu.columnsvisibility")); //$NON-NLS-1$
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void run() {
+            final List<String> vColumnsNameArray = new ArrayList<String>();
+            final List<String> vVisibleColumnsNamesArray = new ArrayList<String>();
+
+            // Get the map specifying the visibility of each column
+            final Map<String, Boolean> vColumnsVisibilityMap = getColumnsVisibility();
+
+            // Loop on all the column visibility map to build two arrays :
+            // - one for all the columns names
+            // - one with only the name of visible columns
+            for (final String vColumnName : vColumnsVisibilityMap.keySet()) {
+                // Remember the column name
+                vColumnsNameArray.add(vColumnName);
+
+                // Remember the name of the visible column
+                if (vColumnsVisibilityMap.get(vColumnName)) {
+                    vVisibleColumnsNamesArray.add(vColumnName);
+                }
+            }
+
+            // Open a dialog to allow the user which columns must be visible
+            final Object[] vResultsArray = openColumnsSelectionDialog(
+                vColumnsNameArray,
+                vVisibleColumnsNamesArray);
+
+            if (vResultsArray != null) {
+
+                // Loop on the results array to build a set containing all the
+                // names of the column to show
+                Set<String> vShownColumnsNamesSet = new HashSet<String>();
+                for (final Object vResult : vResultsArray) {
+                    // NB : The result is normally already a String with the column name
+                    vShownColumnsNamesSet.add(vResult.toString());
+                }
+
+                // Then build the list of columns to hide, by removing from the whole list
+                // of columns, those to hide
+                Set<String> vHiddenColumnsNamesSet = new HashSet<String>(vColumnsVisibilityMap.keySet());
+                vHiddenColumnsNamesSet.removeAll(vShownColumnsNamesSet);
+
+                // Finally, hide and show the columns according to the user choices
+                hideColumns(vHiddenColumnsNamesSet.toArray(new String[vHiddenColumnsNamesSet.size()]));
+                showColumns(vShownColumnsNamesSet.toArray(new String[vShownColumnsNamesSet.size()]));
+            }
+        }
+
+        /**
+         * Open a dialog allowing the user to select which columns must
+         * be visible in the viewer.
+         *
+         * The array of selected columns is directly returned.
+         *
+         * @param pColumnsNamesArray The array of all the column names
+         * @param pVisibleColumnsNamesArray The array of all the columns names already currently visible
+         * @return The array of all the columns names to show
+         */
+        private Object[] openColumnsSelectionDialog(
+            final List<String> pColumnsNamesArray,
+            final List<String> pVisibleColumnsNamesArray) {
+
+            Object[] vResultsArray = null;
+
+            // Build the selection dialog
+            final ListSelectionDialog vDialog = new ListSelectionDialog(
+                PlatformUI.getWorkbench().getDisplay().getActiveShell(),
+                pColumnsNamesArray,
+                new ArrayContentProvider(),
+                new LabelProvider(),
+                CommonUIActivator.getMessages()
+                    .getString("AbstractColumnViewerPage.label.columnsvisibility")); //$NON-NLS-1$
+
+            // Set the dialog title and select by default the columns which are currently visible
+            vDialog.setTitle(CommonUIActivator.getMessages()
+                .getString("AbstractColumnViewerPage.title.columnsvisibility")); //$NON-NLS-1$
+            vDialog.setInitialElementSelections(pVisibleColumnsNamesArray);
+
+            // Finally open the dialog and remember of its result if the user validate its choice
+            if (vDialog.open() == Window.OK) {
+                vResultsArray = vDialog.getResult();
+            }
+
+            return vResultsArray;
+        }
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractModelPage.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractModelPage.java
new file mode 100644
index 0000000..691d50d
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractModelPage.java
@@ -0,0 +1,325 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.view;
+
+import java.util.Iterator;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
+import org.eclipse.emf.edit.domain.EditingDomain;
+import org.eclipse.emf.edit.domain.IEditingDomainProvider;
+import org.eclipse.jface.viewers.ColumnLabelProvider;
+import org.eclipse.jface.viewers.EditingSupport;
+import org.eclipse.jface.viewers.IBaseLabelProvider;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.TreeColumn;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.views.properties.PropertyColumnLabelProvider;
+import org.polarsys.esf.core.common.ui.actions.NoModifiesActionBarContributor;
+import org.polarsys.esf.core.common.ui.actions.ViewActionBarContributor;
+import org.polarsys.esf.core.common.ui.editingsupport.ValidatedPropertyEditingSupport;
+import org.polarsys.esf.core.common.ui.provider.FirstColumnLabelProvider;
+
+/**
+ * Base for pages which are looking at a ESF Model,
+ * and which will be displayed in a page book view.
+ *
+ * This allows to put several pages in a same view, in order
+ * to link the view content to the active editor for example.
+ *
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public abstract class AbstractModelPage
+    extends AbstractTreeTablePage {
+
+    /** Default column width. */
+    private static final int COLUMN_WIDTH = 150;
+
+    /** The resource set on which the page will be plugged. */
+    private ResourceSet mResourceSet = null;
+
+    /** The resource, contained in the resource set, which will be used as input for the page viewer. */
+    private Resource mResource = null;
+
+    /** The source part, containing the resource set and the editing domain, to link to this page. */
+    private IWorkbenchPart mSourcePart = null;
+
+    /**
+     * Default constructor.
+     *
+     * @param pSourcePart The source part to link to this page
+     * @param pRequiredColumnName Name of the required columns for the viewer
+     * @param pColumnsName Names of other columns
+     * @param pReadOnlyMode <code>true</code> if the page must be in read only mode
+     */
+    public AbstractModelPage(
+        final IWorkbenchPart pSourcePart,
+        final String pRequiredColumnName,
+        final String[] pColumnsName,
+        final boolean pReadOnlyMode) {
+
+        super(pRequiredColumnName, pColumnsName, pReadOnlyMode);
+        mSourcePart = pSourcePart;
+    }
+
+    /**
+     * Return the part linked to this page instance and used
+     * to get the source model.
+     *
+     * @return The sourcePart
+     */
+    public IWorkbenchPart getSourcePart() {
+        return mSourcePart;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected IBaseLabelProvider createLabelProvider() {
+        return new FirstColumnLabelProvider(getAdapterFactory());
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * For a page used to display an ESF model content, from the source editor linked
+     * to this instance, the initial input is the resource found in this editor.
+     *
+     * Thus, this method will initialise the {@link #mResource} and {@link #mResourceSet} properties
+     * to ensure that the page is plugged to the editor data.
+     */
+    @Override
+    protected Object getInitialInput() {
+        // Check if the source part is able to provide an editing domain provider
+        // If this is not the case, no input can be found
+        if (mSourcePart instanceof IEditingDomainProvider) {
+
+            // Get the resource set on which works the source part
+            mResourceSet = ((IEditingDomainProvider) mSourcePart).getEditingDomain().getResourceSet();
+
+            // Then loop on the resource set to find the ESF Resource to use as input
+            Iterator<Resource> vIterator = mResourceSet.getResources().iterator();
+            while (vIterator.hasNext() && mResource == null) {
+                Resource vResource = (Resource) vIterator.next();
+
+                // Check if the current resource is a ESF model
+                // TODO : Check the right resource type
+                if (vResource instanceof Resource) {
+                    // Remember of this resource to use it as input
+                    mResource = vResource;
+                }
+            }
+        }
+
+        return mResource;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected ResourceSet getResourceSet() {
+        return mResourceSet;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     *
+     * This method is overridden to ensure that the source part editing domain will be used if possible
+     * instead of creating a new one.
+     */
+    @Override
+    protected EditingDomain createEditingDomain() {
+        EditingDomain vEditingDomain = null;
+
+        if (mSourcePart instanceof IEditingDomainProvider) {
+            // Get the editing domain of the source part if possible
+            vEditingDomain = (AdapterFactoryEditingDomain) ((IEditingDomainProvider) mSourcePart).getEditingDomain();
+
+            // Get the command stack of the editing domain to add a listener on it
+            addCommandStackListener(vEditingDomain.getCommandStack());
+
+        } else {
+            // Call the parent method otherwise to create a default editing domain
+            vEditingDomain = super.createEditingDomain();
+        }
+
+        return vEditingDomain;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Overridden to add an action bar contributor without any action able to modify model.
+     */
+    @Override
+    protected ViewActionBarContributor createActionBarContributor() {
+        return new NoModifiesActionBarContributor();
+    }
+
+    /**
+     * Initialise the width of the viewer columns, only if their actual size is less than column width constant.
+     * Moreover, the column alignment is set to center.
+     */
+    protected void setColumnsWidthAndAlignment() {
+        TreeColumn[] vColummnsArray = getViewer().getTree().getColumns();
+
+        for (TreeColumn vColumn : vColummnsArray) {
+            vColumn.setAlignment(SWT.CENTER);
+
+            if (vColumn.getWidth() < COLUMN_WIDTH) {
+                vColumn.setWidth(COLUMN_WIDTH);
+            }
+        }
+    }
+
+    /**
+     * Add a column in view, and initialise it, to ensure that :
+     * <ul>
+     *  <li>it's editable if needed.</li>
+     *  <li>it's linked to to right properties.</li>
+     *  <li>its width is set.</li>
+     * </ul>
+     *
+     * @param pColumnName The column name, used to identify it
+     */
+    protected void addColumnViewer(final String pColumnName) {
+
+        // Get the editable state for the column given
+        boolean vIsEditable = isColumnEditable(pColumnName);
+
+        // Create a column label provider in function of the target column
+        ColumnLabelProvider vColumnLabelProvider = createColumnLabelProvider(pColumnName);
+
+        // Get the property id associated to the given column
+        String vPropertyId = getAssociatedColumnPropertyID(pColumnName);
+
+        // Try to create an editing support if the column is editable,
+        // and associated to a property in the model
+        if (vIsEditable && StringUtils.isNotEmpty(vPropertyId)) {
+
+            // Create an editing support for column which can be modified
+            EditingSupport vEditingSupport =
+                new ValidatedPropertyEditingSupport(
+                    getViewer(),
+                    getPropertySourceProvider(),
+                    vPropertyId,
+                    getActionBars().getStatusLineManager());
+
+            // Then create the column with this editing support
+            createViewerColumn(pColumnName, vColumnLabelProvider, vEditingSupport);
+
+        } else {
+            // Create a non editable column
+            createViewerColumn(pColumnName, vColumnLabelProvider);
+        }
+
+        // Once that a column has been added, reset the width
+        // and alignment of each of them
+        setColumnsWidthAndAlignment();
+    }
+
+    /**
+     * Create a column label provider in function of the target column.
+     * The label provider may built by default is based on the property id associated
+     * to the given column.
+     *
+     * @param pColumnName The name of the column concerned
+     * @return The created column label provider
+     */
+    protected ColumnLabelProvider createColumnLabelProvider(final String pColumnName) {
+        ColumnLabelProvider vColumnLabelProvider = null;
+
+        // Get the id of the property linked to this column
+        String vPropertyId = getAssociatedColumnPropertyID(pColumnName);
+
+        if (StringUtils.isNotEmpty(vPropertyId)) {
+            // Create a new label provider for this property
+            vColumnLabelProvider = new PropertyColumnLabelProvider(
+                    getPropertySourceProvider(),
+                    vPropertyId);
+
+        } else {
+            // Create a default label provider
+            vColumnLabelProvider = new ColumnLabelProvider();
+        }
+
+        return vColumnLabelProvider;
+    }
+
+    /**
+     * Return a boolean specifying if the column, identified by the name given in parameter
+     * is editable or not.
+     *
+     * Return false by default.
+     *
+     * @param pColumnName The column name
+     * @return <code>true</code> if the column is editable
+     */
+    protected boolean isColumnEditable(final String pColumnName) {
+        return false;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * In the model pages implementations, the drag and drop actions are disabled, as
+     * these pages are made to view to model, not to modify its structure.
+     */
+    @Override
+    protected void addDragSupport() {
+        // Nothing to do
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * In the model pages implementations, the drag and drop actions are disabled, as
+     * these pages are made to view to model, not to modify its structure.
+     */
+    @Override
+    protected void addDropSupport() {
+        // Nothing to do
+    }
+
+    /**
+     * Get the associated property Id for a column whose name is given in parameter.
+     *
+     * Return an empty String by default.
+     *
+     * @param pColumnName Column name
+     * @return The associated property Id found, or an empty String if no property is associated
+     */
+    protected String getAssociatedColumnPropertyID(final String pColumnName) {
+        return StringUtils.EMPTY;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     *
+     * This default implementation create a new column for each name returned
+     * by the method {@link #getColumnsName()}.
+     */
+    @Override
+    protected void createInitialViewerColumns() {
+        // Loop on all the columns name to create a new one for each
+        for (String vColumnName : getColumnsName()) {
+            // Only the analysis closed column can be edited
+            addColumnViewer(vColumnName);
+        }
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractModelPageBookView.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractModelPageBookView.java
new file mode 100644
index 0000000..9f73187
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractModelPageBookView.java
@@ -0,0 +1,205 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.view;
+
+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.jface.viewers.Viewer;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.part.IPage;
+import org.eclipse.ui.part.MessagePage;
+import org.eclipse.ui.part.PageBook;
+import org.eclipse.ui.part.PageBookView;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+import org.polarsys.esf.core.common.ui.filter.IFilterPartListener;
+
+/**
+ * Abstract base for the views which are looking at the content of an ESF Model
+ * opened in any type of editor (Graphical, EMF tree table, etc.).
+ * 
+ * These views are also listening to the changes on the filter to adapt the content
+ * of their pages. 
+ * 
+ * Moreover, they must implements the interface IEditingDomainProvider to return the editing
+ * domain used by the current page. This is mandatory to enable the actions activation with 
+ * the action bars contributor.
+ * To enable the refresh contextual action, the view must provide a viewer, and implements
+ * the IViewerProvider interface. The viewer search is delegated to the current page.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public abstract class AbstractModelPageBookView
+    extends PageBookView
+    implements IFilterPartListener, IEditingDomainProvider, IViewerProvider {
+    
+    /** Message to show on the default page. */
+    private static final String DEFAULT_TEXT = CommonUIActivator.getMessages()
+        .getString("AbstractSAModelPageBookView.defaultPage.label"); //$NON-NLS-1$
+
+    /**
+     * Default constructor.
+     */
+    public AbstractModelPageBookView() {
+        super();
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * The default page displays only a message to warn the user that 
+     * he must open an editor to link a new page to its content.
+     */
+    @Override
+    protected IPage createDefaultPage(final PageBook pBook) {
+        
+        // Create the default page, which will contains only an information message
+        MessagePage vPage = new MessagePage();
+        
+        // Initialise the page and create its controls
+        initPage(vPage);
+        vPage.createControl(pBook);
+        
+        // Set the default message to the page
+        vPage.setMessage(DEFAULT_TEXT);
+        
+        return vPage;
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * Track only the editors to synchronise the view pages.
+     */
+    @Override
+    protected boolean isImportant(final IWorkbenchPart pPart) {
+        // Only cares about editors
+        return pPart instanceof IEditorPart;
+    }
+    
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void doDestroyPage(final IWorkbenchPart pPart, final PageRec pPageRec) {
+        // Get the page from the page record
+        IPage vPage = pPageRec.page;
+        
+        // Dispose the page, and the record
+        vPage.dispose();
+        pPageRec.dispose();
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * Return the active editor for the current page. 
+     */
+    @Override
+    protected IWorkbenchPart getBootstrapPart() {
+        IWorkbenchPart vBootStrapPart = null;
+        
+        // Get the current page shown
+        IWorkbenchPage vPage = getSite().getPage();
+        if (vPage != null) {
+            // Get the active editor linked to this page
+            vBootStrapPart = vPage.getActiveEditor();
+        }
+
+        return vBootStrapPart;
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * Treat this event as a part activation.
+     * Otherwise, nothing is done by default.
+     */
+    @Override
+    public void partBroughtToTop(final IWorkbenchPart pPart) {
+        partActivated(pPart);
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * This method is overridden to register this current page book view as selection provider 
+     * in the page action bar contributor, to enable the contextual actions.
+     * 
+     * This must be done on each activation, and not only once when the page is initialised,
+     * as in this case, the {@link #getEditingDomain()} method will be called only once, and
+     * the actions won't be linked to the right editing domain. 
+     */
+    @Override
+    public void partActivated(final IWorkbenchPart pPart) {
+        // Call the parent method
+        super.partActivated(pPart);
+        
+        // If the current page in a instance of model page, update its action bar contributor
+        // to use this view as selection listener
+        if (getCurrentPage() instanceof AbstractModelPage) {                
+            ((AbstractModelPage) getCurrentPage()).updateActionBarContributorActivePart(this);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * For a page book view, the event treatment is delegated to the current page.
+     */
+    @Override
+    public void filterTextChanged(final String pNewFilterText) {
+        IPage vCurrentPage = getCurrentPage();
+        
+        if (vCurrentPage instanceof AbstractModelPage) {
+            ((AbstractModelPage) vCurrentPage).filterTextChanged(pNewFilterText);
+        }        
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * Return the editing domain of the current page displayed.
+     */
+    @Override
+    public EditingDomain getEditingDomain() {
+        
+        EditingDomain vEditingDomain = null;
+        
+        // Delegate the editing domain providing to the current page
+        if (getCurrentPage() instanceof IEditingDomainProvider) {
+            vEditingDomain = ((IEditingDomainProvider) getCurrentPage()).getEditingDomain();
+        }
+        
+        return vEditingDomain;
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * Return the viewer current page displayed if possible, null otherwise.
+     */
+    @Override
+    public Viewer getViewer() {
+        
+        Viewer vViewer = null;
+        
+        // Delegate the viewer providing to the current page
+        if (getCurrentPage() instanceof IViewerProvider) {
+            vViewer = ((IViewerProvider) getCurrentPage()).getViewer();
+        }
+        
+        return vViewer;
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractPage.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractPage.java
new file mode 100644
index 0000000..a02e1ea
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractPage.java
@@ -0,0 +1,1187 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.view;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.EventObject;
+import java.util.HashMap;
+import java.util.List;
+
+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.ui.viewer.IViewerProvider;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
+import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain.EditingDomainProvider;
+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.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.jface.action.IAction;
+import org.eclipse.jface.action.IMenuListener;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.IStatusLineManager;
+import org.eclipse.jface.action.MenuManager;
+import org.eclipse.jface.action.Separator;
+import org.eclipse.jface.viewers.DoubleClickEvent;
+import org.eclipse.jface.viewers.IBaseLabelProvider;
+import org.eclipse.jface.viewers.IContentProvider;
+import org.eclipse.jface.viewers.IDoubleClickListener;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.jface.viewers.StructuredViewer;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.jface.viewers.ViewerFilter;
+import org.eclipse.swt.dnd.DND;
+import org.eclipse.swt.dnd.Transfer;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Menu;
+import org.eclipse.ui.IActionBars;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.part.IPageSite;
+import org.eclipse.ui.part.Page;
+import org.eclipse.ui.views.properties.IPropertySourceProvider;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+import org.polarsys.esf.core.common.ui.actions.ViewActionBarContributor;
+import org.polarsys.esf.core.common.ui.constants.ImageConstants;
+import org.polarsys.esf.core.common.ui.filter.AbstractFilter;
+import org.polarsys.esf.core.common.ui.filter.NamePropertyFilter;
+import org.polarsys.esf.core.common.ui.view.properties.PropertySourceProvider;
+
+/**
+ * Abstract base of all the Pages to use in a PageBookView,
+ * with the filters, the editing domain mechanisms, etc.
+ * 
+ * This abstract page implement the following interfaces :
+ * - IEditingDomainProvider : to allow other classes to access to its editing domain
+ * - IMenuListener : to be warned when a menu is about to show
+ * - IViewerProvider : to allow other classes to access to its viewer
+ * - IFiltrePageListener : to enable the filter mechanisms
+ * 
+ * NB : This kind of page doesn't manage a link with the Properties view, nor a save action
+ * as its behaviour is to be dependent of an opened editor. Thus, it's the editor
+ * selection with is displayed in the Properties view, and the dirty state is also managed
+ * by the editor.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public abstract class AbstractPage
+    extends Page
+    implements IEditingDomainProvider, IMenuListener, IViewerProvider {
+
+    /** The pop-up menu id. */
+    private static final String POP_UP_ID = "#PopUp"; //$NON-NLS-1$
+
+    /** The additions menu section id. */
+    private static final String ADDITIONS_SEPARATOR_ID = "additions"; //$NON-NLS-1$
+
+    /** The adapter factory used to provide the views of the model elements. */
+    private ComposedAdapterFactory mComposedAdapterFactory = null;
+
+    /** The editing domain used to track all the changes to the model elements, if this view is editable. */
+    private EditingDomain mEditingDomain = null;
+
+    /**
+     * The command stack listener to plug to the command stack of the used editing domain,
+     * to be warned the changes happend.
+     */
+    private CommandStackListener mCommandStackListener = new CommandStackListener() {
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void commandStackChanged(final EventObject pEvent) {
+            AbstractPage.this.getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public void run() {
+                    handleCommandStackChanged(((CommandStack) pEvent.getSource()).getMostRecentCommand());
+                }
+            });
+        }
+    };
+
+    /** The label provider used in the viewer. */
+    private IBaseLabelProvider mLabelProvider = null;
+
+    /** The content provider used in the viewer. */
+    private IContentProvider mContentProvider = null;
+
+    /** The property source provider used in the viewer. */
+    private IPropertySourceProvider mPropertySourceProvider = null;
+
+    /** The view action bar contributor. */
+    private ViewActionBarContributor mActionBarContributor = null;
+
+    /** The viewer used in this page. */
+    private StructuredViewer mViewer = null;
+
+    /** Flag which indicates if this view is in read only mode. */
+    private boolean mReadOnlyMode = true;
+
+    /**
+     * Constructor used to specify if the view is read only or not.
+     * 
+     * @param pReadOnlyMode <code>true</code> if this view is in read only mode, <code>false</code> otherwise
+     */
+    public AbstractPage(final boolean pReadOnlyMode) {
+        super();
+        mReadOnlyMode = pReadOnlyMode;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void dispose() {
+
+        // Remove the potential listener on the command stack used
+        // This is mandatory as the command stack may not be in this instance context only
+        if (mEditingDomain != null && mEditingDomain.getCommandStack() != null) {
+            mEditingDomain.getCommandStack().removeCommandStackListener(mCommandStackListener);
+        }
+
+        if (mLabelProvider != null) {
+            mLabelProvider.dispose();
+            mLabelProvider = null;
+        }
+
+        if (mContentProvider != null) {
+            mContentProvider.dispose();
+            mContentProvider = null;
+        }
+
+        if (mComposedAdapterFactory != null) {
+            mComposedAdapterFactory.dispose();
+            mComposedAdapterFactory = null;
+        }
+
+        if (mActionBarContributor != null) {
+            // Unlink the potential active part registered in the
+            // action bar contributor and dispose it
+            mActionBarContributor.setActivePart(null);
+            mActionBarContributor.dispose();
+            mActionBarContributor = null;
+        }
+
+        super.dispose();
+    }
+
+    /**
+     * @return <code>true</code> if the view is in read only mode, <code>false</code> otherwise.
+     */
+    public boolean isReadOnlyMode() {
+        return mReadOnlyMode;
+    }
+
+    /**
+     * Initialise the editing domain for this page.
+     * 
+     * The default implementation create a new adapter factory, and
+     * a new editing domain for this page instance by calling : {@link AbstractPage#createAdapterFactory()} and
+     * {@link AbstractPage#createEditingDomain()}
+     */
+    protected void initializeEditingDomain() {
+        mComposedAdapterFactory = createAdapterFactory();
+        mEditingDomain = createEditingDomain();
+    }
+
+    /**
+     * Create and return an instance of {@link ComposedAdapterFactory} and initialise it with the adapter factories.
+     * 
+     * @see #getAdapterFactories()
+     * @return The created {@link ComposedAdapterFactory}
+     */
+    protected ComposedAdapterFactory createAdapterFactory() {
+        // Create an adapter factory that yields the needed item providers
+        final ComposedAdapterFactory vComposedAdapterFactory = new ComposedAdapterFactory();
+
+        // Loop on the adapter factories to add each one to the composed adapter factory
+        for (final Class<? extends AdapterFactory> vAdapterFactory : getAdapterFactories()) {
+            try {
+                vComposedAdapterFactory.addAdapterFactory(vAdapterFactory.newInstance());
+            } catch (final InstantiationException e) {
+                CommonUIActivator.INSTANCE.log(e);
+            } catch (final IllegalAccessException e) {
+                CommonUIActivator.INSTANCE.log(e);
+            }
+        }
+
+        return vComposedAdapterFactory;
+    }
+
+    /**
+     * Return the adapter factories that will be added to the composed adapter factory
+     * used by this page.
+     * 
+     * @return Adapter factories to add to the composed adapter factory
+     */
+    protected abstract Collection<Class<? extends AdapterFactory>> getAdapterFactories();
+
+    /**
+     * This sets the selection into the active viewer.
+     * 
+     * @param pSelections The selection elements to set
+     * 
+     */
+    protected void setSelectionToViewer(final Collection<?> pSelections) {
+        // Check if this selection is valid
+        if (pSelections != null && !pSelections.isEmpty()) {
+
+            // Use a runnable in an UI thread to update the viewer selection
+            getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                @Override
+                public void run() {
+                    // Try to select the items in the current content viewer
+                    if (mViewer != null) {
+                        mViewer.setSelection(new StructuredSelection(pSelections.toArray()), true);
+                    }
+                }
+            });
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * This returns the editing domain as required by the {@link IEditingDomainProvider} interface.
+     * This is important to implement several mechanisms as the Commands, etc.
+     * 
+     * @return The current editing domain used
+     */
+    @Override
+    public EditingDomain getEditingDomain() {
+        return mEditingDomain;
+    }
+
+    /**
+     * Create and return an instance of {@link AdapterFactoryEditingDomain}.
+     * 
+     * This base implementation creates a default editing domain and associate it to a new {@link CommandStack}, and to
+     * the resource set returned by the {@link #getResourceSet()} if it's not null. Otherwise, it uses a new resource
+     * set.
+     * 
+     * @return The created instance of {@link EditingDomain}
+     */
+    protected EditingDomain createEditingDomain() {
+
+        AdapterFactoryEditingDomain vEditingDomain = null;
+
+        // Create a default command stack
+        final CommandStack vCommandStack = createCommandStack();
+
+        // Get the resource set used by this page
+        final ResourceSet vResourceSet = getResourceSet();
+
+        if (vResourceSet != null) {
+            // A resource set is known, use it to create the editing domain
+            vEditingDomain = new AdapterFactoryEditingDomain(getAdapterFactory(), vCommandStack, vResourceSet);
+            vEditingDomain.setResourceToReadOnlyMap(new HashMap<Resource, Boolean>());
+
+        } else {
+            // A resource set is not known, create the editing domain with a new resource set
+            vEditingDomain = new AdapterFactoryEditingDomain(
+                getAdapterFactory(),
+                vCommandStack,
+                new HashMap<Resource, Boolean>());
+        }
+
+        return vEditingDomain;
+    }
+
+    /**
+     * Create and return a default command stack, which allow to react to its changes
+     * using the {@link AbstractPage#handleCommandStackChanged(Command)} method.
+     * 
+     * @return The command stack created
+     */
+    protected BasicCommandStack createCommandStack() {
+        // Create the command stack
+        final BasicCommandStack vCommandStack = new BasicCommandStack();
+
+        // Add the listener which will notify this page when commands are executed
+        addCommandStackListener(vCommandStack);
+
+        return vCommandStack;
+    }
+
+    /**
+     * Add a custom listener to the given command stack.
+     * This listener is used to allow to this page to react to a change in the command stack.
+     * 
+     * @param pCommandStack The command stack to listen
+     */
+    protected void addCommandStackListener(final CommandStack pCommandStack) {
+        // Add a listener on the command stack to warn the page when something changed
+        pCommandStack.addCommandStackListener(mCommandStackListener);
+    }
+
+    /**
+     * Remove the custom listener to the given command stack.
+     * This is mandatory to dispose correctly the page.
+     * 
+     * @param pCommandStack The command stack to stop to listen
+     */
+    protected void removeCommandStackListener(final CommandStack pCommandStack) {
+        // Remove the potential listener on the command stack
+        pCommandStack.removeCommandStackListener(mCommandStackListener);
+    }
+
+    /**
+     * This method is called when the command stack is changed, to allow the
+     * page to react. By default, this will simply select the objects
+     * affected by the command in the viewer.
+     * 
+     * @param pMostRecentCommand The most recent command
+     */
+    protected void handleCommandStackChanged(final Command pMostRecentCommand) {
+        if (pMostRecentCommand != null) {
+            // Try to select the affected objects
+            setSelectionToViewer(pMostRecentCommand.getAffectedObjects());
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * Returns the viewer as required by the {@link IViewerProvider} interface.
+     * It can be any kind of viewer (tree, table, etc.).
+     * 
+     * @return The viewer of this page
+     */
+    @Override
+    public Viewer getViewer() {
+        return mViewer;
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * By default, return this page viewer control.
+     */
+    @Override
+    public Control getControl() {
+        return getViewer().getControl();
+    }
+
+    /**
+     * Creates a default context menu and set it to the viewer.
+     */
+    protected void addContextMenu() {
+        // Create a default context menu
+        final MenuManager vContextMenuManager = new MenuManager();
+        vContextMenuManager.add(new Separator(ADDITIONS_SEPARATOR_ID));
+        vContextMenuManager.setRemoveAllWhenShown(true);
+
+        // Register this page instance as menu listener to ensure
+        // that it will be warn when the menu is opened
+        vContextMenuManager.addMenuListener(this);
+
+        // Create a context menu in the new menu manager, and link it to the viewer
+        final Menu vMenu = vContextMenuManager.createContextMenu(mViewer.getControl());
+        mViewer.getControl().setMenu(vMenu);
+
+        // Register the context menu to the viewer selection
+        getSite().registerContextMenu(POP_UP_ID, vContextMenuManager, new UnwrappingSelectionProvider(mViewer));
+    }
+
+    /**
+     * Add a drag support to the viewer.
+     */
+    protected void addDragSupport() {
+        final int vDndOperations = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
+        final Transfer[] vTransfersArray = new Transfer[] {LocalTransfer.getInstance()};
+
+        mViewer.addDragSupport(
+            vDndOperations,
+            vTransfersArray,
+            new ViewerDragAdapter(mViewer));
+    }
+
+    /**
+     * Add a drop support to the viewer.
+     */
+    protected void addDropSupport() {
+        final int vDndOperations = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
+        final Transfer[] vTransfersArray = new Transfer[] {LocalTransfer.getInstance()};
+
+        mViewer.addDropSupport(
+            vDndOperations,
+            vTransfersArray,
+            new EditingDomainViewerDropAdapter(mEditingDomain, mViewer));
+    }
+
+    /**
+     * Return the adapter factory content provider to associate to the viewer.
+     * If no content provider is known, create a default one.
+     * 
+     * @return Return the content provider to associate to the viewer
+     */
+    protected IContentProvider getContentProvider() {
+        if (mContentProvider == null) {
+            // Create a default content provider
+            mContentProvider = createContentProvider();
+        }
+
+        return mContentProvider;
+    }
+
+    /**
+     * Create and return a default content provider.
+     * The content provider must call {@link #inputChanged(oldInput,newInput) in the method
+     * 
+     * @return The created content provider
+     */
+    protected IContentProvider createContentProvider() {
+        return new AdapterFactoryContentProvider(getAdapterFactory()) {
+
+            /**
+             * {@inheritDoc}
+             * 
+             * This method is overridden to be able to manage the arrays as input element.
+             */
+            @Override
+            public Object[] getElements(final Object pInputElement) {
+                Object[] vElementsArray = new Object[] {};
+
+                // Check if the input element is an array
+                if (pInputElement instanceof Object[]) {
+                    // If the input is an array, loop on each input object in it
+                    // to get its corresponding elements
+                    final List<Object> vElementsList = new ArrayList<Object>();
+                    for (final Object vInputElement : (Object[]) pInputElement) {
+                        vElementsList.addAll(Arrays.asList(super.getElements(vInputElement)));
+                    }
+
+                    // Build the final elements array from the list
+                    if (!vElementsList.isEmpty()) {
+                        vElementsArray = vElementsList.toArray(new Object[vElementsList.size()]);
+                    }
+
+                } else {
+                    // If the input is a single object, get its element by calling the parent method
+                    vElementsArray = super.getElements(pInputElement);
+                }
+
+                return vElementsArray;
+            }
+
+            /**
+             * {@inheritDoc}
+             * 
+             * This method is overridden to warn the page instance that its input has changed
+             * if the content provider input changes.
+             */
+            @Override
+            public void inputChanged(final Viewer pViewer, final Object pOldInput, final Object pNewInput) {
+                // Call the parent method
+                super.inputChanged(pViewer, pOldInput, pNewInput);
+
+                // Warn the page that its input changed
+                AbstractPage.this.inputChanged(pOldInput, pNewInput);
+            }
+
+            /**
+             * {@inheritDoc}
+             * 
+             * This method is overridden to warn the page instance that its input has been disposed.
+             */
+            @Override
+            public void dispose() {
+                if (viewer != null) {
+                    // Set the page input to null
+                    AbstractPage.this.inputChanged(viewer.getInput(), null);
+                }
+                super.dispose();
+            }
+        };
+    }
+
+    /**
+     * Called when the input is changed to attach the {@link IEditingDomainProvider} if needed.
+     * 
+     * @param pOldInput the old input element, or null if the viewer did not previously have an input
+     * @param pNewInput the new input element, or null if the viewer does not have an input
+     */
+    protected void inputChanged(final Object pOldInput, final Object pNewInput) {
+        disposeOldInput(pOldInput);
+        inputChanged(pNewInput);
+    }
+
+    /**
+     * React to an input change, to link the page content to the new input.
+     * If the input is a resource (or an array of resources), attach all the needed adapters to it.
+     * 
+     * @param pNewInput The new input value
+     */
+    private void inputChanged(final Object pNewInput) {
+
+        // Initialise a list of resource to add as input
+        List<Resource> vInputResourcesList = new ArrayList<Resource>();
+
+        if (pNewInput instanceof Resource) {
+            // If the new input is a resource, add it in the list to manage
+            vInputResourcesList.add((Resource) pNewInput);
+
+        } else if (pNewInput instanceof Object[]) {
+            // The input is an array, look in its content for the potential resources
+            // to use as input
+            for (final Object vInput : (Object[]) pNewInput) {
+                if (vInput instanceof Resource) {
+                    vInputResourcesList.add((Resource) vInput);
+                }
+            }
+        }
+
+        // Finally, loop on the resources to add as input
+        for (Resource vResource : vInputResourcesList) {
+            // Attach all the needed adapters
+            attachAdapterForResource(vResource);
+
+            // Add the resource to the resource set of the used editing domain
+            // but lock its edition if the view is read only, and if the editing
+            // domain allows it
+            if (mReadOnlyMode && mEditingDomain instanceof AdapterFactoryEditingDomain) {
+                // Add the resource in the locked part of the resource set
+                ((AdapterFactoryEditingDomain) mEditingDomain).getResourceToReadOnlyMap().put(vResource, Boolean.TRUE);
+
+            } else {
+                // The view is not in read only, or the editing domain doesn't allow to lock its resource,
+                // thus simply add the resource in the resource set
+                mEditingDomain.getResourceSet().getResources().add(vResource);
+            }
+        }
+    }
+
+    /**
+     * Dispose an old input.
+     * 
+     * A custom treatment is applied if the input was a resource or an
+     * array of resources, to ensure that all the potential listeners or adapters
+     * are also disposed.
+     * 
+     * @param pOldInput The input to dispose
+     */
+    private void disposeOldInput(final Object pOldInput) {
+        if (pOldInput instanceof Resource) {
+            // The old input was a resource, detach all the potential adapters
+            detachAdapterFromResource((Resource) pOldInput);
+
+        } else if (pOldInput instanceof Object[]) {
+            // The old input was an array, check if it contains any resource,
+            // to detach all the potential adapters
+            for (final Object vOldInput : (Object[]) pOldInput) {
+                if (vOldInput instanceof Resource) {
+                    detachAdapterFromResource((Resource) vOldInput);
+                }
+            }
+        }
+    }
+
+    /**
+     * Return the label provider to associate to the viewer.
+     * If no label provider is known, create a default one.
+     * 
+     * @return Return the label provider to associate to the viewer
+     */
+    protected IBaseLabelProvider getLabelProvider() {
+        if (mLabelProvider == null) {
+            mLabelProvider = createLabelProvider();
+        }
+        return mLabelProvider;
+    }
+
+    /**
+     * Create and return a default label provider based on the adapter factory.
+     * 
+     * @return The created label provider
+     */
+    protected IBaseLabelProvider createLabelProvider() {
+        return new AdapterFactoryLabelProvider(getAdapterFactory());
+    }
+
+    /**
+     * Set the input of the viewer.
+     * This will be done in an UI thread, and will ensure that the viewer is still available.
+     * 
+     * @param pInput The new input to set to the viewer
+     */
+    protected void setViewerInput(final Object pInput) {
+        getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void run() {
+                if ((mViewer != null) && !mViewer.getControl().isDisposed()) {
+                    synchronized (mViewer) {
+                        mViewer.setInput(pInput);
+                    }
+                }
+            }
+        });
+    }
+
+    /**
+     * Return the initial input of the viewer.
+     * 
+     * @return The initial input of the viewer
+     */
+    protected abstract Object getInitialInput();
+
+    /**
+     * Return the resource set to associate to the editing domain.
+     * 
+     * If this method return <code>null</code>, a new resource set will be
+     * created by default during the editing domain initialisation.
+     * 
+     * @return The resource set to associate to the editing domain
+     */
+    protected abstract ResourceSet getResourceSet();
+
+    /**
+     * Return the property source provider to associate to the viewer.
+     * If no property source provider is known, create a default one.
+     * 
+     * @return Return the property source provider to associate to the viewer
+     */
+    protected IPropertySourceProvider getPropertySourceProvider() {
+        if (mPropertySourceProvider == null) {
+            mPropertySourceProvider = createPropertySourceProvider();
+        }
+        return mPropertySourceProvider;
+    }
+
+    /**
+     * Create and return a default property source provider based on the adapter factory.
+     * 
+     * @return The created property source provider
+     */
+    protected IPropertySourceProvider createPropertySourceProvider() {
+        return new PropertySourceProvider(getAdapterFactory());
+    }
+
+    /**
+     * Set the message to the status line manager based on the selection count.
+     * 
+     * @param pSelection The selection to take into account
+     */
+    protected void updateStatusBar(final ISelection pSelection) {
+
+        String vMessage = null;
+
+        // Ensure that the selection can be parsed
+        if (pSelection instanceof IStructuredSelection) {
+
+            // Get the right message, according to the number of elements in the selection
+            switch (((IStructuredSelection) pSelection).size()) {
+                case 0:
+                    vMessage = CommonUIActivator.getMessages().getString("AbstractPage.noobjectselected"); //$NON-NLS-1$
+                    break;
+
+                case 1:
+                    // Get the text corresponding to the selected object
+                    final String vSelectedObjectText = new AdapterFactoryItemDelegator(mComposedAdapterFactory)
+                        .getText(((IStructuredSelection) pSelection).getFirstElement());
+
+                    // Build the message with the text found
+                    vMessage = CommonUIActivator.getMessages().getString("AbstractPage.oneobjectselected", //$NON-NLS-1$
+                        new Object[] {vSelectedObjectText});
+                    break;
+
+                default:
+                    vMessage = CommonUIActivator.getMessages().getString("AbstractPage.multiobjectsselected", //$NON-NLS-1$
+                        new Object[] {Integer.toString(((IStructuredSelection) pSelection).size())});
+                    break;
+            }
+        }
+
+        // Finally update the status message
+        setStatusLineMessage(vMessage, false);
+    }
+
+    /**
+     * Set the message to the status line manager.
+     * It can be treated as an error message or not according to the flag given in parameter.
+     * 
+     * @param pMessage The message to set
+     * @param pIsErrorMsg <code>true</code> if the message is an error message, <code>false</code> otherwise
+     */
+    protected void setStatusLineMessage(final String pMessage, final boolean pIsErrorMsg) {
+        // Get the status line manager
+        final IStatusLineManager vStatusLineManager = getActionBars().getStatusLineManager();
+
+        if (vStatusLineManager != null) {
+            // Update the status message, with an error status or not
+            if (pIsErrorMsg) {
+                vStatusLineManager.setErrorMessage(ImageConstants.ICON_ERROR, pMessage);
+            } else {
+                vStatusLineManager.setMessage(ImageConstants.ICON_INFO, pMessage);
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * This is overridden to help to fill the context menus with contributions from the Edit menu.
+     */
+    @Override
+    public void menuAboutToShow(final IMenuManager pMenuManager) {
+        getActionBarContributor().menuAboutToShow(pMenuManager);
+    }
+
+    /**
+     * Returns the action bar contributor for this page.
+     * If no contributor is known, create a default one.
+     * 
+     * @return The page action bar contributor
+     */
+    protected ViewActionBarContributor getActionBarContributor() {
+        if (mActionBarContributor == null) {
+            mActionBarContributor = createActionBarContributor();
+            mActionBarContributor.init(getActionBars(), getSite().getPage());
+        }
+
+        return mActionBarContributor;
+    }
+
+    /**
+     * Update the action bar contributor of this page to use the given part as
+     * selection provider, and if possible also as editing domain provider.
+     * 
+     * This is mandatory to ensure that the contextual actions in the contributor
+     * are linked to a selection for their activation and their run.
+     * 
+     * @param pActivePart The part to use as selection provider and potential editing domain
+     * provider for the action bar contributor
+     */
+    public void updateActionBarContributorActivePart(final IWorkbenchPart pActivePart) {
+        // Register the new active part
+        getActionBarContributor().setActivePart(pActivePart);
+
+        // Then update the actions
+        getActionBarContributor().update();
+    }
+
+    /**
+     * Create and return a default action bar contributor.
+     * 
+     * @return The created action bar contributor
+     */
+    protected ViewActionBarContributor createActionBarContributor() {
+        return new ViewActionBarContributor();
+    }
+
+    /**
+     * Returns the action bars for this page.
+     * 
+     * @return The {@link IActionBars} of this page
+     */
+    protected IActionBars getActionBars() {
+        return getSite().getActionBars();
+    }
+
+    /**
+     * This returns the composed adapter factory associated to the viewer.
+     * 
+     * @return The composed adapter factory associated to the viewer
+     */
+    protected ComposedAdapterFactory getAdapterFactory() {
+        return mComposedAdapterFactory;
+    }
+
+    /**
+     * Add an editing domain provider adapter to the given resource.
+     * 
+     * @param pResource The resource to treat
+     */
+    private void attachAdapterForResource(final Resource pResource) {
+        // Check if an editing domain provider is already known for this resource
+        // in this case, there is nothing to do
+        if (getResourceEditingDomainProvider(pResource) == null) {
+            // Create a new editing domain provider and add it to the resource
+            final EditingDomainProvider vEditingDomainProvider = new EditingDomainProvider(mEditingDomain);
+            pResource.eAdapters().add(vEditingDomainProvider);
+        }
+    }
+
+    /**
+     * Remove the editing domain provider adapter attach to the resource
+     * if it has been added only for this page context.
+     * 
+     * @param pResource The resource to treat
+     */
+    private void detachAdapterFromResource(final Resource pResource) {
+        // Get the editing domain provider linked to the resource
+        final IEditingDomainProvider vResourceEditingDomainProvider = getResourceEditingDomainProvider(pResource);
+        if (vResourceEditingDomainProvider != null) {
+
+            // Check if the resource editing domain is the same editing domain
+            // as the one used in the page. In this case, it has been added explicitly
+            // for this page and can thus be removed
+            if (mEditingDomain.equals(vResourceEditingDomainProvider.getEditingDomain())) {
+                pResource.eAdapters().remove(vResourceEditingDomainProvider);
+            }
+        }
+    }
+
+    /**
+     * Return the editing domain provider of a given resource.
+     * 
+     * @param pResource The resource to treat
+     * @return <code>{@link IEditingDomainProvider}</code> found, or null otherwise
+     */
+    private IEditingDomainProvider getResourceEditingDomainProvider(final Resource pResource) {
+        IEditingDomainProvider vEditingDomainProvider = null;
+
+        if (pResource != null) {
+            // Get the potential existing editing domain provider
+            vEditingDomainProvider = (IEditingDomainProvider) EcoreUtil.getExistingAdapter(
+                pResource,
+                IEditingDomainProvider.class);
+        }
+
+        return vEditingDomainProvider;
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * Initialises this page with the given page site.
+     * <p>
+     * This method is automatically called by the workbench shortly after the part is instantiated. It marks the start
+     * of the page's life cycle. Clients must not call this method directly.
+     * </p>
+     * 
+     * @param pSite The page site
+     */
+    @Override
+    public void init(final IPageSite pSite) {
+        // Call the parent method
+        super.init(pSite);
+
+        // Initialise the editing domain for this page
+        initializeEditingDomain();
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * Create the controls for this page, and initialise the viewer of this page.
+     * 
+     * @param pParent The parent control
+     */
+    @Override
+    public void createControl(final Composite pParent) {
+        // Initialise the viewer
+        initializeViewer(pParent);
+
+        // Add the page styles, menus and toolbars
+        addStyles();
+        addMenuBarActions();
+        addToolBarActions();
+    }
+
+    /**
+     * This method is used to add the styles to the page : its context menu,
+     * and the mechanisms for the drag & drop, and the filters.
+     * 
+     * User must override this function to add or remove specific styles.
+     */
+    protected void addStyles() {
+        addContextMenu();
+        addDragSupport();
+        addDropSupport();
+        addFilters();
+    }
+
+    /**
+     * Initialise the viewer of this page.
+     * 
+     * @param pParent The parent composite
+     */
+    protected void initializeViewer(final Composite pParent) {
+        // Create the viewer and remember it
+        mViewer = createViewer(pParent);
+
+        // Set the viewer providers and input
+        setViewerProviders();
+        setViewerInput(getInitialInput());
+
+        // Register the fact that this page site selection is provided by the viewer
+        getSite().setSelectionProvider(mViewer);
+
+        // Finally, add the listeners (double click, etc.) on the viewer
+        addViewerListeners();
+    }
+
+    /**
+     * Set the viewer content and label providers.
+     * 
+     * This default implementation use the methods {@link AbstractPage#getLabelProvider()} and
+     * {@link AbstractPage#getContentProvider()} to find the providers to set.
+     */
+    protected void setViewerProviders() {
+        mViewer.setLabelProvider(getLabelProvider());
+        mViewer.setContentProvider(getContentProvider());
+    }
+
+    /**
+     * Adds the listeners to the viewer.
+     * This default implementation add a selection changed and a double click listeners.
+     */
+    protected void addViewerListeners() {
+        addViewerSelectionChangedListener();
+        addViewerDoubleCLickListener();
+    }
+
+    /**
+     * Adds an {@link ISelectionChangedListener} to the viewer.
+     */
+    protected void addViewerSelectionChangedListener() {
+        mViewer.addSelectionChangedListener(new ISelectionChangedListener() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void selectionChanged(final SelectionChangedEvent pEvent) {
+                handleSelectionChanged(pEvent);
+            }
+        });
+    }
+
+    /**
+     * Adds an {@link IDoubleClickListener} to the viewer.
+     */
+    protected void addViewerDoubleCLickListener() {
+        mViewer.addDoubleClickListener(new IDoubleClickListener() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void doubleClick(final DoubleClickEvent pEvent) {
+
+                // Use an asynchronous UI thread to treat the double click event
+                mViewer.getControl().getDisplay().asyncExec(new Runnable() {
+
+                    /**
+                     * {@inheritDoc}
+                     */
+                    @Override
+                    public void run() {
+                        // Ensure that the viewer is still available
+                        if (mViewer != null && !mViewer.getControl().isDisposed()) {
+                            handleDoubleClick(pEvent);
+                        }
+                    }
+                });
+            }
+        });
+    }
+
+    /**
+     * Called when a double click is made in the viewer.
+     * This method does nothing by default.
+     * 
+     * @param pEvent The {@link DoubleClickEvent}.
+     */
+    protected void handleDoubleClick(final DoubleClickEvent pEvent) {
+        // Nothing to do
+    }
+
+    /**
+     * Called when the selection changed in the viewer.
+     * This method update the status bar message by default.
+     * 
+     * @param pEvent The {@link ISelectionChangedListener}.
+     */
+    protected void handleSelectionChanged(final SelectionChangedEvent pEvent) {
+        updateStatusBar(pEvent.getSelection());
+    }
+
+    /**
+     * Create the viewer.
+     * This method is abstract as each child will create its own kind of viewer.
+     * 
+     * @param pParent The composite parent
+     * @return The created viewer
+     */
+    protected abstract StructuredViewer createViewer(Composite pParent);
+
+    /**
+     * Refresh the viewer.
+     */
+    protected void refreshViewer() {
+        // Use an asynchronous UI thread to refresh the viewer
+        getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void run() {
+                // Ensure that the viewer is still available
+                if (mViewer != null && !mViewer.getControl().isDisposed()) {
+                    synchronized (mViewer) {
+                        mViewer.refresh();
+                    }
+                }
+            }
+        });
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * Asks this page to take focus within the workbench.
+     * Page must assign focus to one of the controls contained in
+     * the part's parent composite.
+     * 
+     * In our case, set the focus to the viewer control by default.
+     */
+    @Override
+    public void setFocus() {
+        // Ensure that the viewer is still available
+        if (mViewer != null && !mViewer.getControl().isDisposed()) {
+            mViewer.getControl().setFocus();
+        }
+    }
+
+    /**
+     * Add an action in the menu bar.
+     * 
+     * @param pAction The action to add
+     */
+    protected void addMenuBarAction(final IAction pAction) {
+        getActionBars().getMenuManager().add(pAction);
+    }
+
+    /**
+     * Add an action in the tool bar.
+     * 
+     * @param pAction The action to add
+     */
+    protected void addToolBarAction(final IAction pAction) {
+        getActionBars().getToolBarManager().add(pAction);
+    }
+
+    /**
+     * Add a sub-menu to the menu bar.
+     * 
+     * @param pMenuManager The menu manager to add
+     */
+    protected void addMenuBarSubMenu(final IMenuManager pMenuManager) {
+        getActionBars().getMenuManager().add(pMenuManager);
+    }
+
+    /**
+     * Add a separator to the menu bar.
+     */
+    protected void addMenuBarSeparator() {
+        getActionBars().getMenuManager().add(new Separator());
+    }
+
+    /**
+     * Add a separator to the tool bar.
+     */
+    protected void addToolBarSeparator() {
+        getActionBars().getToolBarManager().add(new Separator());
+    }
+
+    /**
+     * Add the filters returned by {@link #getFilters()} to the viewer.
+     */
+    protected void addFilters() {
+        for (AbstractFilter vFilter : getFilters()) {
+            mViewer.addFilter(vFilter);
+        }
+    }
+
+    /**
+     * Called when the filter text changed, to be able to react.
+     * 
+     * @param pNewFilterText The new filter text to take into account
+     */
+    public void filterTextChanged(final String pNewFilterText) {
+        // Ensure that the viewer is still available
+        if (mViewer != null && !mViewer.getControl().isDisposed()) {
+
+            // Loop on the registered filters to apply the new text
+            for (final ViewerFilter vViewerFilter : mViewer.getFilters()) {
+                if (vViewerFilter instanceof AbstractFilter) {
+                    ((AbstractFilter) vViewerFilter).setFilter(pNewFilterText);
+                }
+            }
+
+            // Finally refresh the viewer content
+            refreshViewer();
+        }
+    }
+
+    /**
+     * Return the filters that will be associated to the viewer by {@link #addFilters()}.
+     * By default, this returns a table of filters containing a new {@link NamePropertyFilter} filter.
+     * 
+     * @return The table of filters to associate to the viewer
+     */
+    protected AbstractFilter[] getFilters() {
+        return new AbstractFilter[] {new NamePropertyFilter()};
+    }
+
+    /**
+     * Add actions to the menu bar.
+     * 
+     * By default, this method doesn't add any actions, it's only update the menu bar. User can override
+     * this method to add actions to the menu bar. User can call at the end of the overriding method
+     * super {@link #addMenuBarActions()} to update the menu bar.
+     */
+    protected void addMenuBarActions() {
+        getActionBars().getMenuManager().update(true);
+    }
+
+    /**
+     * Add actions to the tool bar.
+     * 
+     * By default, this method doesn't add any actions, it's only update the tool bar. User can override
+     * this method to add actions to the tool bar. User can call at the end of the overriding method
+     * super {@link #addToolBarActions()} to update the tool bar.
+     */
+    protected void addToolBarActions() {
+        getActionBars().getToolBarManager().update(true);
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractTreePage.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractTreePage.java
new file mode 100644
index 0000000..ea876ba
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractTreePage.java
@@ -0,0 +1,371 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.view;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.jface.action.Action;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.jface.viewers.ColumnLabelProvider;
+import org.eclipse.jface.viewers.DoubleClickEvent;
+import org.eclipse.jface.viewers.EditingSupport;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.jface.viewers.TreeViewerColumn;
+import org.eclipse.jface.viewers.ViewerColumn;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.TreeColumn;
+import org.eclipse.ui.handlers.CollapseAllHandler;
+import org.eclipse.ui.handlers.ExpandAllHandler;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+import org.polarsys.esf.core.common.ui.CommonUIActivator.Implementation;
+
+/**
+ * Abstract base of all the Pages to use in a PageBookView,
+ * and which includes a tree.
+ * 
+ * This implementation doesn't manage the columns in the tree,
+ * but it inherits of all the standard mechanisms like the filters, the editing domain mechanisms, etc.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public abstract class AbstractTreePage
+    extends AbstractColumnViewerPage {
+
+    /**
+     * Default constructor, which allows to specify if the viewer must be read only or not.
+     * 
+     * @param pReadOnlyMode <code>true</code> if this view is in read only mode, <code>false</code> otherwise
+     */
+    public AbstractTreePage(final boolean pReadOnlyMode) {
+        super(pReadOnlyMode);
+    }
+    
+    /**
+     * Advanced constructor which takes the name of the required column, an array with the optional columns name,
+     * and a boolean which specifies if the viewer must be in read only mode or not.
+     * 
+     * The required column will mandatory be visible and can't be hidden. 
+     * 
+     * @param pRequiredColumnName The name of the required column name
+     * @param pColumnsName The array of optional columns name. This list must not contain the required column name
+     * @param pReadOnlyMode <code>true</code> if this view is in read only mode, <code>false</code> otherwise
+     */
+    public AbstractTreePage(
+        final String pRequiredColumnName, 
+        final String[] pColumnsName, 
+        final boolean pReadOnlyMode) {
+        super(pRequiredColumnName, pColumnsName, pReadOnlyMode);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected TreeViewer createViewer(final Composite pParent) {
+        return new TreeViewer(pParent, SWT.MULTI);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public TreeViewer getViewer() {
+        return (TreeViewer) super.getViewer();
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * Overridden to expand or collapse the current element on which
+     * the double click is performed.
+     */
+    @Override
+    protected void handleDoubleClick(final DoubleClickEvent pEvent) {
+        // Get the element on which the double click is performed
+        final IStructuredSelection vSelection = (IStructuredSelection) pEvent.getSelection();
+        final Object vSelectedeElement = vSelection.getFirstElement();
+        
+        // If the element is expandable, change is expand state
+        if (getViewer().isExpandable(vSelectedeElement)) {
+            getViewer().setExpandedState(vSelectedeElement, !getViewer().getExpandedState(vSelectedeElement));
+        }
+    }
+
+    /**
+     * Create the expand all action.
+     * 
+     * @return The expand all action created
+     */
+    protected IAction createExpandAllAction() {
+        // Get the action image
+        final ImageDescriptor vImageDescriptor = 
+            CommonUIActivator.getPlugin().getImageRegistry().getDescriptor(
+                Implementation.ICON_EXPAND_ALL_KEY);
+        
+        // Get the action label
+        final String vActionLabel = 
+            CommonUIActivator.getMessages().getString("AbstractTreePage.action.expandall"); //$NON-NLS-1$ 
+            
+        // Create the action
+        final IAction vExpandAllAction = new Action(vActionLabel, vImageDescriptor) {
+
+            /**
+             * {@inheritDoc} 
+             */
+            @Override
+            public void run() {
+                // Prepare the expand action asynchronously, on the UI thread
+                AbstractTreePage.this.getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                    /**
+                     * {@inheritDoc} 
+                     */
+                    @Override
+                    public void run() {
+                        // Create the action handler on the viewer
+                        final ExpandAllHandler vExpandAllHandler = 
+                            new ExpandAllHandler(AbstractTreePage.this.getViewer());
+                        
+                        // And finally execute it
+                        vExpandAllHandler.execute(null);
+                    }
+                });
+            }
+        };
+        
+        return vExpandAllAction;
+    }
+
+    /**
+     * Create the collapse all action.
+     * 
+     * @return The collapse all action created
+     */
+    protected IAction createCollapseAllAction() {
+        // Get the action image
+        final ImageDescriptor vImageDescriptor = 
+            CommonUIActivator.getPlugin().getImageRegistry().getDescriptor(
+                Implementation.ICON_COLLAPSE_ALL_KEY);
+        
+        // Get the action label
+        final String vActionLabel = 
+            CommonUIActivator.getMessages().getString("AbstractTreePage.action.collapseall"); //$NON-NLS-1$ 
+            
+        // Create the action
+        final IAction vCollapseAllAction = new Action(vActionLabel, vImageDescriptor) { 
+
+            /**
+             * {@inheritDoc} 
+             */
+            @Override
+            public void run() {
+                // Prepare the collapse action asynchronously, on the UI thread
+                AbstractTreePage.this.getSite().getShell().getDisplay().asyncExec(new Runnable() {
+
+                    /**
+                     * {@inheritDoc} 
+                     */
+                    @Override
+                    public void run() {
+                        // Create the action handler on the viewer
+                        final CollapseAllHandler vCollapseAllHandler = 
+                            new CollapseAllHandler(AbstractTreePage.this.getViewer());
+                        
+                        // And finally execute it
+                        vCollapseAllHandler.execute(null);
+                    }
+                });
+            }
+        };
+        
+        return vCollapseAllAction;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setLinesVisible(final boolean pShow) {
+        getViewer().getTree().setLinesVisible(pShow);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setHeaderVisible(final boolean pShow) {
+        getViewer().getTree().setHeaderVisible(pShow);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected boolean isViewerHeaderInitiallyVisible() {
+        return getViewer().getTree().getHeaderVisible();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected boolean isViewerLinesInitiallyVisible() {
+        return getViewer().getTree().getLinesVisible();
+    }
+    
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected boolean hideColumn(final String pColumnName) {
+        
+        boolean vColumnHidden = false;
+        
+        // Try to find the column by its name
+        final TreeColumn vColumn = getColumn(pColumnName);
+        
+        // If the column is found, dispose it
+        if (vColumn != null) {
+            vColumn.dispose();
+            
+            // Remember that the column was hidden
+            vColumnHidden = true;
+        }
+        
+        return vColumnHidden;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected boolean isColumnVisible(final String pColumnName) {
+        return getColumn(pColumnName) != null;
+    }
+
+    /**
+     * Find and return an existing column in the tree viewer from its name.
+     * 
+     * @param pColumnName The name of the column to find
+     * @return The column found if any, and <code>null</code> otherwise
+     */
+    protected TreeColumn getColumn(final String pColumnName) {
+        
+        TreeColumn vColumnFound = null;
+        
+        // Check if the searched name is valid
+        if (StringUtils.isNotEmpty(pColumnName)) {
+            
+            // Get an iterator on the list of existing columns in the tree viewer
+            final TreeColumn[] vColumnsArray = getViewer().getTree().getColumns();
+            
+            // Loop on the columns array until the column is found
+            for (int i = 0; i < vColumnsArray.length && vColumnFound == null; i++) {
+                TreeColumn vTreeColumn = vColumnsArray[i];
+                
+                if (vTreeColumn.getText().equals(pColumnName)) {
+                    vColumnFound = vTreeColumn;
+                }
+            }
+        }
+        
+        return vColumnFound;
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * This is customised to add the expand all and collapse all actions. 
+     */
+    @Override
+    protected void addToolBarActions() {
+        addExpandAllAction();
+        addCollapseAllAction();
+        super.addToolBarActions();
+    }
+
+    /**
+     * Add to the toolbar the action to expand all the tree content.
+     */
+    protected void addExpandAllAction() {
+        addToolBarAction(createExpandAllAction());
+    }
+
+    /**
+     * Add to the toolbar the action to collapse all the tree content.
+     */
+    protected void addCollapseAllAction() {
+        addToolBarAction(createCollapseAllAction());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected TreeViewerColumn createRequiredViewerColumn() {
+        // Nothing to do as this implementation doesn't manage multiple columns
+        return null;
+    }
+    
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected ViewerColumn createViewerColumn(final String pColumnName) {
+        // Nothing to do as this implementation doesn't manage multiple columns
+        return null;
+    }
+    
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected ViewerColumn createViewerColumn(final String pColumnName, final int pIndex) {
+        // Nothing to do as this implementation doesn't manage multiple columns
+        return null;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected ViewerColumn createViewerColumn(
+        final String pColumnName, 
+        final ColumnLabelProvider pColumnLabelProvider) {
+        // Nothing to do as this implementation doesn't manage multiple columns
+        return null;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected ViewerColumn createViewerColumn(
+        final String pColumnName,
+        final ColumnLabelProvider pColumnLabelProvider,
+        final EditingSupport pEditingSupport) {
+        // Nothing to do as this implementation doesn't manage multiple columns
+        return null;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected ViewerColumn createViewerColumn(final String pColumnName, final String pPropertyID) {
+        // Nothing to do as this implementation doesn't manage multiple columns
+        return null;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractTreeTablePage.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractTreeTablePage.java
new file mode 100644
index 0000000..bfd5e3e
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/AbstractTreeTablePage.java
@@ -0,0 +1,166 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.view;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.jface.viewers.ColumnLabelProvider;
+import org.eclipse.jface.viewers.EditingSupport;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.jface.viewers.TreeViewerColumn;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.ui.views.properties.PropertyColumnLabelProvider;
+import org.polarsys.esf.core.common.ui.editingsupport.ValidatedPropertyEditingSupport;
+
+/**
+ * Abstract base of all the Pages to use in a PageBookView,
+ * and which contains a tree table as viewer.
+ * 
+ * This page inherits of all the standard mechanisms like the filters, the editing domain mechanisms, etc.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public abstract class AbstractTreeTablePage
+    extends AbstractTreePage {
+
+    /**
+     * A constructor that takes the array of columns name to create in the tree table. 
+     * This constructor is used in the case of adding of the columns visibility action.
+     * 
+     * @param pRequiredColumnName The name of the required column name that can't be hidden
+     * @param pColumnsName The column names list. This list must not contain the requiredColumnName
+     * @param pReadOnlyMode <code>true</code>if this view is in mode read only <code>false</code> otherwise
+     */
+    public AbstractTreeTablePage(
+        final String pRequiredColumnName,
+        final String[] pColumnsName,
+        final boolean pReadOnlyMode) {
+        super(pRequiredColumnName, pColumnsName, pReadOnlyMode);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected TreeViewerColumn createRequiredViewerColumn() {
+        // Get the name of the required column
+        String vColumnName = getRequiredColumnName();
+        
+        // If the name is not valid, set a default empty value
+        if (StringUtils.isEmpty(vColumnName)) {
+            vColumnName = StringUtils.EMPTY;
+        }
+        
+        // Create the required column at the beginning, and set its width
+        final TreeViewerColumn vTreeViewerColumn = createViewerColumn(vColumnName, 0);
+        vTreeViewerColumn.getColumn().setWidth(150);
+        
+        return vTreeViewerColumn;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected TreeViewer createViewer(final Composite pParent) {
+        
+        // Create a tree viewer allowing multiple selection 
+        final TreeViewer vTreeViewer = new TreeViewer(pParent, SWT.MULTI | SWT.FULL_SELECTION);
+
+        // Set the tree lines and header visible
+        // NB : Don't call directly the methods 'setLinesVisible' and 'setHeaderVisible' 
+        //      of this instance as the tree is not already created and initialised 
+        vTreeViewer.getTree().setLinesVisible(true);
+        vTreeViewer.getTree().setHeaderVisible(true);
+        return vTreeViewer;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected TreeViewerColumn createViewerColumn(final String pColumnName, final int pIndex) {
+        
+        // Create a new column at the given index
+        final TreeViewerColumn vTreeViewerColumn = new TreeViewerColumn(getViewer(), SWT.LEFT, pIndex);
+        vTreeViewerColumn.getColumn().setText(pColumnName);
+        vTreeViewerColumn.getColumn().pack();
+        
+        return vTreeViewerColumn;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected TreeViewerColumn createViewerColumn(final String pColumnName) {
+        return createViewerColumn(pColumnName, getViewer().getTree().getColumnCount());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected TreeViewerColumn createViewerColumn(
+        final String pColumnName, 
+        final ColumnLabelProvider pColumnLabelProvider) {
+        
+        // Create a new column
+        final TreeViewerColumn vTreeViewerColumn = createViewerColumn(pColumnName);
+        
+        // Set the column label provider with the instance given in parameter
+        vTreeViewerColumn.setLabelProvider(pColumnLabelProvider);
+        
+        return vTreeViewerColumn;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected TreeViewerColumn createViewerColumn(
+        final String pColumnName,
+        final ColumnLabelProvider pColumnLabelProvider,
+        final EditingSupport pEditingSupport) {
+        
+        // Create a new column
+        final TreeViewerColumn vTreeViewerColumn = createViewerColumn(pColumnName);
+        
+        // Set the column label provider and editing support
+        // with the instance given in parameter
+        vTreeViewerColumn.setLabelProvider(pColumnLabelProvider);
+        vTreeViewerColumn.setEditingSupport(pEditingSupport);
+        return vTreeViewerColumn;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected TreeViewerColumn createViewerColumn(final String pColumnName, final String pPropertyID) {
+        
+        // Create a new column
+        final TreeViewerColumn vTreeViewerColumn = createViewerColumn(pColumnName);
+        
+        // Set the column label provider and editing support based on the property whose
+        // id is given in parameter
+        vTreeViewerColumn.setLabelProvider(new PropertyColumnLabelProvider(getPropertySourceProvider(), pPropertyID));
+        vTreeViewerColumn.setEditingSupport(
+            new ValidatedPropertyEditingSupport(
+                getViewer(), 
+                getPropertySourceProvider(), 
+                pPropertyID,
+                getActionBars().getStatusLineManager()));
+        
+        return vTreeViewerColumn;
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/ArrayInputPropertySourceProvider.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/ArrayInputPropertySourceProvider.java
new file mode 100644
index 0000000..d18963b
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/ArrayInputPropertySourceProvider.java
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.view.properties;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+
+/**
+ * Property source provider used to work with an array as input element.
+ * 
+ * It extends {@link PropertySourceProvider} to be able to work also on generic.
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class ArrayInputPropertySourceProvider
+    extends PropertySourceProvider {
+
+    /**
+     * Default constructor.
+     * 
+     * @param pAdapterFactory The adapter factory
+     */
+    public ArrayInputPropertySourceProvider(final AdapterFactory pAdapterFactory) {
+        super(pAdapterFactory);
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * This method is overridden to be able to manage the arrays as input element.
+     */
+    @Override
+    public Object[] getElements(final Object pInputElement) {
+        Object[] vElementsArray = new Object[] {};
+
+        // Check if the input element is an array
+        if (pInputElement instanceof Object[]) {
+            // If the input is an array, loop on each input object in it
+            // to get its corresponding elements
+            final List<Object> vElementsList = new ArrayList<Object>();
+            for (final Object vInputElement : (Object[]) pInputElement) {
+                vElementsList.addAll(Arrays.asList(super.getElements(vInputElement)));
+            }
+
+            // Build the final elements array from the list
+            if (!vElementsList.isEmpty()) {
+                vElementsArray = vElementsList.toArray(new Object[vElementsList.size()]);
+            }
+
+        } else {
+            // If the input is a single object, get its element by calling the parent method
+            vElementsArray = super.getElements(pInputElement);
+        }
+
+        return vElementsArray;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/ExtendedPropertyDescriptor.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/ExtendedPropertyDescriptor.java
new file mode 100644
index 0000000..7083eba
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/ExtendedPropertyDescriptor.java
@@ -0,0 +1,255 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.view.properties;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.emf.common.ui.celleditor.ExtendedComboBoxCellEditor;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.EcorePackage;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.ui.provider.PropertyDescriptor;
+import org.eclipse.jface.viewers.CellEditor;
+import org.eclipse.swt.custom.CCombo;
+import org.eclipse.swt.widgets.Composite;
+
+/**
+ * This class is a {@link PropertyDescriptor} that manage the Java Generic.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class ExtendedPropertyDescriptor
+    extends PropertyDescriptor {
+
+    /**
+     * Default constructor.
+     * 
+     * @param pObject The object
+     * @param pItemPropertyDescriptor The property descriptor {@link IItemPropertyDescriptor}
+     */
+    public ExtendedPropertyDescriptor(final Object pObject, final IItemPropertyDescriptor pItemPropertyDescriptor) {
+        super(pObject, pItemPropertyDescriptor);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public CellEditor createPropertyEditor(final Composite pComposite) {
+
+        // Initialise with
+        CellEditor vCellEditor = null;
+
+        if (itemPropertyDescriptor.canSetProperty(object)) {
+
+            // Specific case of EStructuralFeature
+            if (object instanceof EObject) {
+
+                // Get feature of object
+                final EObject vObject = (EObject) object;
+                final Object vGenericFeature = itemPropertyDescriptor.getFeature(object);
+
+                if (vGenericFeature instanceof EStructuralFeature) {
+
+                    if (getPropertyValue(itemPropertyDescriptor, vObject) instanceof Boolean) {
+
+                        vCellEditor = handleEStructuralFeature(pComposite);
+                    }
+                }
+
+            }
+
+            // Default
+            if (vCellEditor == null) {
+                // Get cell editor from ancestor
+                vCellEditor = super.createPropertyEditor(pComposite);
+            }
+        }
+
+        return vCellEditor;
+    }
+
+    /**
+     * Handle boolean EStructuralFeature dialog property view.
+     * 
+     * @param pComposite Parent composite
+     * @return Cell editor with java generic type
+     */
+    private CellEditor handleEStructuralFeature(final Composite pComposite) {
+
+        // Create dialog with Java generic values for boolean type
+        CellEditor vCellEditor = new ExtendedComboBoxCellEditor(pComposite, Arrays.asList(new Object[] {
+            Boolean.FALSE,
+            Boolean.TRUE}), getEditLabelProvider(), itemPropertyDescriptor.isSortChoices(object)) {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            protected void refreshItems(final String pFilter) {
+                CCombo vCombo = (CCombo) getControl();
+                if (vCombo != null && !vCombo.isDisposed()) {
+                    List<Object> vOriginalList = new ArrayList<Object>(originalList);
+                    String[] vItemsArray = createItems(vOriginalList, labelProvider, pFilter, sorted);
+                    if (!vOriginalList.isEmpty() && !vOriginalList.equals(list)) {
+                        Object vPreviousValue = getValue();
+                        list = vOriginalList;
+                        vCombo.setItems(vItemsArray);
+                        if (list.contains(vPreviousValue)) {
+                            setValue(vPreviousValue);
+                        } else if (!list.isEmpty()) {
+                            setValue(list.get(0));
+                        }
+                    }
+                }
+            }
+        };
+        return vCellEditor;
+    }
+
+    /**
+     * Retrieve the property value thanks to the given {@link IItemPropertyDescriptor}.
+     * 
+     * @param pPropertyDescriptor The given {@link IItemPropertyDescriptor}.
+     * @param pObject The value to retrieve
+     * @return A property value
+     */
+    protected Object getPropertyValue(final IItemPropertyDescriptor pPropertyDescriptor, final Object pObject) {
+
+        Object vPropertyValue = null;
+
+        // Verify if descriptor is null
+        if (pPropertyDescriptor != null) {
+            // Get property value for descriptor
+            vPropertyValue = pPropertyDescriptor.getPropertyValue(pObject);
+
+            // If value is ItemPropertySource
+            if (vPropertyValue instanceof IItemPropertySource) {
+                // Get editable value
+                vPropertyValue = ((IItemPropertySource) vPropertyValue).getEditableValue(pObject);
+            }
+
+        }
+        return vPropertyValue;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected CellEditor createEDataTypeCellEditor(final EDataType pEDataType, final Composite pComposite) {
+
+        CellEditor vCellEditor = null;
+
+        // Verify if it is EAttribute
+        if (!itemPropertyDescriptor.isMultiLine(object)) {
+
+            final Object vGenericFeature = itemPropertyDescriptor.getFeature(object);
+
+            if (vGenericFeature instanceof EAttribute) {
+                EAttribute vEAttribute = (EAttribute) vGenericFeature;
+                if (vEAttribute.getEType() instanceof EDataType) {
+                    EDataType vEAttributeDataType = (EDataType) vEAttribute.getEType();
+
+                    if (vEAttributeDataType.equals(EcorePackage.eINSTANCE.getEJavaObject())) {
+                        // If EDataType is an instance of EJavaObject
+                        // handle java generic type
+                        vCellEditor = handleGenericTypeValue(pComposite);
+
+                    }
+                }
+            }
+        }
+
+        if (vCellEditor == null) {
+            // Get editor from ancestor
+            vCellEditor = super.createEDataTypeCellEditor(pEDataType, pComposite);
+        }
+
+        return vCellEditor;
+    }
+
+    /**
+     * Handle Java generic type to instantiate correct cell editor.
+     * 
+     * @param pComposite Parent composite
+     * @return Cell editor according to Java generic type
+     */
+    private CellEditor handleGenericTypeValue(final Composite pComposite) {
+        EObject vEObject = (EObject) object;
+        Object vValue = getPropertyValue(itemPropertyDescriptor, vEObject);
+
+        // Initialise with current value of cell editor
+        CellEditor vCellEditor = null;
+        EDataType vEDataType = null;
+
+        // Verify generic type to determine data type
+        if (vValue instanceof Integer) {
+            vEDataType = EcorePackage.eINSTANCE.getEIntegerObject();
+        } else if (vValue instanceof Double) {
+            vEDataType = EcorePackage.eINSTANCE.getEDoubleObject();
+        } else if (vValue instanceof String) {
+            vEDataType = EcorePackage.eINSTANCE.getEString();
+        }
+
+        // Create with determined data type
+        if (vEDataType != null) {
+            vCellEditor = new ExtendedEDataTypeCellEditor(
+                vEDataType,
+                pComposite);
+        }
+
+        return vCellEditor;
+    }
+
+    /**
+     * This class is an {@link EDataTypeCellEditor} that manage the java Generic.
+     */
+    protected static class ExtendedEDataTypeCellEditor
+        extends EDataTypeCellEditor {
+
+        /**
+         * Default constructor.
+         * 
+         * @param pEDataType The {@link EDataType}
+         * @param pParent The parent composite
+         */
+        public ExtendedEDataTypeCellEditor(final EDataType pEDataType, final Composite pParent) {
+            super(pEDataType, pParent);
+            valueHandler = new EDataTypeValueHandler(pEDataType) {
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public String toString(final Object pValue) {
+                    String vStringValue = StringUtils.EMPTY;
+
+                    if (pValue != null) {
+                        vStringValue = super.toString(pValue);
+                    }
+
+                    return vStringValue;
+
+                }
+            };
+            setValidator(valueHandler);
+        }
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/ExtendedPropertySource.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/ExtendedPropertySource.java
new file mode 100644
index 0000000..305a7e9
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/ExtendedPropertySource.java
@@ -0,0 +1,62 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.view.properties;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.ui.provider.PropertySource;
+import org.eclipse.ui.views.properties.IPropertyDescriptor;
+
+/**
+ * This class is a {@link PropertySource} that manages the Java Generic.
+ *
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class ExtendedPropertySource
+    extends PropertySource {
+
+    /**
+     * Default constructor.
+     * An instance is constructed from an object and its item property source.
+     *
+     * @param pObject The object
+     * @param pItemPropertySource The item property source
+     */
+    public ExtendedPropertySource(final Object pObject, final IItemPropertySource pItemPropertySource) {
+        super(pObject, pItemPropertySource);
+    }
+
+    /**
+     * Create and return an {@link IPropertyDescriptor}.
+     *
+     * @param pItemPropertyDescriptor The item property descriptor
+     * @return The created {@link IPropertyDescriptor}
+     * @see #createPropertyDescriptor(Object, IItemPropertyDescriptor)
+     */
+    @Override
+    protected IPropertyDescriptor createPropertyDescriptor(final IItemPropertyDescriptor pItemPropertyDescriptor) {
+        return createPropertyDescriptor(object, pItemPropertyDescriptor);
+    }
+
+    /**
+     * Create and return the property descriptor {@link IItemPropertyDescriptor} of an object.
+     *
+     * @param pObject The object
+     * @param pItemPropertyDescriptor The item property descriptor
+     * @return An {@link ExtendedPropertyDescriptor} descriptor of an object
+     */
+    protected IPropertyDescriptor createPropertyDescriptor(
+        final Object pObject,
+        final IItemPropertyDescriptor pItemPropertyDescriptor) {
+        return new ExtendedPropertyDescriptor(pObject, pItemPropertyDescriptor);
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/PropertySourceProvider.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/PropertySourceProvider.java
new file mode 100644
index 0000000..6da7581
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/view/properties/PropertySourceProvider.java
@@ -0,0 +1,60 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.view.properties;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.edit.provider.IChangeNotifier;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
+import org.eclipse.ui.views.properties.IPropertySource;
+
+/**
+ * This class is a {@link org.eclipse.ui.views.properties.IPropertySourceProvider} that manage the Generic.
+ * This class give data for display in :
+ * <ul>
+ * <li>Properties View instancing correct {@link IPropertySource} according to {@link ItemPropertyDescriptor}</li>
+ * <li>Tree Viewer</li>
+ * </ul>
+ *
+ *
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class PropertySourceProvider
+    extends AdapterFactoryContentProvider {
+
+    /**
+     * This constructs an instance that wraps this factory. The factory should yield adapters that implement the various
+     * IItemContentProvider interfaces. If the adapter factory is an {@link IChangeNotifier}, a listener is added to it,
+     * so it's important to call {@link #dispose()}.
+     *
+     * @param pAdapterFactory The adapter factory
+     */
+    public PropertySourceProvider(final AdapterFactory pAdapterFactory) {
+        super(pAdapterFactory);
+    }
+
+    /**
+     * Create and return an instance of {@link ExtendedPropertySource}.
+     *
+     * @param pObject Object to display in property view
+     * @param pItemPropertySource Delegated implementation
+     * @return The created {@link ExtendedPropertySource}
+     */
+    @Override
+    protected IPropertySource createPropertySource(
+        final Object pObject,
+        final IItemPropertySource pItemPropertySource) {
+
+        return new ExtendedPropertySource(pObject, pItemPropertySource);
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/ActiveProjectControlContribution.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/ActiveProjectControlContribution.java
new file mode 100644
index 0000000..b7ac639
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/ActiveProjectControlContribution.java
@@ -0,0 +1,312 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.widget;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.emf.common.ui.URIEditorInput;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IFileEditorInput;
+import org.eclipse.ui.IPartListener;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.ide.IDE.SharedImages;
+import org.eclipse.ui.menus.WorkbenchWindowControlContribution;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+
+/**
+ * Control contribution used to display the current active project
+ * according to the active editor.
+ *
+ * This is made to ease user work, by displaying directly on which project he is working.
+ *
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class ActiveProjectControlContribution
+    extends WorkbenchWindowControlContribution
+    implements IPartListener {
+
+    /** The default label for the active project name. */
+    private static final String DEFAULT_PROJECT_NAME = CommonUIActivator.getMessages().getString(
+        "ActiveProjectControlContribution.default.projectname"); //$NON-NLS-1$
+
+    /** The composite containing all the widgets used to display the active project name. */
+    private ActiveProjectComposite mActiveProjectComposite = null;
+
+    /** The last editor activated and used to get the active project name. */
+    private IEditorPart mActiveEditorPart = null;
+
+    /**
+     * Default constructor.
+     */
+    public ActiveProjectControlContribution() {
+        // Register this new instance as part listener
+        PlatformUI.getWorkbench().getActiveWorkbenchWindow().getPartService().addPartListener(this);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * When the control contribution is disposed, removed it from the part listeners.
+     */
+    @Override
+    public void dispose() {
+        // Unregister the instance from the part listeners
+        IWorkbenchWindow vWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
+        if (vWorkbenchWindow != null) {
+            vWorkbenchWindow.getPartService().removePartListener(this);
+        }
+
+        // Call the parent method
+        super.dispose();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected Control createControl(final Composite pParent) {
+        // Create a new composite containing all the widgets to display for the active project
+        mActiveProjectComposite = new ActiveProjectComposite(pParent);
+
+        return mActiveProjectComposite;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void partActivated(final IWorkbenchPart pPart) {
+        // Ensure that the activated part is an editor
+        if (pPart instanceof IEditorPart) {
+
+            // Remember of the active editor
+            mActiveEditorPart = (IEditorPart) pPart;
+
+            // Get the editor input
+            IEditorInput vEditorInput = mActiveEditorPart.getEditorInput();
+
+            // Check the type of the editor input to find the file used as input
+            IFile vFileInput = null;
+            if (vEditorInput instanceof IFileEditorInput) {
+                // For a file editor input, get directly the file object
+                vFileInput = ((IFileEditorInput) vEditorInput).getFile();
+
+            } else if (vEditorInput instanceof URIEditorInput) {
+                // For an URI editor input, get the file object by looking for in
+                // the workspace content, the file which corresponds to the given URI
+
+                // ... Build the file path from the URI
+                IPath vFilePath = new Path(((URIEditorInput) vEditorInput).getURI().toPlatformString(true));
+
+                // ... Try to find the file from the build path, in the workspace content
+                vFileInput = ResourcesPlugin.getWorkspace().getRoot().getFile(vFilePath);
+            }
+
+            // Finally, if the input file is found, try to get its parent project name
+            // to update the controls value
+            if (vFileInput != null && vFileInput.getProject() != null) {
+                mActiveProjectComposite.updateActiveProjectControls(vFileInput.getProject().getName());
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Treat this event as a part activation.
+     * Otherwise, nothing is done by default.
+     */
+    @Override
+    public void partBroughtToTop(final IWorkbenchPart pPart) {
+        partActivated(pPart);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void partClosed(final IWorkbenchPart pPart) {
+        // If the last active editor used is the one which is closed,
+        // then reset the controls content to the default value
+        if (pPart.equals(mActiveEditorPart)) {
+            mActiveProjectComposite.updateActiveProjectControls(null);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void partDeactivated(final IWorkbenchPart pPart) {
+        // Nothing to do
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void partOpened(final IWorkbenchPart pPart) {
+        // Nothing to do
+    }
+
+    /**
+     * Composite which contains all the widgets used to display the current project.
+     */
+    private class ActiveProjectComposite
+        extends Composite {
+
+        /** The preferred width for the composite. */
+        private static final int CONTROL_WIDTH = 250;
+
+        /** The preferred height for the composite. */
+        private static final int CONTROL_HEIGHT = 17;
+
+        /** The text used to display the active project name. */
+        private Text mActiveProjectNameText = null;
+
+        /** The introduction label. */
+        private Label mActiveProjectNameLabel = null;
+
+        /** The opened project image. */
+        private final Image mOpenedProjectImage = PlatformUI.getWorkbench().getSharedImages()
+            .getImage(SharedImages.IMG_OBJ_PROJECT);
+
+        /** The closed project image. */
+        private final Image mClosedProjectImage = PlatformUI.getWorkbench().getSharedImages()
+            .getImage(SharedImages.IMG_OBJ_PROJECT_CLOSED);
+
+        /**
+         * Default constructor.
+         *
+         * @param pParent The parent composite
+         */
+        public ActiveProjectComposite(final Composite pParent) {
+            // Call the parent method
+            super(pParent, SWT.FLAT);
+
+            // Create all the content of the composite
+            createContent(pParent);
+        }
+
+        /**
+         * Create all the widget to include in this composite instance.
+         *
+         * @param pParent The parent composite
+         */
+        private void createContent(final Composite pParent) {
+            // Prepare and set this instance layout and layout data
+            final GridLayout vLayout = new GridLayout();
+            vLayout.marginHeight = 0;
+            vLayout.marginWidth = 1;
+            setLayout(vLayout);
+            setFont(pParent.getFont());
+
+            // Create a child composite and set its layout and display properties
+            final Composite vChildComposite = new Composite(this, SWT.BORDER);
+            vChildComposite.setBackground(getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
+            final GridLayout vChildLayout = new GridLayout(3, false);
+            vChildLayout.marginHeight = 0;
+            vChildLayout.marginWidth = 0;
+            vChildComposite.setLayout(vChildLayout);
+            GridData vGridData = new GridData(SWT.FILL, SWT.BEGINNING, true, false);
+            vGridData.widthHint = CONTROL_WIDTH;
+            vChildComposite.setLayoutData(vGridData);
+            vChildComposite.setFont(pParent.getFont());
+
+            // Create the widgets needed
+            createActiveProjectLabel(vChildComposite);
+            createActiveProjectText(vChildComposite);
+
+            // Update the text and label values with the default text and image
+            updateActiveProjectControls(null);
+        }
+
+        /**
+         * Create the active project text.
+         *
+         * @param pParent The parent composite
+         */
+        private void createActiveProjectText(final Composite pParent) {
+            // Create the text and set its layout
+            mActiveProjectNameText = new Text(pParent, SWT.SINGLE | SWT.READ_ONLY);
+            GridData vGridData = new GridData(SWT.FILL, SWT.CENTER, true, false);
+            vGridData.heightHint = CONTROL_HEIGHT;
+            mActiveProjectNameText.setLayoutData(vGridData);
+
+            // Set the text background
+            mActiveProjectNameText.setBackground(pParent.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
+        }
+
+        /**
+         * Create the active project label.
+         *
+         * @param pParent The parent composite
+         */
+        private void createActiveProjectLabel(final Composite pParent) {
+            // Create the label and set its layout
+            mActiveProjectNameLabel = new Label(pParent, SWT.NONE);
+            mActiveProjectNameLabel.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER, false, false, 0, 0));
+
+            // Set the label background
+            mActiveProjectNameLabel.setBackground(pParent.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
+        }
+
+        /**
+         * Update the active project text message, and the displayed image,
+         * according to the given project name.
+         *
+         * If the given value is <code>null</code> or empty, set the default text
+         * and image.
+         *
+         * @param pProjectName The new project name to display
+         */
+        private void updateActiveProjectControls(final String pProjectName) {
+
+            // Check if the given project name is valid
+            if (StringUtils.isNotEmpty(pProjectName)) {
+
+                // Update the text value and the label image
+                if (mActiveProjectNameText != null) {
+                    mActiveProjectNameText.setText(pProjectName);
+                }
+                if (mActiveProjectNameLabel != null) {
+                    mActiveProjectNameLabel.setImage(mOpenedProjectImage);
+                }
+
+            } else {
+                // The given project name is not valid, set the default values
+                // for the text value and the label image
+                if (mActiveProjectNameText != null) {
+                    mActiveProjectNameText.setText(DEFAULT_PROJECT_NAME);
+                }
+                if (mActiveProjectNameLabel != null) {
+                    mActiveProjectNameLabel.setImage(mClosedProjectImage);
+                }
+
+            }
+        }
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/FileDialogWrapper.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/FileDialogWrapper.java
new file mode 100644
index 0000000..871bb6c
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/FileDialogWrapper.java
@@ -0,0 +1,242 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.widget;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.swt.widgets.FileDialog;
+import org.eclipse.swt.widgets.Shell;
+
+/**
+ * Wrap a file dialog to ensure that the returned file name
+ * will be suffixed by the filtered extension, if one is set.
+ *
+ * For example, if the user type 'test' and the dialog has been built
+ * to select only xml file, the returned value must be 'test.xml'
+ *
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class FileDialogWrapper {
+
+    /** The file dialog instance wrapped, to adapt its behaviour. */
+    private FileDialog mFileDialog = null;
+
+    /** The filters array to apply. */
+    private FileFilterEnum[] mFileFiltersArray = null;
+
+    /**
+     * Constructs a new instance of this class given only the parent of the wrapped file dialog,
+     * and the filters to apply.
+     *
+     * @param pParent Shell which will be the parent of the wrapped file dialog
+     * @param pFileFiltersArray The array of file filters to apply on the wrapped dialog, or null
+     */
+    public FileDialogWrapper(final Shell pParent, final FileFilterEnum[] pFileFiltersArray) {
+        mFileFiltersArray = pFileFiltersArray;
+        mFileDialog = new FileDialog(pParent);
+
+        // Set the filters on the wrapped dialog
+        initialiseDialogFilters();
+    }
+
+    /**
+     * Constructs a new instance of this class given the parent of the wrapped file dialog,
+     * a style value describing its behaviour and appearance, and the filters to apply.
+     *
+     * @param pParent Shell which will be the parent of the wrapped file dialog
+     * @param pStyle The style of wrapped dialog
+     * @param pFileFiltersArray The array of file filters to apply on the wrapped dialog, or null
+     */
+    public FileDialogWrapper(final Shell pParent, final int pStyle, final FileFilterEnum[] pFileFiltersArray) {
+        mFileFiltersArray = pFileFiltersArray;
+        mFileDialog = new FileDialog(pParent, pStyle);
+
+        // Set the filters on the wrapped dialog
+        initialiseDialogFilters();
+    }
+
+    /**
+     * Initialise the filters on the wrapped dialog.
+     */
+    private void initialiseDialogFilters() {
+
+        if (mFileFiltersArray != null) {
+
+            // Loop on the filters to apply to build an array of filters
+            // compatible with the standard file dialog, which uses only String values
+            String[] vFiltersLabelArray = new String[mFileFiltersArray.length];
+            for (int i = 0; i < mFileFiltersArray.length; i++) {
+                vFiltersLabelArray[i] = mFileFiltersArray[i].getFilterLabel();
+            }
+
+            // Finally apply the filters on the wrapped dialog
+            mFileDialog.setFilterExtensions(vFiltersLabelArray);
+        }
+    }
+
+    /**
+     * Open the wrapped file dialog and ensure that its returned file name
+     * is suffixed by the selected filter, if one is set.
+     *
+     * @return The selected file, suffixed is necessary
+     */
+    public String openFileDialog() {
+        // Call the wrapped dialog method to get the first selected file,
+        // and suffix the name is necessary
+        return suffixFileName(mFileDialog.open());
+    }
+
+    /**
+     * Get the wrapped file dialog.
+     *
+     * @return The wrapped file dialog instance
+     */
+    public FileDialog getFileDialog() {
+        return mFileDialog;
+    }
+
+    /**
+     * Get the file name selected in the wrapped file dialog
+     * and ensure that it is suffixed by the selected filter, if one is set.
+     *
+     * @return The selected file, suffixed is necessary
+     */
+    public String getFileName() {
+        // Call the parent method to get the first selected file,
+        // and suffix the name is necessary
+        return suffixFileName(mFileDialog.getFileName());
+    }
+
+    /**
+     * Get the file names selected in the wrapped file dialog
+     * and ensure that they are suffixed by the selected filter, if one is set.
+     *
+     * @return The selected files, suffixed is necessary
+     */
+    public String[] getFileNames() {
+
+        // Get the array of file names selected in the dialog
+        String[] vFileNamesArray = mFileDialog.getFileNames();
+
+        // Loop on the file names to suffix each one if necessary
+        List<String> vSuffixedFileNamesList = new ArrayList<String>(vFileNamesArray.length);
+        for (String vCurrentFileName : vFileNamesArray) {
+            // Suffix the current name and add it in the list
+            vSuffixedFileNamesList.add(suffixFileName(vCurrentFileName));
+        }
+
+        // Convert the list to an array and return it
+        return vSuffixedFileNamesList.toArray(new String[vSuffixedFileNamesList.size()]);
+    }
+
+    /**
+     * Return a String corresponding to the given file name suffixed by
+     * the filter extension selected. If no filter is selected, or if the
+     * name is already correctly suffixed, the name is not changed.
+     *
+     * @param pFileName The file name to suffix by the selected filter
+     * @return The file name suffixed
+     */
+    private String suffixFileName(final String pFileName) {
+
+        String vSuffixedFileName = pFileName;
+
+        // Ensure that the initial file name is valid
+        if (StringUtils.isNotEmpty(vSuffixedFileName)) {
+
+            // Get the index of the filter currently selected, and get the
+            // corresponding filter enumeration instance, to find its file extension
+            FileFilterEnum vFilterFound = null;
+            if (mFileFiltersArray != null && mFileDialog.getFilterIndex() >= 0) {
+                vFilterFound = mFileFiltersArray[mFileDialog.getFilterIndex()];
+            }
+
+            // Ensure that a filter is found
+            if (vFilterFound != null) {
+                // Build the corresponding extension value
+                String vExtensionWithDot = '.' + vFilterFound.getFilterExtension();
+
+                // Adapt the file name to ensure that it finishes by the filtered extension
+                if (!vSuffixedFileName.endsWith(vExtensionWithDot)) {
+                    vSuffixedFileName += vExtensionWithDot;
+                }
+            }
+        }
+
+        return vSuffixedFileName;
+    }
+
+    /**
+     * Define location where dialog will open.
+     *
+     * @param pDirectoryPath Path of directory
+     */
+    public void setDefaultDirectory(final String pDirectoryPath) {
+        String vLocation = pDirectoryPath;
+
+        // If location is empty, workspace location will be used
+        if (StringUtils.isEmpty(pDirectoryPath)) {
+            vLocation = ResourcesPlugin.getWorkspace().getRoot().getLocation().toOSString();
+        }
+
+        mFileDialog.setFilterPath(vLocation);
+    }
+
+    /**
+     * Enumeration for available file filters.
+     *
+     * @author $Author: jdumont $
+     * @version $Revision: 83 $
+     */
+    public enum FileFilterEnum {
+
+        /** XML filter. */
+        XML("xml", "*.xml"), //$NON-NLS-1$ //$NON-NLS-2$
+
+        /** UML filter. */
+        UML("uml", "*.uml"); //$NON-NLS-1$ //$NON-NLS-2$
+
+        /** The filter label displayed. */
+        private String mFilterLabel = null;
+
+        /** The filter extension. */
+        private String mFilterExtension = null;
+
+        /**
+         * Default constructor.
+         *
+         * @param pFilterExtension The file extension filtered (like 'xml')
+         * @param pFilterLabel The filter label displayed for the user (like '*.xml')
+         */
+        FileFilterEnum(final String pFilterExtension, final String pFilterLabel) {
+            mFilterExtension = pFilterExtension;
+            mFilterLabel = pFilterLabel;
+        }
+
+        /**
+         * @return The filter label
+         */
+        public String getFilterLabel() {
+            return mFilterLabel;
+        }
+
+        /**
+         * @return The filter extension
+         */
+        public String getFilterExtension() {
+            return mFilterExtension;
+        }
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/FilterComposite.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/FilterComposite.java
new file mode 100644
index 0000000..dc7dacf
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/FilterComposite.java
@@ -0,0 +1,379 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.widget;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.jface.action.IMenuListener;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.MenuManager;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.dnd.DND;
+import org.eclipse.swt.dnd.DropTarget;
+import org.eclipse.swt.dnd.DropTargetAdapter;
+import org.eclipse.swt.dnd.DropTargetEvent;
+import org.eclipse.swt.dnd.TextTransfer;
+import org.eclipse.swt.dnd.Transfer;
+import org.eclipse.swt.events.KeyAdapter;
+import org.eclipse.swt.events.KeyEvent;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.MouseAdapter;
+import org.eclipse.swt.events.MouseEvent;
+import org.eclipse.swt.events.MouseTrackAdapter;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Menu;
+import org.eclipse.swt.widgets.Text;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+import org.polarsys.esf.core.common.ui.CommonUIActivator.Implementation;
+import org.polarsys.esf.core.common.ui.actions.FilterPartAction;
+import org.polarsys.esf.core.common.ui.constants.ImageConstants;
+import org.polarsys.esf.core.common.ui.filter.FilterPartManager;
+import org.polarsys.esf.core.common.ui.filter.IFilterPartListener;
+
+/**
+ * Composite used to display all what is needed for the filter mechanisms.
+ * This include the field to select the filter value, the menu to apply
+ * to filter on available parts, etc.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class FilterComposite
+    extends Composite {
+
+    /** The preferred width for the composite. */
+    private static final int CONTROL_WIDTH = 200;
+    
+    /** The preferred height for the composite. */
+    private static final int CONTROL_HEIGHT = 17;
+
+    /** Reference to the singleton which manages the filter mechanisms. */
+    private static final FilterPartManager FILTER_PART_MANAGER = FilterPartManager.INSTANCE;
+
+    /** The filter text field. */
+    private Text mFilterTextField = null;
+
+    /** The clear label. */
+    private Label mClearLabel = null;
+
+    /** The search label. */
+    private Label mSearchLabel = null;
+
+    /**
+     * Default constructor.
+     * 
+     * @param pParent The parent composite
+     */
+    public FilterComposite(final Composite pParent) {
+        // Call the parent constructor
+        super(pParent, SWT.FLAT);
+
+        // Create its content
+        createContent(pParent);
+    }
+
+    /**
+     * Create the content of the composite, with all the needed widgets.
+     * 
+     * @param pParent The parent composite
+     */
+    private void createContent(final Composite pParent) {
+        // Initialise the layout of this instance
+        final GridLayout vMainLayout = new GridLayout();
+        vMainLayout.marginHeight = 0;
+        vMainLayout.marginWidth = 1;
+        setLayout(vMainLayout);
+
+        // Create the filter composite
+        final Composite vFilterComposite = new Composite(this, SWT.BORDER);
+        vFilterComposite.setBackground(getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
+
+        // Initialise the layout of the filter composite to display the widgets on three columns
+        final GridLayout vFilterLayout = new GridLayout(3, false);
+        vFilterLayout.marginHeight = 0;
+        vFilterLayout.marginWidth = 0;
+        vFilterComposite.setLayout(vFilterLayout);
+        GridData vGridData = new GridData(SWT.FILL, SWT.BEGINNING, true, false);
+        vGridData.widthHint = CONTROL_WIDTH;
+        vFilterComposite.setLayoutData(vGridData);
+
+        // Create the search label
+        createSearchLabel(vFilterComposite);
+
+        // Create the menu manager and associate it to the search label
+        createMenuManager();
+
+        // Create the filter text field
+        createFilterText(vFilterComposite);
+
+        // Create the clear label
+        createClearLabel(vFilterComposite);
+
+        // Initialise the widgets value for the initial state, without filter value
+        mClearLabel.setVisible(false);
+    }
+
+    /**
+     * Create the filter text field.
+     * 
+     * @param pParent The parent composite
+     */
+    private void createFilterText(final Composite pParent) {
+        // Create and initialise the filter text
+        mFilterTextField = new Text(pParent, SWT.SINGLE | SWT.ICON_CANCEL);
+        mFilterTextField.setMessage(CommonUIActivator.getMessages().getString("FilterComposite.text.defaulttext")); //$NON-NLS-1$
+        mFilterTextField.setToolTipText(CommonUIActivator.getMessages().getString("FilterComposite.text.tooltip")); //$NON-NLS-1$
+
+        // Add a key listener on the field to be warned that
+        // the filter value changes dynamically
+        mFilterTextField.addKeyListener(new KeyAdapter() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void keyReleased(final KeyEvent pEvent) {
+                FILTER_PART_MANAGER.updateFilterText(mFilterTextField.getText());
+            }
+        });
+
+        // Add a modify listener on the field to react
+        // when a value is validated
+        mFilterTextField.addModifyListener(new ModifyListener() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void modifyText(final ModifyEvent pEvent) {
+                mClearLabel.setVisible(StringUtils.isNotEmpty(mFilterTextField.getText()));
+            }
+        });
+
+        // Build the layout data for the text field
+        // NB : If the text widget supported cancel then it will have it's own
+        // integrated button, thus we can take the whole space
+        final GridData vGridData = new GridData(SWT.FILL, SWT.CENTER, true, false);
+        vGridData.heightHint = CONTROL_HEIGHT;
+        if ((mFilterTextField.getStyle() & SWT.ICON_CANCEL) != 0) {
+            vGridData.horizontalSpan = 2;
+        }
+        mFilterTextField.setLayoutData(vGridData);
+
+        // Add the drag and drop support on the text field
+        final DropTarget vDropTarget = new DropTarget(mFilterTextField, DND.DROP_MOVE | DND.DROP_COPY);
+        vDropTarget.setTransfer(new Transfer[] {TextTransfer.getInstance()});
+        vDropTarget.addDropListener(new DropTargetAdapter() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void drop(final DropTargetEvent pEvent) {
+                // Try to use the event data as new filter text
+                mFilterTextField.setText(String.valueOf(pEvent.data));
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void dragEnter(final DropTargetEvent pEvent) {
+                // Force the drag and drop operation to be a copy
+                pEvent.detail = DND.DROP_COPY;
+            }
+        });
+    }
+
+    /**
+     * Create the search label, displayed as an image, and associate a context menu to it.
+     * 
+     * @param pParent The parent composite
+     */
+    private void createSearchLabel(final Composite pParent) {
+        // Create the label and set its layout
+        mSearchLabel = new Label(pParent, SWT.NONE);
+        mSearchLabel.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, false, false, 0, 0));
+
+        // Set the label display, to show a standard search image
+        mSearchLabel.setImage(CommonUIActivator.getPlugin().getImageRegistry().get(Implementation.ICON_SEARCH_KEY));
+        mSearchLabel.setBackground(pParent.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
+        mSearchLabel.setToolTipText(CommonUIActivator.getMessages().getString("FilterComposite.search.tooltip")); //$NON-NLS-1$
+    }
+
+    /**
+     * Create the menu manager of the search label.
+     * Thus, when the user click on the search label, a contextual menu is
+     * displayed with all the available listeners.
+     */
+    private void createMenuManager() {
+        // Create the menu manager
+        final MenuManager vMenuManager = new MenuManager();
+
+        // Ensure that when the menu is shown, all the previous elements are removed
+        vMenuManager.setRemoveAllWhenShown(true);
+
+        // Add a custom listener to populate the menu dynamically
+        vMenuManager.addMenuListener(new IMenuListener() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void menuAboutToShow(final IMenuManager pMenuManager) {
+                // Add an item in the menu for all the active listeners
+                // This item will be already checked
+                for (IFilterPartListener vFiltrePartListener : FILTER_PART_MANAGER.getActivePartListenersList()) {
+                    pMenuManager.add(new FilterPartAction(vFiltrePartListener, true));
+                }
+
+                // Add an item in the menu for all the available listeners
+                // This item won't be checked
+                for (IFilterPartListener vFiltrePartListener : FILTER_PART_MANAGER.getAvailablePartListenersList()) {
+                    pMenuManager.add(new FilterPartAction(vFiltrePartListener));
+                }
+            }
+        });
+
+        // Add a custom listener to the search label, to be able to react on the mouse click,
+        // and build the contextual menu to the right location
+        mSearchLabel.addMouseListener(new MouseAdapter() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void mouseDown(final MouseEvent pEvent) {
+                // Ensure that it's a left click
+                if (pEvent.button == 1) {
+                    // Create the context menu for the search label
+                    final Menu vContextMenu = vMenuManager.createContextMenu(mSearchLabel);
+
+                    // Build the point, relative to the search label, where the
+                    // contextual menu must appear
+                    final Rectangle vRectangle = mSearchLabel.getBounds();
+                    Point vPoint = new Point(vRectangle.x, vRectangle.y + vRectangle.height);
+                    vPoint = mSearchLabel.toDisplay(vPoint);
+
+                    // Set the menu location, and display it
+                    vContextMenu.setLocation(vPoint.x, vPoint.y);
+                    vContextMenu.setVisible(true);
+                }
+            }
+        });
+    }
+
+    /**
+     * Create the clear text label, displayed as an image.
+     * 
+     * @param pParent The parent composite
+     */
+    private void createClearLabel(final Composite pParent) {
+        // Create the label only if the text widget doesn't support one natively
+        if ((mFilterTextField.getStyle() & SWT.ICON_CANCEL) == 0) {
+
+            // Create the label and set its layout
+            mClearLabel = new Label(pParent, SWT.NONE);
+            mClearLabel.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, false, false));
+
+            // Set the label display, to show a standard clear image
+            mClearLabel.setImage(ImageConstants.ICON_CLEAR_DISABLED);
+            mClearLabel.setBackground(pParent.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
+            mClearLabel
+                .setToolTipText(CommonUIActivator.getMessages().getString("FilterComposite.clearfilter.tooltip")); //$NON-NLS-1$
+
+            // Add a custom mouse listener to be able to clear the text on a click
+            // and to update the label image with the click action
+            mClearLabel.addMouseListener(new ClearLabelMouseAdapter());
+
+            // Add a custom mouse track adapter to update the label image when
+            // the mouse is over it
+            mClearLabel.addMouseTrackListener(new MouseTrackAdapter() {
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public void mouseEnter(final MouseEvent pEvent) {
+                    mClearLabel.setImage(ImageConstants.ICON_CLEAR);
+                }
+
+                /**
+                 * {@inheritDoc}
+                 */
+                @Override
+                public void mouseExit(final MouseEvent pEvent) {
+                    mClearLabel.setImage(ImageConstants.ICON_CLEAR_DISABLED);
+                }
+            });
+        }
+    }
+
+    /**
+     * Clear the filter text, by setting the default value.
+     */
+    private void clearFilterText() {
+        // Reset the text from the text widget, using the default filter
+        mFilterTextField.setText(FilterPartManager.DEFAULT_FILTER_TEXT);
+
+        // Reset the filter text applied by the manager
+        // NB : This will warn all the listeners
+        FILTER_PART_MANAGER.resetFilterText();
+    }
+
+    /**
+     * Mouse adapter linked to the clear label.
+     * 
+     * The clear label is displayed as an image, and when the user click on it,
+     * it must clear the filter text.
+     * 
+     * @author $Author: jdumont $
+     * @version $Revision: 83 $
+     */
+    private class ClearLabelMouseAdapter
+        extends MouseAdapter {
+
+        /**
+         * Default constructor.
+         */
+        public ClearLabelMouseAdapter() {
+            super();
+        }
+
+        /**
+         * {@inheritDoc}
+         * 
+         * Update the clear label image.
+         */
+        @Override
+        public void mouseDown(final MouseEvent pEvent) {
+            mClearLabel.setImage(ImageConstants.ICON_CLEAR_PRESSED);
+        }
+
+        /**
+         * {@inheritDoc}
+         * 
+         * Update the clear label image and clear the filter text.
+         */
+        @Override
+        public void mouseUp(final MouseEvent pEvent) {
+            // Thus update the label image and clear the text if needed
+            mClearLabel.setImage(ImageConstants.ICON_CLEAR);
+            clearFilterText();
+            mFilterTextField.setFocus();
+        }
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/GroupFileModelCreator.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/GroupFileModelCreator.java
new file mode 100644
index 0000000..df154de
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/GroupFileModelCreator.java
@@ -0,0 +1,135 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.widget;
+
+import java.util.List;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+import org.eclipse.emf.edit.provider.ItemProvider;
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
+import org.eclipse.jface.viewers.ComboViewer;
+import org.eclipse.jface.viewers.IContentProvider;
+import org.eclipse.jface.viewers.ILabelProvider;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Group;
+import org.eclipse.swt.widgets.Label;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+import org.polarsys.esf.core.common.ui.provider.FileLabelProvider;
+import org.polarsys.esf.core.common.ui.selection.ISelectionHelper;
+
+/**
+ * Group file model widget.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class GroupFileModelCreator {
+
+    /** Title of model selection group. */
+    private static final String MODEL_GROUP_TITLE = CommonUIActivator.getMessages().getString(
+        "GroupFileModelCreator.group.title"); //$NON-NLS-1$
+
+    /** Label for ESF File combo. */
+    private static final String SA_FILE_LABEL = CommonUIActivator.getMessages()
+        .getString("GroupFileModelCreator.label"); //$NON-NLS-1$
+
+    /** Helper used to manage files which can be proposed in combo box. */
+    private ISelectionHelper mSelectionHelper = null;
+
+    /** Viewer create to manage link between data and control. */
+    private Viewer mViewer = null;
+
+    /**
+     * Default constructor.
+     * 
+     * @param pSelectionHelper Helper used to get file which can be proposed to user.
+     */
+    public GroupFileModelCreator(final ISelectionHelper pSelectionHelper) {
+        mSelectionHelper = pSelectionHelper;
+    }
+
+    /**
+     * Create a group composite with a combo box, and add it to given parent composite.
+     * 
+     * @param pParent target composite for this group
+     * @return viewer of combobox
+     */
+    public Viewer createGroupFileModel(final Composite pParent) {
+
+        // Create composite which group model component
+        Group vGroupComposite = new Group(pParent, SWT.NONE);
+        vGroupComposite.setText(MODEL_GROUP_TITLE);
+
+        // Set Layout
+        GridLayout vLayout = new GridLayout(2, false);
+        vGroupComposite.setLayout(vLayout);
+        vGroupComposite.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, false));
+
+        Label vLabel = new Label(vGroupComposite, SWT.NONE);
+        vLabel.setText(SA_FILE_LABEL);
+
+        // Create Item Provider
+        List<IFile> vFilesList = mSelectionHelper.getFilteredFiles();
+        ItemProvider vFileProvider = new ItemProvider(vFilesList);
+
+        // Then create a content provider, it is a link between viewer and item provider.
+        IContentProvider vContentProvider = new AdapterFactoryContentProvider(new AdapterFactoryImpl());
+
+        ILabelProvider vLabelProvider = new FileLabelProvider();
+
+        ComboViewer vComboViewer = new ComboViewer(vGroupComposite);
+        vComboViewer.getCombo().setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
+
+        vComboViewer.setContentProvider(vContentProvider);
+        vComboViewer.setLabelProvider(vLabelProvider);
+        vComboViewer.setInput(vFileProvider);
+
+        mViewer = vComboViewer;
+
+        initialiseSelectedFile();
+
+        return vComboViewer;
+    }
+
+    /**
+     * Initialise selected file.
+     */
+    private void initialiseSelectedFile() {
+        IFile vSelectedFile = null;
+        IFile[] vSelectedFiles = mSelectionHelper.getSelectedFiles();
+
+        if (vSelectedFiles.length > 0) {
+            vSelectedFile = vSelectedFiles[0];
+        }
+
+        List<IFile> vFilesList = mSelectionHelper.getFilteredFiles();
+
+        if (!vFilesList.isEmpty()) {
+
+            /*
+             * Load model from selection when it is known, otherwise load first of list.
+             */
+            int vIndex = 0;
+            if (vSelectedFile != null) {
+                vIndex = vFilesList.indexOf(vSelectedFile);
+            }
+
+            mViewer.setSelection(new StructuredSelection(vFilesList.get(vIndex)));
+
+        }
+    }
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/MultipleChoicesComposite.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/MultipleChoicesComposite.java
new file mode 100644
index 0000000..40ca2fc
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/MultipleChoicesComposite.java
@@ -0,0 +1,908 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.widget;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+import org.eclipse.emf.common.ui.celleditor.ExtendedComboBoxCellEditor;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.edit.provider.ItemProvider;
+import org.eclipse.emf.edit.ui.EMFEditUIPlugin;
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
+import org.eclipse.jface.viewers.AbstractTreeViewer;
+import org.eclipse.jface.viewers.DoubleClickEvent;
+import org.eclipse.jface.viewers.IContentProvider;
+import org.eclipse.jface.viewers.IDoubleClickListener;
+import org.eclipse.jface.viewers.ILabelProvider;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.TableViewer;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Group;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.dialogs.PatternFilter;
+import org.polarsys.esf.core.common.observer.IObserver;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+import org.polarsys.esf.core.common.ui.CommonUIActivator.Implementation;
+
+/**
+ *
+ * Composite with dual choice list, add, remove, up and down button.
+ * Inspired from multipleChoiceDialog Class (IBM).
+ *
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public final class MultipleChoicesComposite
+    extends Composite {
+
+    /**
+     * Image descriptor for up button.
+     */
+    private static final Image IMG_UP = CommonUIActivator.getPlugin().getImageRegistry()
+        .getDescriptor(Implementation.ICON_UP_IMG_KEY).createImage();
+
+    /**
+     * Image descriptor for down button.
+     */
+    private static final Image IMG_DOWN = CommonUIActivator.getPlugin().getImageRegistry()
+        .getDescriptor(Implementation.ICON_DOWN_IMG_KEY).createImage();
+
+    /**
+     * Image descriptor for add button.
+     */
+    private static final Image IMG_ADD = CommonUIActivator.getPlugin().getImageRegistry()
+        .getDescriptor(Implementation.ICON_ADD_IMG_KEY).createImage();
+
+    /**
+     * Image descriptor for remove button.
+     */
+    private static final Image IMG_RMV = CommonUIActivator.getPlugin().getImageRegistry()
+        .getDescriptor(Implementation.ICON_REMOVE_IMG_KEY).createImage();
+
+    /**
+     * Title of left list.
+     */
+    private String mLeftListTitle = null;
+
+    /**
+     * Title of right list.
+     */
+    private String mRightListTitle = null;
+
+    /**
+     * Label provider for contents in list.
+     */
+    private ILabelProvider mLabelProvider = null;
+
+    /**
+     * Wrapper source (left) table.
+     */
+    private TableViewer mLeftTableViewer = null;
+
+    /**
+     * Item provider for available (left) list.
+     */
+    private ItemProvider mLeftItemProvider = null;
+
+    /**
+     * Convenient provider for table viewer.
+     */
+    private IContentProvider mLeftContentProvider = null;
+
+    /**
+     * Convenient provider for table viewer.
+     */
+    private IContentProvider mRightContentProvider = null;
+
+    /**
+     * Item provider for results (right) list.
+     */
+    private ItemProvider mRightItemProvider = null;
+
+    /**
+     * Wrapper for results (right) table.
+     */
+    private TableViewer mRightTableViewer = null;
+
+    /**
+     * Add button.
+     */
+    private Button mAddButton = null;
+
+    /**
+     * Remove button.
+     */
+    private Button mRemoveButton = null;
+
+    /**
+     * Up Button.
+     */
+    private Button mUpButton = null;
+
+    /**
+     * Down Button.
+     */
+    private Button mDownButton = null;
+
+    /**
+     * Observer updated when a modification is done.
+     */
+    private IObserver mObserver = null;
+
+    /** Right choices is sort. */
+    private boolean mSortChoices = false;
+
+    /** Filter field to filter left column. */
+    private Text mFilterField = null;
+
+    /**
+     * Default constructor.
+     *
+     * @param pParent composite where this one will be anchored.
+     * @param pLabelProvider Provider for label of object in list.
+     * @param pSortChoices decide if lists must be sorted or not.
+     * @param pLeftListTitle title for left list.
+     * @param pRightListTitle title for right list.
+     * @param pObserver Observer of this window.
+     */
+    public MultipleChoicesComposite(
+        final Composite pParent,
+        final ILabelProvider pLabelProvider,
+        final boolean pSortChoices,
+        final String pLeftListTitle,
+        final String pRightListTitle,
+        final IObserver pObserver) {
+
+        // Instantiate composite, and link it to support parent.
+        super(pParent, SWT.NULL);
+
+        // Instantiate members.
+        mLabelProvider = pLabelProvider;
+        mRightListTitle = pRightListTitle;
+        mLeftListTitle = pLeftListTitle;
+        mSortChoices = pSortChoices;
+        mObserver = pObserver;
+
+        // Now create visual part.
+        createComposite();
+    }
+
+    /**
+     * Fill parent composite with two table, a filter, and add/remove/up/down buttons. React to double click.
+     */
+    private void createComposite() {
+
+        // Instantiate layout for main panel.
+        GridLayout vContentsLayout = new GridLayout();
+        vContentsLayout.numColumns = 3;
+
+        // Set it on main composite panel.
+        setLayout(vContentsLayout);
+
+        // Create a group (subclass of composite) for filter part, which contains text and label.
+        createFilterGroup(this);
+
+        // Create left composite, with available values list.
+        createLeftComposite(this);
+
+        // Create center composite, with button.
+        createCenterComposite(this);
+
+        // Create right composite, with results values list.
+        createRightComposite(this);
+
+        computeButtonStatus();
+
+    }
+
+    /**
+     * Create filter group.
+     *
+     * @param pParent parent target for the widget created.
+     */
+    private void createFilterGroup(final Composite pParent) {
+        Group vFilterGroupComposite = new Group(pParent, SWT.NONE);
+
+        vFilterGroupComposite.setText(EMFEditUIPlugin.INSTANCE.getString("_UI_Choices_pattern_group")); //$NON-NLS-1$
+
+        // Set layout and data for parent layout.
+        vFilterGroupComposite.setLayout(new GridLayout(2, false));
+        vFilterGroupComposite.setLayoutData(new GridData(SWT.FILL, SWT.DEFAULT, true, false, 3, 1));
+
+        // Add label to group
+        Label vLabel = new Label(vFilterGroupComposite, SWT.NONE);
+        vLabel.setText(EMFEditUIPlugin.INSTANCE.getString("_UI_Choices_pattern_label")); //$NON-NLS-1$
+
+        // Add text area to group
+        // vPatternText is the high part of the window, used to fill filter.
+        mFilterField = new Text(vFilterGroupComposite, SWT.BORDER);
+        mFilterField.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+    }
+
+    /**
+     * Create left composite.
+     *
+     * @param pParent parent for this widget
+     */
+    private void createLeftComposite(final Composite pParent) {
+
+        // Now create left composite (table of available values)
+        Composite vLeftComposite = new Composite(pParent, SWT.NONE);
+
+        // Set layout data for parent composite
+        GridData vData = new GridData(SWT.FILL, SWT.FILL, true, true);
+        vData.horizontalAlignment = SWT.END;
+        vLeftComposite.setLayoutData(vData);
+
+        // Create a layout for current composite
+        final GridLayout vLayout = new GridLayout();
+        vData.horizontalAlignment = SWT.FILL;
+        vLayout.marginHeight = 0;
+        vLayout.marginWidth = 0;
+        vLayout.numColumns = 1;
+        vLeftComposite.setLayout(vLayout);
+
+        // Create label for table
+        createLeftColumnLabel(vLeftComposite);
+
+        // Create Table
+        createLeftColumn(vLeftComposite);
+
+    }
+
+    /**
+     * Create left column for left side composite.
+     *
+     * @param pParent parent target for the widget created.
+     */
+    private void createLeftColumn(final Composite pParent) {
+        Table vAvailableValuesTable = new Table(pParent, SWT.MULTI | SWT.BORDER);
+
+        // Add layout data
+        GridData vLeftTableGridData = new GridData();
+        vLeftTableGridData.widthHint = Display.getCurrent().getBounds().width / 5;
+        vLeftTableGridData.heightHint = Display.getCurrent().getBounds().height / 3;
+        vLeftTableGridData.verticalAlignment = SWT.FILL;
+        vLeftTableGridData.horizontalAlignment = SWT.FILL;
+        vLeftTableGridData.grabExcessHorizontalSpace = true;
+        vLeftTableGridData.grabExcessVerticalSpace = true;
+        vAvailableValuesTable.setLayoutData(vLeftTableGridData);
+
+        // Create viewer for this table.
+        mLeftTableViewer = new TableViewer(vAvailableValuesTable);
+
+        // Create Filter.
+        associateFilterToColumn();
+
+        // Add listener for double click.
+        mLeftTableViewer.addDoubleClickListener(new IDoubleClickListener() {
+
+            @Override
+            public void doubleClick(final DoubleClickEvent pEvent) {
+                if (mAddButton.isEnabled()) {
+                    mAddButton.notifyListeners(SWT.Selection, null);
+                }
+            }
+        });
+
+        // Add listener to enable/disable button
+        mLeftTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
+
+            @Override
+            public void selectionChanged(final SelectionChangedEvent pEvent) {
+                // Refresh button enable status
+                computeButtonStatus();
+
+            }
+        });
+    }
+
+    /**
+     * Associate filter to left column.
+     */
+    private void associateFilterToColumn() {
+        final PatternFilter vFilter = new PatternFilter() {
+
+            @Override
+            protected boolean isParentMatch(final Viewer pViewer, final Object pElement) {
+                return (pViewer instanceof AbstractTreeViewer) && super.isParentMatch(pViewer, pElement);
+            }
+        };
+
+        // Add filter to this viewer
+        mLeftTableViewer.addFilter(vFilter);
+
+        // Add listener to refresh viewer when text of filter is modified.
+        mFilterField.addModifyListener(new ModifyListener() {
+
+            @Override
+            public void modifyText(final ModifyEvent pEvent) {
+                vFilter.setPattern(((Text) pEvent.widget).getText());
+                mLeftTableViewer.refresh();
+            }
+        });
+    }
+
+    /**
+     * Create label for left column.
+     *
+     * @param pParent parent target for the widget created.
+     */
+    private void createLeftColumnLabel(final Composite pParent) {
+        Label vLeftTableTitleLabel = new Label(pParent, SWT.NONE);
+        vLeftTableTitleLabel.setText(mLeftListTitle);
+
+        // Add grid data
+        GridData vLeftTableTitleLabelGridData = new GridData();
+        vLeftTableTitleLabelGridData.verticalAlignment = SWT.FILL;
+        vLeftTableTitleLabelGridData.horizontalAlignment = SWT.FILL;
+        vLeftTableTitleLabel.setLayoutData(vLeftTableTitleLabelGridData);
+    }
+
+    /**
+     * Create right composite (results table).
+     *
+     * @param pParent where composite will be push.
+     */
+    private void createRightComposite(final Composite pParent) {
+
+        // Create composite and push it on parent panel.
+        Composite vRightComposite = new Composite(pParent, SWT.NONE);
+
+        // Add grid data for parent layout.
+        GridData vData = new GridData(SWT.FILL, SWT.FILL, true, true);
+        vData.horizontalAlignment = SWT.END;
+        vRightComposite.setLayoutData(vData);
+
+        // Create a layout for this composite.
+        final GridLayout vLayout = new GridLayout();
+        vData.horizontalAlignment = SWT.FILL;
+        vLayout.marginHeight = 0;
+        vLayout.marginWidth = 0;
+        vLayout.numColumns = 1;
+        vRightComposite.setLayout(vLayout);
+
+        // Create title label for right list
+        createRightLabelColumn(vRightComposite);
+
+        // Create table
+        createRightColumn(vRightComposite);
+
+    }
+
+    /**
+     * Create right column for composite.
+     *
+     * @param pParent parent target for the widget created.
+     */
+    private void createRightColumn(final Composite pParent) {
+        Table vRightTable = new Table(pParent, SWT.MULTI | SWT.BORDER);
+
+        // Create grid data for this table
+        GridData vRightTableGridData = new GridData();
+        vRightTableGridData.widthHint = Display.getCurrent().getBounds().width / 5;
+        vRightTableGridData.heightHint = Display.getCurrent().getBounds().height / 3;
+        vRightTableGridData.verticalAlignment = SWT.FILL;
+        vRightTableGridData.horizontalAlignment = SWT.FILL;
+        vRightTableGridData.grabExcessHorizontalSpace = true;
+        vRightTableGridData.grabExcessVerticalSpace = true;
+        vRightTable.setLayoutData(vRightTableGridData);
+
+        // Create a viewer for results table
+        mRightTableViewer = new TableViewer(vRightTable);
+
+        mRightTableViewer.addDoubleClickListener(new IDoubleClickListener() {
+
+            @Override
+            public void doubleClick(final DoubleClickEvent pEvent) {
+                if (mRemoveButton.isEnabled()) {
+                    mRemoveButton.notifyListeners(SWT.Selection, null);
+                }
+            }
+        });
+
+        // Add listener to enable/disable button
+        mRightTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
+
+            @Override
+            public void selectionChanged(final SelectionChangedEvent pEvent) {
+                // Refresh button enable status
+                computeButtonStatus();
+
+            }
+        });
+    }
+
+    /**
+     * Create label for right column.
+     *
+     * @param pParent parent target for the widget created.
+     */
+    private void createRightLabelColumn(final Composite pParent) {
+        final Label vRightListTitleLabel = new Label(pParent, SWT.NONE);
+        vRightListTitleLabel.setText(mRightListTitle);
+
+        // Create grid data for this title.
+        final GridData vRightListTitleLabelGridData = new GridData();
+        vRightListTitleLabelGridData.horizontalSpan = 1;
+        vRightListTitleLabelGridData.horizontalAlignment = SWT.FILL;
+        vRightListTitleLabelGridData.verticalAlignment = SWT.FILL;
+        vRightListTitleLabel.setLayoutData(vRightListTitleLabelGridData);
+    }
+
+    /**
+     * Create center composite (button).
+     *
+     * @param pParent where composite will be push.
+     */
+    private void createCenterComposite(final Composite pParent) {
+
+        // Instantiate center composite and put it on main panel.
+        Composite vControlButtons = new Composite(pParent, SWT.NONE);
+
+        // Add data for parent layout.
+        GridData vControlButtonsGridData = new GridData();
+        vControlButtonsGridData.verticalAlignment = SWT.FILL;
+        vControlButtonsGridData.horizontalAlignment = SWT.FILL;
+        vControlButtons.setLayoutData(vControlButtonsGridData);
+
+        // Create a layout for current composite.
+        final GridLayout vControlsButtonGridLayout = new GridLayout();
+        vControlButtons.setLayout(vControlsButtonGridLayout);
+
+        // new Label(vControlButtons, SWT.NONE);
+        // Create a space label to separate add/remove and up/down button
+        Label vSpaceLabelOne = new Label(vControlButtons, SWT.NONE);
+        GridData vSpaceLabelOneGridData = new GridData();
+        vSpaceLabelOneGridData.verticalSpan = 2;
+        vSpaceLabelOne.setLayoutData(vSpaceLabelOneGridData);
+
+        // Create each button
+        createAddButton(vControlButtons);
+        createRemoveButton(vControlButtons);
+
+        // Create a space label to separate add/remove and up/down button
+        Label vSpaceLabelTwo = new Label(vControlButtons, SWT.NONE);
+        GridData vSpaceLabelTwoGridData = new GridData();
+        vSpaceLabelTwoGridData.verticalSpan = 2;
+        vSpaceLabelTwo.setLayoutData(vSpaceLabelTwoGridData);
+
+        createUpButton(vControlButtons);
+        createDownButton(vControlButtons);
+    }
+
+    /**
+     * Create add button (move selected items from available table to results table).
+     *
+     * @param pParent where button will be push.
+     */
+    private void createAddButton(final Composite pParent) {
+
+        // Instantiate button
+        mAddButton = new Button(pParent, SWT.PUSH);
+
+        // Set icon
+        mAddButton.setImage(IMG_ADD);
+
+        // Add data grid
+        final GridData vAddButtonGridData = new GridData();
+        vAddButtonGridData.verticalAlignment = SWT.FILL;
+        vAddButtonGridData.horizontalAlignment = SWT.FILL;
+        mAddButton.setLayoutData(vAddButtonGridData);
+
+        // Add listener
+        mAddButton.addSelectionListener(new SelectionAdapter() {
+
+            // Event is null when choiceTableViewer is double clicked
+            @Override
+            public void widgetSelected(final SelectionEvent pEvent) {
+
+                // Get selected items
+                final IStructuredSelection vSelection = (IStructuredSelection) mLeftTableViewer.getSelection();
+
+                Iterator<?> vSelectionIterator = vSelection.iterator();
+
+                // Iterate on it
+                while (vSelectionIterator.hasNext()) {
+                    Object vCurrentValue = vSelectionIterator.next();
+
+                    if (!mRightItemProvider.getChildren().contains(vCurrentValue)) {
+                        // Add current value to results provider
+                        mRightItemProvider.getChildren().add(vCurrentValue);
+
+                        // remove it form available values provider
+                        mLeftItemProvider.getChildren().remove(vCurrentValue);
+
+                    }
+                }
+
+                // Run asynchronous selection because Viewer refresh is asynchronous
+                getDisplay().asyncExec(new Runnable() {
+
+                    /**
+                     * {@inheritDoc}
+                     */
+                    @Override
+                    public void run() {
+                        mRightTableViewer.setSelection(vSelection);
+                    }
+                });
+
+                // Notify observer
+                notifyObserver();
+            }
+
+        });
+
+    }
+
+    /**
+     * Create remove button (move selected items from results table to available table).
+     *
+     * @param pParent where button will be push.
+     */
+    private void createRemoveButton(final Composite pParent) {
+
+        // Instantiate remove button and push it on central composite.
+        mRemoveButton = new Button(pParent, SWT.PUSH);
+
+        // Set icon
+        mRemoveButton.setImage(IMG_RMV);
+
+        // Add data layout
+        final GridData vRemoveButtonGridData = new GridData();
+        vRemoveButtonGridData.verticalAlignment = SWT.FILL;
+        vRemoveButtonGridData.horizontalAlignment = SWT.FILL;
+        mRemoveButton.setLayoutData(vRemoveButtonGridData);
+
+        // Add listener
+        mRemoveButton.addSelectionListener(new SelectionAdapter() {
+
+            // event is null when Results TableViewer is double clicked
+            @Override
+            public void widgetSelected(final SelectionEvent pEvent) {
+                final IStructuredSelection vSelection = (IStructuredSelection) mRightTableViewer.getSelection();
+                Iterator<?> vSelectionIterator = vSelection.iterator();
+
+                // Iterate on it
+                while (vSelectionIterator.hasNext()) {
+                    final Object vCurrentValue = vSelectionIterator.next();
+
+                    // Remove it from results provider
+                    mRightItemProvider.getChildren().remove(vCurrentValue);
+
+                    // Add it to available provider
+                    mLeftItemProvider.getChildren().add(vCurrentValue);
+
+                }
+
+                // Run asynchronous selection because Viewer refresh is asynchronous
+                getDisplay().asyncExec(new Runnable() {
+
+                    /**
+                     * {@inheritDoc}
+                     */
+                    @Override
+                    public void run() {
+                        mLeftTableViewer.setSelection(vSelection);
+                    }
+                });
+
+                // Notify observer
+                notifyObserver();
+            }
+        });
+
+    }
+
+    /**
+     * Create up button, to change order of item in results list.
+     *
+     * @param pParent where button will be push.
+     */
+    private void createUpButton(final Composite pParent) {
+        // Set up button
+        mUpButton = new Button(pParent, SWT.PUSH);
+
+        // Set icon
+        mUpButton.setImage(IMG_UP);
+
+        // set data layout
+        GridData vUpButtonGridData = new GridData();
+        vUpButtonGridData.verticalAlignment = SWT.FILL;
+        vUpButtonGridData.horizontalAlignment = SWT.FILL;
+        mUpButton.setLayoutData(vUpButtonGridData);
+
+        // Add listener
+        mUpButton.addSelectionListener(new SelectionAdapter() {
+
+            @Override
+            public void widgetSelected(final SelectionEvent pEvent) {
+                // Get Selection
+                IStructuredSelection vSelection = (IStructuredSelection) mRightTableViewer.getSelection();
+
+                // Iterate on it
+                Iterator<?> vSelectionIterator = vSelection.iterator();
+
+                // Estimate upper bound of list
+                int vMinIndex = 0;
+                EList<Object> vRightItemsList = mRightItemProvider.getChildren();
+
+                while (vSelectionIterator.hasNext()) {
+                    Object vCurrentValue = vSelectionIterator.next();
+
+                    // Get current index
+                    int vIndex = vRightItemsList.indexOf(vCurrentValue);
+
+                    // Move item
+                    vRightItemsList.move(Math.max(vIndex - 1, vMinIndex), vCurrentValue);
+
+                }
+
+                computeButtonStatus();
+            }
+        });
+
+    }
+
+    /**
+     * Create down button, to change order of item in results list.
+     *
+     * @param pParent where button will be push.
+     */
+    private void createDownButton(final Composite pParent) {
+
+        // Instantiate down button
+        mDownButton = new Button(pParent, SWT.PUSH);
+
+        // Set image
+        mDownButton.setImage(IMG_DOWN);
+
+        // Create data layout
+        GridData vDownButtonGridData = new GridData();
+        vDownButtonGridData.verticalAlignment = SWT.FILL;
+        vDownButtonGridData.horizontalAlignment = SWT.FILL;
+        mDownButton.setLayoutData(vDownButtonGridData);
+
+        // Add selection listener
+        mDownButton.addSelectionListener(new SelectionAdapter() {
+
+            @Override
+            public void widgetSelected(final SelectionEvent pEvent) {
+                // Get selected items
+                IStructuredSelection vSelection = (IStructuredSelection) mRightTableViewer.getSelection();
+
+                // Need to explore in right way
+                Collections.reverse(vSelection.toList());
+
+                // Iterate on it
+                Iterator<?> vSelectionIterator = vSelection.iterator();
+
+                // Estimate bottom bound of list
+                EList<Object> vRigthItemsList = mRightItemProvider.getChildren();
+                int vMaxIndex = vRigthItemsList.size() - 1;
+
+                while (vSelectionIterator.hasNext()) {
+                    Object vCurrentValue = vSelectionIterator.next();
+
+                    // Get index of current items
+                    int vIndex = vRigthItemsList.indexOf(vCurrentValue);
+
+                    // Move it
+                    vRigthItemsList.move(Math.min(vIndex + 1, vMaxIndex), vCurrentValue);
+
+                }
+
+                computeButtonStatus();
+            }
+        });
+    }
+
+    /**
+     * Call this method to compute each button status (enabled / disabled) according to selection and/or table status.
+     */
+    private void computeButtonStatus() {
+
+        // Add button is available if provider of available values is not empty.
+        mAddButton.setEnabled(checkLeftColumn());
+
+        // Remove button is available if provider of results is not empty.
+        mRemoveButton.setEnabled(checkRightColumn());
+
+        // Up Button is available if provider of results and selection are not empty.
+        mUpButton.setEnabled(checkRankSort()
+            && checkUpButton());
+
+        // Up Button is available if provider of results and selection are not empty.
+        mDownButton.setEnabled(checkRankSort()
+            && checkDownButton());
+
+    }
+
+    /**
+     * @return <code>true</code> if a selection exist in right column, otherwise <code>false</code>
+     */
+    private boolean checkUpButton() {
+        IStructuredSelection vSelection = (IStructuredSelection) mRightTableViewer.getSelection();
+        boolean vResult = !vSelection.isEmpty();
+
+        // Case : one selection can not Up if it is on top of column
+        if (vResult && vSelection.size() == 1) {
+            EList<Object> vRightElements = mRightItemProvider.getChildren();
+            vResult = vRightElements.indexOf(vSelection.getFirstElement()) != 0;
+        }
+
+        return vResult;
+    }
+
+    /**
+     * @return <code>true</code> if a selection exist in right column, otherwise <code>false</code>
+     */
+    private boolean checkDownButton() {
+        IStructuredSelection vSelection = (IStructuredSelection) mRightTableViewer.getSelection();
+        boolean vResult = !vSelection.isEmpty();
+
+        // Case : one selection can not Down if it is on bottom of column
+        if (vResult && vSelection.size() == 1) {
+            EList<Object> vRightElements = mRightItemProvider.getChildren();
+            vResult = vRightElements.indexOf(vSelection.getFirstElement()) != (vRightElements.size() - 1);
+        }
+
+        return vResult;
+    }
+
+    /**
+     * @return <code>true</code> if there are elements in right column, otherwise <code>false</code>
+     */
+    private boolean checkRightColumn() {
+        return mRightItemProvider != null && !mRightItemProvider.getChildren().isEmpty();
+    }
+
+    /**
+     * @return <code>true</code> if there are at least two elements in right column, otherwise <code>false</code>
+     */
+    private boolean checkRankSort() {
+        return mRightItemProvider != null && mRightItemProvider.getChildren().size() > 1;
+    }
+
+    /**
+     * @return <code>true</code> if there are children in left column, otherwise <code>false</code>
+     */
+    private boolean checkLeftColumn() {
+        return mLeftItemProvider != null && !mLeftItemProvider.getChildren().isEmpty();
+    }
+
+    /**
+     * Notify observer. Method call when results list is modified.
+     *
+     */
+    private void notifyObserver() {
+        if (mObserver != null) {
+            mObserver.update(this);
+        }
+    }
+
+    /**
+     * Set left column input.
+     */
+    private void setLeftColumnInput() {
+        // Associate content provider and viewer
+        mLeftTableViewer.setContentProvider(mLeftContentProvider);
+
+        // Set Label provider
+        mLeftTableViewer.setLabelProvider(mLabelProvider);
+
+        // Now set item provider.
+        mLeftTableViewer.setInput(mLeftItemProvider);
+    }
+
+    /**
+     * Set right column input.
+     */
+    private void setRightColumnInput() {
+
+        // Set a content provider.
+        mRightTableViewer.setContentProvider(mRightContentProvider);
+
+        // IContentProvider vContentProvider = new AdapterFactoryContentProvider(new AdapterFactoryImpl());
+        // vFeatureTableViewer.setContentProvider(vContentProvider);
+
+        // Set a label provider
+        mRightTableViewer.setLabelProvider(mLabelProvider);
+
+        // This will call getElements in the content provider
+        mRightTableViewer.setInput(mRightItemProvider);
+
+    }
+
+    /**
+     * Set intput of composite.
+     *
+     * @param pLeftList Input for left column.
+     * @param pRightList Input for right column.
+     */
+    public void setInputList(final List<? extends Object> pLeftList, final List<? extends Object> pRightList) {
+
+        // Get a generic and empty adapter factory
+        ComposedAdapterFactory vAdapterFactory = new ComposedAdapterFactory();
+        // TODO : Change for the right adapter factory type
+        vAdapterFactory.addAdapterFactory(new AdapterFactoryImpl());
+
+        if (pLeftList != null) {
+            // Order action will modify values list. Then it is necessary to create a new list, to not modify
+            // one give in parameter.
+            List<Object> vAvailableValuesList = new ArrayList<Object>(pLeftList);
+
+            // To order entries, alphabetic order of Label provider contents is used.
+            if (mSortChoices) {
+                // This one ordered results.
+                // This method directly modify List gave in parameter. (...)
+                ExtendedComboBoxCellEditor.createItems(vAvailableValuesList, mLabelProvider, true);
+            }
+
+            // Get an item provider
+            mLeftItemProvider = new ItemProvider(vAdapterFactory, vAvailableValuesList);
+
+            // Get a content provider
+            mLeftContentProvider = new AdapterFactoryContentProvider(vAdapterFactory);
+
+            setLeftColumnInput();
+        }
+
+        if (pRightList != null) {
+            // ItemProvider will create a new list.
+            // Obtain an item provider for results list.
+            mRightItemProvider = new ItemProvider(vAdapterFactory, pRightList);
+
+            // Create a content provider which wraps adapterFactory and will be used by table viewer
+            mRightContentProvider = new AdapterFactoryContentProvider(vAdapterFactory);
+
+            setRightColumnInput();
+        }
+
+        computeButtonStatus();
+    }
+
+    /**
+     * @return list of results values. Create a new list each time.
+     */
+    public List<Object> getResults() {
+        return new ArrayList<Object>(mRightItemProvider.getChildren());
+    }
+
+    /**
+     * @return list of Available values. Create a new list each time.
+     */
+    public List<Object> getAvailableValues() {
+        return new ArrayList<Object>(mLeftItemProvider.getChildren());
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/TreeViewerUtils.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/TreeViewerUtils.java
new file mode 100644
index 0000000..2d5d354
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/TreeViewerUtils.java
@@ -0,0 +1,125 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.widget;
+
+import org.eclipse.jface.viewers.CellLabelProvider;
+import org.eclipse.jface.viewers.EditingSupport;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.jface.viewers.TreeViewerColumn;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.TreeColumn;
+
+
+/**
+ * Utility class used to centralise common methods to work with tree viewers. 
+ * 
+ * @author  $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public final class TreeViewerUtils {
+    
+    
+    /**
+     * Default constructor.
+     * Private as its a utility class.
+     */
+    private TreeViewerUtils() {
+    }
+    
+    /**
+     * Create a {@link TreeViewerColumn} and set its alignment, text and size.
+     * 
+     * @param pTreeViewer The tree viewer which will contain the column
+     * @param pText The column text
+     * @param pAlignment The column content alignment
+     * @param pWidth The column width
+     * @return The created column
+     */
+    public static TreeViewerColumn createViewerColumn(
+        final TreeViewer pTreeViewer,
+        final String pText,
+        final int pAlignment,
+        final int pWidth) {
+
+        // Create the tree viewer column
+        final TreeViewerColumn vTreeViewerColumn = new TreeViewerColumn(pTreeViewer, SWT.NONE);
+
+        // Get the column object and set its alignment, text and width
+        final TreeColumn vTreeColumn = vTreeViewerColumn.getColumn();
+        vTreeColumn.setText(pText);
+        vTreeColumn.setAlignment(pAlignment);
+        vTreeColumn.setWidth(pWidth);
+
+        return vTreeViewerColumn;
+    }
+    
+    /**
+     * Create a {@link TreeViewerColumn} with a specific label provider,
+     * and set its alignment, text and size.
+     * 
+     * @param pTreeViewer The tree viewer which will contain the column
+     * @param pText The column text
+     * @param pAlignment The column content alignment
+     * @param pWidth The column width
+     * @param pLabelProvider The custom label provider to set to this column. Can be null.
+     * @return The created column
+     */
+    public static TreeViewerColumn createViewerColumn(
+        final TreeViewer pTreeViewer,
+        final String pText,
+        final int pAlignment,
+        final int pWidth,
+        final CellLabelProvider pLabelProvider) {
+
+        // Create the tree viewer column
+        final TreeViewerColumn vTreeViewerColumn = createViewerColumn(pTreeViewer, pText, pAlignment, pWidth);
+        
+        // Finally, if a label provider is specified, use it
+        if (pLabelProvider != null) {
+            vTreeViewerColumn.setLabelProvider(pLabelProvider);
+        }
+
+        return vTreeViewerColumn;
+    }
+    
+    /**
+     * Create a {@link TreeViewerColumn} with specific label provider and editing support,
+     * and set its alignment, text and size.
+     * 
+     * @param pTreeViewer The tree viewer which will contain the column
+     * @param pAlignment The column content alignment
+     * @param pText The column text
+     * @param pWidth The column width
+     * @param pLabelProvider The custom label provider to set to this column. Can be null.
+     * @param pEditingSupport The custom editing support to set to this column. Can be null.
+     * @return The created column
+     */
+    public static TreeViewerColumn createViewerColumn(
+        final TreeViewer pTreeViewer,
+        final String pText,
+        final int pAlignment,
+        final int pWidth,
+        final CellLabelProvider pLabelProvider,
+        final EditingSupport pEditingSupport) {
+
+        // Create the tree viewer column
+        final TreeViewerColumn vTreeViewerColumn = 
+            createViewerColumn(pTreeViewer, pText, pAlignment, pWidth, pLabelProvider);
+        
+        // Finally, if an editing support is specified, use it
+        if (pEditingSupport != null) {
+            vTreeViewerColumn.setEditingSupport(pEditingSupport);
+        }
+
+        return vTreeViewerColumn;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/listener/ShowHideAdapter.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/listener/ShowHideAdapter.java
new file mode 100644
index 0000000..e6a7a3d
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/widget/listener/ShowHideAdapter.java
@@ -0,0 +1,383 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.widget.listener;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Text;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+import org.polarsys.esf.core.common.ui.CommonUIActivator.Implementation;
+
+/**
+ * Selection listener used to hide / show a composite on action.
+ * It can typically be used for an advanced button.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ * 
+ */
+public class ShowHideAdapter
+    extends SelectionAdapter {
+
+    /** Default image. */
+    public static final Image DEFAULT_SHOW_IMAGE = CommonUIActivator.getPlugin().getImageRegistry()
+        .get(Implementation.ICON_ADVANCED_SHOW_KEY);
+
+    /** Default image. */
+    public static final Image DEFAULT_HIDE_IMAGE = CommonUIActivator.getPlugin().getImageRegistry()
+        .get(Implementation.ICON_ADVANCED_HIDE_KEY);
+
+    /** Default label. */
+    public static final String DEFAULT_SHOW_LABEL =
+        CommonUIActivator.getMessages().getString("ShowHideAdapter.default.show"); //$NON-NLS-1$
+
+    /** Default label. */
+    public static final String DEFAULT_HIDE_LABEL =
+        CommonUIActivator.getMessages().getString("ShowHideAdapter.default.hide"); //$NON-NLS-1$
+
+    /** Image for advanced button. */
+    private Image mShowAdvancedImage = DEFAULT_SHOW_IMAGE;
+
+    /** Image for advanced button. */
+    private Image mHideAdvancedImage = DEFAULT_HIDE_IMAGE;
+
+    /** Label for advanced button. */
+    private String mShowAdvancedLabel = DEFAULT_SHOW_LABEL;
+
+    /** Label for advanced button. */
+    private String mHideAdvancedLabel = DEFAULT_HIDE_LABEL;
+
+    /** Memorise last status of composite to hide. */
+    private boolean mHidden = false;
+
+    /** Composite to hide/show. */
+    private Composite mCompositeToToggle = null;
+
+    /** Button click to hide/show composite. */
+    private Button mToggleButton = null;
+
+    /** Map of default values associated to controls. */
+    private Map<Control, Object> mDefaultControlsValue = null;
+
+    /**
+     * Default constructor, with default.
+     * 
+     * @param pAdvancedComposite Composite for which hide/show ability must be implemented
+     * @param pButton Button which trigger a switch
+     */
+    public ShowHideAdapter(final Button pButton, final Composite pAdvancedComposite) {
+
+        super();
+
+        mCompositeToToggle = pAdvancedComposite;
+        mToggleButton = pButton;
+
+        // Initialise map of default control values
+        snapshotControlStates();
+
+    }
+
+    /**
+     * Refresh (or create) snapshot of control states.
+     * 
+     * This method is automatically call by constructor.
+     * External call should only be used if composite to show/hide have a structure modification.
+     */
+    public void snapshotControlStates() {
+        if (mCompositeToToggle != null) {
+            mDefaultControlsValue = new HashMap<Control, Object>();
+            rememberDefaultValues(mCompositeToToggle);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void widgetSelected(final SelectionEvent pEvent) {
+        // Negate the hidden status
+        mHidden = !mHidden;
+        switchComposite();
+    }
+
+    /**
+     * Switch Composite, based on hidden status.
+     */
+    private void switchComposite() {
+
+        if (mCompositeToToggle != null) {
+            // Show / hide composite
+            if (mHidden) {
+                hideComposite();
+            } else {
+                showComposite();
+            }
+        }
+
+    }
+
+    /**
+     * Show composite.
+     */
+    private void showComposite() {
+        mCompositeToToggle.setVisible(true);
+        mToggleButton.setText(mHideAdvancedLabel);
+        mToggleButton.setImage(mHideAdvancedImage);
+
+        resizeButton();
+    }
+
+    /**
+     * Hide composite.
+     */
+    private void hideComposite() {
+        mCompositeToToggle.setVisible(false);
+        mToggleButton.setText(mShowAdvancedLabel);
+        mToggleButton.setImage(mShowAdvancedImage);
+
+        restoreDefaultValues(mCompositeToToggle);
+
+        resizeButton();
+    }
+
+    /**
+     * Resize button.
+     */
+    private void resizeButton() {
+        // Compute the button size as the label length can change
+        Point vComputedSize = mToggleButton.computeSize(SWT.DEFAULT, SWT.DEFAULT, true);
+        mToggleButton.setSize(vComputedSize);
+    }
+
+    /**
+     * Construct a map of control / value to be able to restore when main composite is hidden.
+     * It is a recursive method.
+     * 
+     * This method must be recall if composite structure changes.
+     * 
+     * @param pComposite The parent in which children are search
+     */
+    private void rememberDefaultValues(final Composite pComposite) {
+
+        // Iterate through all children of this composite
+        for (Control vChildrenControl : pComposite.getChildren()) {
+            // If this children is itself a composite and have children, explore its children too
+            if (vChildrenControl instanceof Composite) {
+                Composite vCompositeChildren = (Composite) vChildrenControl;
+                if (vCompositeChildren.getChildren().length > 0) {
+                    rememberDefaultValues(vCompositeChildren);
+                }
+            } else {
+                // Remember default value for this child
+                mDefaultControlsValue.put(vChildrenControl, getDefaultValue(vChildrenControl));
+            }
+        }
+
+    }
+
+    /**
+     * From map constructed before, restore default values for children control of given composite.
+     * It is a recursive method.
+     * 
+     * @param pComposite The parent in which children are search
+     */
+    private void restoreDefaultValues(final Composite pComposite) {
+
+        // Iterate through all children of this composite
+        for (Control vChildrenControl : pComposite.getChildren()) {
+
+            // If this children is itself a composite and have children, explore its children too
+            if (vChildrenControl instanceof Composite) {
+                Composite vCompositeChildren = (Composite) vChildrenControl;
+                if (vCompositeChildren.getChildren().length > 0) {
+                    restoreDefaultValues(vCompositeChildren);
+                }
+            } else {
+                // Restore value for this child
+                Object vDefaultValue = mDefaultControlsValue.get(vChildrenControl);
+                if (vDefaultValue != null) {
+                    restoreDefaultValue(vChildrenControl, vDefaultValue);
+                }
+            }
+        }
+    }
+
+    /**
+     * Restore default value for a specific children control.
+     * 
+     * No control are done on default value parameter, because map construction is internal.
+     * 
+     * This method can be override to offer a more specific approach of how value should be restored.
+     * 
+     * @param pChildrenControl Control for which default value will be restore
+     * @param pDefaultValue Default value to restore
+     */
+    protected void restoreDefaultValue(final Control pChildrenControl, final Object pDefaultValue) {
+        if (pChildrenControl instanceof Text) {
+            ((Text) pChildrenControl).setText((String) pDefaultValue);
+        } else if (pChildrenControl instanceof Button) {
+            // For a button, restore selection value. This is a minimal behaviour, not specific. It is because
+            // there is no pretty sure solution to define which kind of widget a button is.
+            Button vButton = (Button) pChildrenControl;
+            vButton.setSelection((Boolean) pDefaultValue);
+        }
+    }
+
+    /**
+     * Find default value for a given control.
+     * Mean of "default value" is specific to kind of control. For a check box, it will be the selected status for
+     * example.
+     * 
+     * This method can be override to offer a more specific approach of how value should be read.
+     * 
+     * @param pChildrenControl Control for which default value is search
+     * @return The default value, null if no one found
+     */
+    protected Object getDefaultValue(final Control pChildrenControl) {
+        Object vDefaultValue = null;
+
+        if (pChildrenControl instanceof Text) {
+            vDefaultValue = ((Text) pChildrenControl).getText();
+        } else if (pChildrenControl instanceof Button) {
+            // For a button, get selection value. This is a minimal behaviour, totally not specific. It is because
+            // there is no pretty sure solution to define which kind of widget a button is.
+            Button vButton = (Button) pChildrenControl;
+            vDefaultValue = vButton.getSelection();
+        }
+
+        return vDefaultValue;
+    }
+
+    /**
+     * @return The showAdvancedImage
+     */
+    public Image getShowAdvancedImage() {
+        return mShowAdvancedImage;
+    }
+
+    /**
+     * @param pShowAdvancedImage The showAdvancedImage to set
+     */
+    public void setShowAdvancedImage(final Image pShowAdvancedImage) {
+        mShowAdvancedImage = pShowAdvancedImage;
+    }
+
+    /**
+     * @return The hideAdvancedImage
+     */
+    public Image getHideAdvancedImage() {
+        return mHideAdvancedImage;
+    }
+
+    /**
+     * @param pHideAdvancedImage The hideAdvancedImage to set
+     */
+    public void setHideAdvancedImage(final Image pHideAdvancedImage) {
+        mHideAdvancedImage = pHideAdvancedImage;
+    }
+
+    /**
+     * @return The hidden
+     */
+    public boolean isHidden() {
+        return mHidden;
+    }
+
+    /**
+     * Set hidden status, and switch composite if possible.
+     * 
+     * @param pHidden The hidden to set
+     */
+    public void setHidden(final boolean pHidden) {
+        mHidden = pHidden;
+        switchComposite();
+    }
+
+    /**
+     * @return The compositeToToggle
+     */
+    public Composite getCompositeToToggle() {
+        return mCompositeToToggle;
+    }
+
+    /**
+     * @param pCompositeToToggle The compositeToToggle to set
+     */
+    public void setCompositeToToggle(final Composite pCompositeToToggle) {
+        mCompositeToToggle = pCompositeToToggle;
+    }
+
+    /**
+     * @return The toggleButton
+     */
+    public Button getToggleButton() {
+        return mToggleButton;
+    }
+
+    /**
+     * @param pToggleButton The toggleButton to set
+     */
+    public void setToggleButton(final Button pToggleButton) {
+        mToggleButton = pToggleButton;
+    }
+
+    /**
+     * @return The showAdvancedLabel
+     */
+    public String getShowAdvancedLabel() {
+        return mShowAdvancedLabel;
+    }
+
+    /**
+     * @param pShowAdvancedLabel The showAdvancedLabel to set
+     */
+    public void setShowAdvancedLabel(final String pShowAdvancedLabel) {
+        mShowAdvancedLabel = pShowAdvancedLabel;
+    }
+
+    /**
+     * @return The hideAdvancedLabel
+     */
+    public String getHideAdvancedLabel() {
+        return mHideAdvancedLabel;
+    }
+
+    /**
+     * @param pHideAdvancedLabel The hideAdvancedLabel to set
+     */
+    public void setHideAdvancedLabel(final String pHideAdvancedLabel) {
+        mHideAdvancedLabel = pHideAdvancedLabel;
+    }
+
+    /**
+     * @return The defaultControlsValue
+     */
+    public Map<Control, Object> getDefaultControlsValue() {
+        return mDefaultControlsValue;
+    }
+
+    /**
+     * @param pDefaultControlsValue The defaultControlsValue to set
+     */
+    public void setDefaultControlsValue(final Map<Control, Object> pDefaultControlsValue) {
+        mDefaultControlsValue = pDefaultControlsValue;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/wizard/AbstractGenericWizard.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/wizard/AbstractGenericWizard.java
new file mode 100644
index 0000000..09a4ff6
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/wizard/AbstractGenericWizard.java
@@ -0,0 +1,266 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.wizard;
+
+import java.lang.reflect.InvocationTargetException;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.MultiStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jface.operation.IRunnableWithProgress;
+import org.eclipse.jface.wizard.Wizard;
+import org.eclipse.ui.statushandlers.StatusManager;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+import org.polarsys.esf.core.common.ui.job.FocusViewJob;
+
+/**
+ * Generic wizard. It handles run of thread and logging, to ensure the same behaviour in all ESF wizards.
+ *
+ * TODO : add an adapt to ask to subclasses if they can send a project back to centralize the
+ * <code>SelectAndRevealResourceJob</code> call.
+ *
+ * @author $Author: jdumont $
+ * @version $Revision: 90 $
+ *
+ */
+public abstract class AbstractGenericWizard
+    extends Wizard {
+
+    /** ID for ESF info log. */
+    private static final String ID_SA_INFO_LOG = "org.polarsys.esf.view.log"; //$NON-NLS-1$
+
+    /** Title for job which focus on info log view after import. */
+    private static final String FOCUS_LOG_JOB_LABEL = CommonUIActivator.getMessages().getString(
+        "AbstractGenericWizard.refresh.workspace"); //$NON-NLS-1$
+
+    /** Constant used to indicate an unknown plugin id. */
+    private static final String UNKNOWN_PLUGIN_ID = "unknown"; //$NON-NLS-1$
+
+    /** Message show to user when finish is successful. */
+    private String mSuccessfulMessage = null;
+
+    /** Thread can be cancel (or not). */
+    private boolean mCancellable = false;
+
+    /**
+     * Default constructor.
+     *
+     * @param pSuccessfulMessage Message show to user when finish is successful.
+     * @param pCancellable true means that process launched will offer options to cancel it
+     */
+    public AbstractGenericWizard(final String pSuccessfulMessage, final boolean pCancellable) {
+        super();
+        setNeedsProgressMonitor(true);
+        mSuccessfulMessage = pSuccessfulMessage;
+        mCancellable = pCancellable;
+    }
+
+    /**
+     * Hook offered to gather information from IHM before running action in non UI thread.
+     *
+     * Default implementation do nothing.
+     */
+    protected void prepareFinish() {
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Do a synchronous call (in same thread than wizard) to prepareFinish, then run a IRunnable in a separate thread.
+     * This configuration need to get information from IHM in prepareFinish().
+     */
+    @Override
+    public boolean performFinish() {
+        prepareFinish();
+
+        // Create job
+        final IRunnableWithProgress vRunnable = new IRunnableWithProgress() {
+
+            /**
+             * {@inheritDoc}
+             */
+            @Override
+            public void run(final IProgressMonitor pMonitor) throws InvocationTargetException, InterruptedException {
+
+                // Perform the finish action and wrap the returned status
+                // to uniform the returns to display
+                IStatus vWrappedStatus = wrapStatus(doFinish(pMonitor));
+
+                // Extract the status type to display it correctly
+                int vHandleType = extractStatusType(vWrappedStatus);
+
+                StatusManager.getManager().handle(vWrappedStatus, vHandleType);
+
+                pMonitor.done();
+
+                // Show log view
+                showFinalView();
+            }
+        };
+
+        // Run job, with no cancel option
+        try {
+            getContainer().run(true, mCancellable, vRunnable);
+
+        } catch (final InvocationTargetException | InterruptedException pException) {
+            CommonUIActivator.logError(pException.getMessage(), pException);
+        }
+
+        // Always return true, as the wizard must not be kept opened even if something goes wrong
+        return true;
+    }
+
+    /**
+     * Wrap a given status to uniform how the returns are displayed
+     * in the log view. If no status is given, build a default OK status.
+     *
+     * @see AbstractGenericWizard#buildWrappedStatus(IStatus)
+     *
+     * @param pStatus A given status or null if no specific return is available
+     * @return The wrapped status
+     */
+    protected IStatus wrapStatus(final IStatus pStatus) {
+
+        IStatus vWrappedStatus = null;
+
+        // Check the given status
+        if (pStatus == null) {
+            // No status is given, build a new default OK status
+            // to uniform the return in case of success
+            vWrappedStatus = new Status(Status.OK, CommonUIActivator.getPlugin().getSymbolicName(), mSuccessfulMessage);
+
+        } else {
+            // A status is given, thus extract its information if possible
+            // to build the wrapped status
+            vWrappedStatus = buildWrappedStatus(pStatus);
+
+        }
+
+        return vWrappedStatus;
+    }
+
+    /**
+     * Build a wrapped status from a one, to uniform how the returns are displayed
+     * in the log view. The wrapped status can manage the multi status.
+     *
+     * @param pStatus A given status, which must not be null
+     * @return The wrapped status built
+     */
+    protected IStatus buildWrappedStatus(final IStatus pStatus) {
+        IStatus vWrappedStatus = null;
+
+        // Extract the status message, or take the 'successful' message for this
+        // action if the status is OK or Info or Warning
+        String vStatusMessage = null;
+        switch (pStatus.getSeverity()) {
+            case IStatus.OK:
+            case IStatus.INFO:
+            case IStatus.WARNING:
+                vStatusMessage = mSuccessfulMessage;
+                break;
+            default:
+                if (StringUtils.isNotEmpty(pStatus.getMessage())) {
+                    vStatusMessage = pStatus.getMessage();
+                }
+                break;
+
+        }
+
+        // Extract the status plugin id, or take the generic
+        // plugin if its not given
+        String vStatusPlugin = CommonUIActivator.getPlugin().getSymbolicName();
+        if (StringUtils.isNotEmpty(pStatus.getPlugin()) && !UNKNOWN_PLUGIN_ID.equals(pStatus.getPlugin())) {
+            vStatusPlugin = pStatus.getPlugin();
+        }
+
+        if (pStatus.isMultiStatus()) {
+            // Build a new status to wrap the given multi status, and ensure
+            // to always display a uniform return
+            vWrappedStatus = new MultiStatus(vStatusPlugin, pStatus.getCode(), vStatusMessage, pStatus.getException());
+
+            // Merge the status children to keep all the status stack
+            // NB : This will set the multi-status severity according to the children
+            // maximum severity
+            ((MultiStatus) vWrappedStatus).merge(pStatus);
+
+        } else {
+            // Build a new status to wrap the given single status, and ensure
+            // to always display uniform return
+            vWrappedStatus = new Status(pStatus.getSeverity(), vStatusPlugin, vStatusMessage);
+        }
+
+        return vWrappedStatus;
+    }
+
+    /**
+     * Extract the type of a status to know how it can be added
+     * in the status manager. By default it's always a 'LOG', and if
+     * the status is an error, add the 'BLOCK' type.
+     *
+     * @param pStatus The given status from which the type must be extracted, or null
+     * @return The status type found
+     */
+    protected int extractStatusType(final IStatus pStatus) {
+
+        // By default, the status is a log
+        int vStatusType = StatusManager.LOG;
+
+        if ((pStatus != null) && pStatus.matches(Status.ERROR)) {
+            // If the status given is an error, add the Block type
+            vStatusType |= StatusManager.BLOCK;
+        }
+
+        return vStatusType;
+    }
+
+    /**
+     * @return The successfulMessage
+     */
+    protected String getSuccessfulMessage() {
+        return mSuccessfulMessage;
+    }
+
+    /**
+     * @param pSuccessfulMessage The successfulMessage to set
+     */
+    protected void setSuccessfulMessage(final String pSuccessfulMessage) {
+        mSuccessfulMessage = pSuccessfulMessage;
+    }
+
+    /**
+     * Show a specific view at the end of the wizard. By default, show log view.
+     */
+    protected void showFinalView() {
+        FocusViewJob vJob = new FocusViewJob(FOCUS_LOG_JOB_LABEL, ID_SA_INFO_LOG);
+        vJob.schedule();
+    }
+
+    /**
+     * Do the concrete job for this wizard.
+     *
+     * Expected behaviour is that the subclass will return an IStatus with error if something goes wrong, or null
+     * otherwise.<br/>
+     * <br/>
+     *
+     * <b>Warning</b> : the <code>pMonitor.done()</code> should not be called in implementation, because performFinish()
+     * will do it after logging final message.<br/>
+     *
+     * <b>Warning</b> : the code in this method will be run in a non UI Thread. To get information from UI, do it before
+     * in {@link AbstractGenericWizard#prepareFinish()}.
+     * If an UI operation is done (like send focus to a specific view), call it in an UIJob.
+     *
+     * @param pMonitor Monitor used to follow job progression
+     * @return an exception if something goes wrong, or null otherwise
+     */
+    protected abstract IStatus doFinish(IProgressMonitor pMonitor);
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/wizard/NotImplementedWizard.java b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/wizard/NotImplementedWizard.java
new file mode 100644
index 0000000..cdd0590
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/java/org/polarsys/esf/core/common/ui/wizard/NotImplementedWizard.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2015 ALL4TEC.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Jonathan Dumont (ALL4TEC) - initial API and implementation
+ ******************************************************************************/
+package org.polarsys.esf.core.common.ui.wizard;
+
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.wizard.Wizard;
+import org.eclipse.ui.IExportWizard;
+import org.eclipse.ui.IImportWizard;
+import org.eclipse.ui.IWorkbench;
+import org.polarsys.esf.core.common.ui.CommonUIActivator;
+
+/**
+ * 
+ * Wizard "not implemented", used to link with import not implemented yet.
+ * 
+ * @author $Author: jdumont $
+ * @version $Revision: 83 $
+ */
+public class NotImplementedWizard
+    extends Wizard
+    implements IImportWizard, IExportWizard {
+
+    /** Title for dialog. */
+    private static final String DIALOG_MSG =
+        CommonUIActivator.getMessages().getString("NotImplementedWizard.warning.implemented.not.label"); //$NON-NLS-1$
+
+    /** Msg for dialog. */
+    private static final String DIALOG_TITLE =
+        CommonUIActivator.getMessages().getString("NotImplementedWizard.warning.implemented.not.title"); //$NON-NLS-1$
+
+    /**
+     * Default constructor.
+     */
+    public NotImplementedWizard() {
+        MessageDialog.openInformation(getShell(), DIALOG_TITLE, DIALOG_MSG);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void init(final IWorkbench pWorkbench, final IStructuredSelection pSelection) {
+        // Nothing to do here.
+
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean performFinish() {
+        // Nothing to do here.
+        return false;
+    }
+
+}
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/advanced_hide.png b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/advanced_hide.png
new file mode 100644
index 0000000..08f2493
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/advanced_hide.png
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/advanced_show.png b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/advanced_show.png
new file mode 100644
index 0000000..6332fef
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/advanced_show.png
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/collapse_all.gif b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/collapse_all.gif
new file mode 100644
index 0000000..a2d80a9
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/collapse_all.gif
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/dialog_probability.png b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/dialog_probability.png
new file mode 100644
index 0000000..aa6e559
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/dialog_probability.png
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/expand_all.gif b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/expand_all.gif
new file mode 100644
index 0000000..0205b29
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/expand_all.gif
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_addone.png b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_addone.png
new file mode 100644
index 0000000..ad35b69
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_addone.png
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_down.png b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_down.png
new file mode 100644
index 0000000..c3ee989
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_down.png
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_removeone.png b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_removeone.png
new file mode 100644
index 0000000..758c196
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_removeone.png
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_up.png b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_up.png
new file mode 100644
index 0000000..017232a
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/icon_up.png
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/rule/icon_exponential_rule.png b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/rule/icon_exponential_rule.png
new file mode 100644
index 0000000..b19c199
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/rule/icon_exponential_rule.png
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/rule/icon_poisson_rule.png b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/rule/icon_poisson_rule.png
new file mode 100644
index 0000000..97d9858
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/rule/icon_poisson_rule.png
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/rule/icon_weibull_rule.png b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/rule/icon_weibull_rule.png
new file mode 100644
index 0000000..659c235
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/rule/icon_weibull_rule.png
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/search.gif b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/search.gif
new file mode 100644
index 0000000..13fe1dd
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/icons/search.gif
Binary files differ
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/properties/nls/messages.properties b/core/org.polarsys.esf.core.common.ui/src/main/resources/properties/nls/messages.properties
new file mode 100644
index 0000000..11f4a67
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/properties/nls/messages.properties
@@ -0,0 +1,97 @@
+
+ActionBarContributorUtils.actions.collapseall        = Collapse all
+ActionBarContributorUtils.actions.expandall          = Expand all
+ActionBarContributorUtils.actions.refresh            = &Refresh
+ActionBarContributorUtils.actions.showpropertiesview = Show &Properties View
+ActionBarContributorUtils.menu.child.new             = &New
+
+AbstractColumnViewerPage.action.showheaders      = Show Header
+AbstractColumnViewerPage.action.showlines        = Show Lines
+AbstractColumnViewerPage.label.columnsvisibility = Choose the columns visibility :
+AbstractColumnViewerPage.menu.columnsvisibility  = Columns Visibility
+AbstractColumnViewerPage.title.columnsvisibility = Columns Visibility
+
+AbstractGenericWizard.job.focus = Show info log
+
+AbstractMultiPageEditor.fileconflict.message            = There are unsaved changes that conflict with changes made outside the editor. Do you wish to discard this editor's changes?
+AbstractMultiPageEditor.fileconflict.title              = File Conflict
+AbstractMultiPageEditor.requiredcolumn.header           = Name
+AbstractMultiPageEditor.statusline.multiobjectsselected = Selected {0} Objects
+AbstractMultiPageEditor.statusline.noobjectselected     = Nothing Selected
+AbstractMultiPageEditor.statusline.singleobjectselected = Selected Object: {0}
+
+AbstractPage.multiobjectsselected = Selected {0} Objects
+AbstractPage.noobjectselected     = Selected Nothing
+AbstractPage.oneobjectselected    = Selected Object: {0}
+
+AbstractProbabilityRule.description.exponential    = The exponential distribution (a.k.a. negative exponential distribution) is the probability distribution that describes the time between events in a Poisson process, i.e. a process in which events occur continuously and independently at a constant average rate. It is the continuous analogue of the geometric distribution, and it has the key property of being memoryless. In addition to being used for the analysis of Poisson processes, it is found in various other contexts.
+AbstractProbabilityRule.description.poisson        = The Poisson distribution is a discrete probability distribution that expresses the probability of a given number of events occurring in a fixed interval of time and/or space if these events occur with a known average rate and independently of the time since the last event. The Poisson distribution can also be used for the number of events in other specified intervals such as distance, area or volume.
+AbstractProbabilityRule.description.weibull        = Its complementary cumulative distribution function is a stretched exponential function. The Weibull distribution is related to a number of other probability distributions; in particular, it interpolates between the exponential distribution (\u03B2 = 1) and the Rayleigh distribution (\u03B2 = 2).\r\n\r\n\
+The parameters of distribution are \u03B2 (> 0), the shape parameter, and \u03BB (> 0), the scale. \
+If the quantity t is a "time-to-failure", the Weibull distribution gives a distribution for which the failure rate is proportional to a power of time. The shape parameter, \u03B2, is that power plus one, and so this parameter can be interpreted directly as follows:\r\n\
+- A value of \u03B2 < 1 indicates that the failure rate decreases over time. This happens if there is significant "infant mortality", or defective items failing early and the failure rate decreasing over time as the defective items are weeded out of the population.\r\n\
+- A value of \u03B2 = 1 indicates that the failure rate is constant over time. This might suggest random external events are causing mortality, or failure.\r\n\
+- A value of \u03B2 > 1 indicates that the failure rate increases with time. This happens if there is an "aging" process, or parts that are more likely to fail as time goes on.\r\n
+
+AbstractProbabilityRuleComposite.header.parameters = Parameter
+AbstractProbabilityRuleComposite.header.value      = Value
+AbstractProbabilityRuleComposite.label.description = Description :
+AbstractProbabilityRuleComposite.label.formula     = Formula :
+AbstractProbabilityRuleComposite.label.parameters  = Parameters :
+
+AbstractSAModelPageBookView.defaultPage.label = Open an editor
+
+AbstractTreePage.action.collapseall = Collapse All
+AbstractTreePage.action.expandall   = Expand All
+
+ActiveProjectControlContribution.default.projectname = No active project
+
+FearedEventsLibraryAssociationDialog.label = Select feared events item :
+FearedEventsLibraryAssociationDialog.title = Feared Events Library Association
+
+FilterComposite.clearfilter.tooltip = Clear filter text
+FilterComposite.search.tooltip      = Choose the part on which you want to apply the filter
+FilterComposite.text.defaulttext    = Type filter text
+FilterComposite.text.tooltip        = (? = any character, * = any String)
+
+GroupFileModelCreator.group.title = Model selection
+GroupFileModelCreator.label       = ESF file :
+
+NotImplementedWizard.warning.implemented.not.label = This wizard has not been implemented
+NotImplementedWizard.warning.implemented.not.title = Not implemented yet
+
+ParameterValueEditingSupport.warning.notnumerical = The value of the parameter must be numerical
+
+ProbabilityEditDialog.confirmdelete.cancel    = Cancel
+ProbabilityEditDialog.confirmdelete.notdelete = Do not delete
+ProbabilityEditDialog.confirmdelete.delete    = Delete
+ProbabilityEditDialog.confirmdelete.message   = No probability value is given, do you want to delete the probability ?
+ProbabilityEditDialog.confirmdelete.title     = Delete probability
+ProbabilityEditDialog.error.probabilityvalue  = The probability value must be a positive numeric, lesser or equal to 1.
+ProbabilityEditDialog.group.origin.title      = Origin
+ProbabilityEditDialog.group.propability.title = Probability
+ProbabilityEditDialog.label.description       = Description :
+ProbabilityEditDialog.label.origin            = Type of origin :
+ProbabilityEditDialog.label.value             = Value :
+ProbabilityEditDialog.message                 = This dialog helps you to edit the probabilities of an object.
+ProbabilityEditDialog.title                   = Probabilities edition
+
+ProbabilityEditManager.rule.exponential = Exponential rule
+ProbabilityEditManager.rule.poisson = Poisson rule
+ProbabilityEditManager.rule.weibull = Weibull rule
+
+ProbabilityOriginEnum.exponentialorigin = Exponential rule
+ProbabilityOriginEnum.poissonorigin     = Poisson rule
+ProbabilityOriginEnum.textualorigin     = Textual origin
+ProbabilityOriginEnum.weibullorigin     = Weibull rule
+
+RunnableLoadModel.task.sa = Loading ESF file
+
+SelectAndRevealResourceJob.title = Select and reveal resource
+
+ShowHideAdapter.default.hide = Hide
+ShowHideAdapter.default.show = Advanced
+
+ShowReportPerspectiveJob.msg.dialogbox   = Do you want to open the Report perspective?
+ShowReportPerspectiveJob.title.dialogbox = Open Report perspective
+
diff --git a/core/org.polarsys.esf.core.common.ui/src/main/resources/properties/plugin.properties b/core/org.polarsys.esf.core.common.ui/src/main/resources/properties/plugin.properties
new file mode 100644
index 0000000..5099dbd
--- /dev/null
+++ b/core/org.polarsys.esf.core.common.ui/src/main/resources/properties/plugin.properties
@@ -0,0 +1,6 @@
+#Properties file for org.polarsys.esf.core.common.ui
+Bundle-Vendor = Polarsys
+Bundle-Name = ESF Common UI
+
+toolbar.activeproject.label = Active project toolbar
+toolbar.filter.label = Filter editor toolbar
\ No newline at end of file