[517560] Improved root element inference for new semantic model creation

Root element target of self contained EReference are no more filtered.

Checking that an EReference references a candidate EClass now takes in
consideration all EClass not abstract or interface instead of just the
one not already filtered.

EClass not containing any containment EReference are now removed from
possible root elements.

Bug: 517560
Change-Id: I8ecf6d35cbdfe341335c87822969f9eade698d05
Signed-off-by: pguilet <pierre.guilet@obeo.fr>

2 files changed, 369 insertions, 122 deletions

diff --git a/plugins/org.eclipse.sirius.common/src/org/eclipse/sirius/common/tools/internal/ecore/EPackageHelper.java b/plugins/org.eclipse.sirius.common/src/org/eclipse/sirius/common/tools/internal/ecore/EPackageHelper.java
new file mode 100644
index 0000000000..c2e4ff19c3
--- /dev/null
+++ b/plugins/org.eclipse.sirius.common/src/org/eclipse/sirius/common/tools/internal/ecore/EPackageHelper.java
@@ -0,0 +1,267 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Obeo
+ * 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:
+ *     Obeo - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.sirius.common.tools.internal.ecore;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.sirius.common.tools.DslCommonPlugin;
+import org.eclipse.sirius.common.tools.api.ecore.EPackageMetaData;
+
+/**
+ * Helper providing methods to extract {@link EClass} fitting some constraints from {@link EPackage}.
+ * 
+ * @author <a href="mailto:pierre.guilet@obeo.fr">Pierre Guilet</a>
+ *
+ */
+public final class EPackageHelper {
+
+    /**
+     * Private constructor for utility class.
+     */
+    private EPackageHelper() {
+    }
+
+    /**
+     * Get the concrete classes from the given {@link EPackage} (classes that are not abstract and that are not
+     * interfaces).
+     * 
+     * @param ePackage
+     *            the given {@link EPackage}.
+     * @return the concrete classes from the given {@link EPackage}.
+     */
+    public static List<EClass> getConcreteClasses(EPackage ePackage) {
+        List<EClass> concreteClasses = new ArrayList<>();
+        if (ePackage != null) {
+            for (EClassifier eClassifier : ePackage.getEClassifiers()) {
+                if (eClassifier instanceof EClass && !((EClass) eClassifier).isAbstract() && !((EClass) eClassifier).isInterface()
+                        && ((EClass) eClassifier).getEAllReferences().stream().anyMatch(EReference::isContainment)) {
+                    concreteClasses.add((EClass) eClassifier);
+                }
+            }
+        }
+        return concreteClasses;
+    }
+
+    /**
+     * Return a list of potential root element {@link EClass} for a given {@link EPackage}. This list is ordered from
+     * the most likely root element to the least.
+     * 
+     * @param ePackage
+     *            the given {@link EPackage}.
+     * @return a list of potential root element {@link EClass} for a given {@link EPackage}.
+     */
+    public static List<EClass> getEClassRootElements(EPackage ePackage) {
+        /*
+         * We'll only consider actually instanciable classes.
+         */
+        List<EClass> concreteClasses = getConcreteClasses(ePackage);
+
+        /*
+         * If we have explicit metadata associated with the EPackage, use the suggested roots.
+         */
+        if (ePackage != null) {
+            String nsURI = ePackage.getNsURI();
+            EPackageMetaData metaData = DslCommonPlugin.INSTANCE.getEPackageMetaData(nsURI);
+            List<EClass> roots = new ArrayList<>();
+            if (metaData != null && !metaData.getSuggestedRoots().isEmpty()) {
+                roots = concreteClasses.stream().filter(c -> metaData.getSuggestedRoots().contains(c.getName())).collect(Collectors.toList());
+            }
+            if (!roots.isEmpty()) {
+                return roots;
+            }
+        }
+
+        /*
+         * Otherwise, or if there is no instanciable suggested root, try to infer good candidates from the metamodel's
+         * structure (i.e. prefer elements which are not contained by anything).
+         */
+        Map<EClass, Integer> inferredRootElementsCandidates = inferRootElementsCandidates(ePackage, concreteClasses);
+        List<EClass> sortedResults = new ArrayList<EClass>();
+        sortedResults.addAll(inferredRootElementsCandidates.keySet());
+        Collections.sort(sortedResults, new Comparator<EClass>() {
+            @Override
+            public int compare(EClass eClass1, EClass eClass2) {
+                return inferredRootElementsCandidates.get(eClass2).compareTo(inferredRootElementsCandidates.get(eClass1));
+            }
+        });
+        return sortedResults;
+    }
+
+    private static Map<EClass, Integer> inferRootElementsCandidates(EPackage ePackage, Collection<EClass> concreteClasses) {
+        Map<EClass, Integer> eClassToRootScore = new HashMap<>();
+        List<EClass> allClasses = ePackage.getEClassifiers().stream().filter(c -> c instanceof EClass).map(c -> (EClass) c).collect(Collectors.toList());
+        for (EClass eClass : concreteClasses) {
+            // Element without containment relations are not considered as root elements.
+            if (eClass.getEAllReferences().stream().anyMatch(EReference::isContainment)) {
+                int importance = getReferenceScore(eClass, allClasses);
+                if (importance != -1) {
+                    eClassToRootScore.put(eClass, importance);
+                }
+            }
+        }
+        return eClassToRootScore;
+    }
+
+    /**
+     * Returns the reference score of the given EClass among given EClasses.
+     * <ul>
+     * <li>A score of -1 means the given EClass is referenced by another EClass among given EClasses. This other EClass
+     * is not a super type of target EClass. Target EClass has not a containment reference from its concrete or super
+     * types to the other one.</li>
+     * <li>A score greater than -1 means the given EClass is not referenced by given EClasses and that it contains n
+     * containment references from concrete or super types and recursively through the ETypes of the references.</li>
+     * </ul>
+     * 
+     * @param eClassToTest
+     *            the EClass from which we want to know if it is contained.
+     * @param allEClasses
+     *            all the ECLass from which we check if they have an EReference to the given EClass.
+     * @return the reference score of the given EClass among given EClasses.
+     */
+    private static int getReferenceScore(EClass eClassToTest, Collection<EClass> allEClasses) {
+        EList<EReference> targetReferences = eClassToTest.getEAllReferences();
+
+        int score = 0;
+        Iterator<EClass> allEClassesIte = allEClasses.iterator();
+        while (allEClassesIte.hasNext() && score != -1) {
+            EClass eClass = allEClassesIte.next();
+            Set<EReference> references = eClass.getEAllReferences().stream().filter(EReference::isContainment).collect(Collectors.toSet());
+            Iterator<EReference> referencesIte = references.iterator();
+            while (referencesIte.hasNext() && score != -1) {
+                EReference eReference = referencesIte.next();
+                EClassifier referedClassifier = eReference.getEType();
+                boolean typeReferenced = eClassToTest.getEAllSuperTypes().contains(referedClassifier) || eClassToTest.equals(referedClassifier);
+                boolean notReferencedByEClassSuperType = !(eClass.isSuperTypeOf(eClassToTest));
+                boolean notReferencedByAContainedEClass = !targetReferences.stream()
+                        .anyMatch(ref -> ref.isContainment() && (eClass.getEAllSuperTypes().contains(ref.getEType()) || eClass.equals(ref.getEType())));
+                boolean isReferenced = typeReferenced && notReferencedByEClassSuperType && notReferencedByAContainedEClass;
+                if (isReferenced) {
+                    Set<EClass> eClassCheckedSet = new HashSet<EClass>();
+                    if (!eClassContainsRecursively(eClassToTest, eClass, eClassCheckedSet)) {
+                        score = -1;
+                    }
+                }
+            }
+        }
+        if (score == 0) {
+            Set<EClass> eClassCheckedSet = new HashSet<EClass>();
+            score = computeScoreRecursively(eClassToTest, eClassCheckedSet);
+        }
+        return score;
+    }
+
+    /**
+     * Compute and return the score of an element considered as a root element. The score is the total number of
+     * containment EReference of the element and all the elements that are EType of these references recursively.
+     * 
+     * @param targetEClass
+     *            EClass from which we compute the root likely score.
+     * @param eClassCheckedSet
+     *            A set of EClass that has been visited while computing recursively containment link.
+     * @return the score of an element considered as a root element.
+     */
+    private static int computeScoreRecursively(EClass targetEClass, Set<EClass> eClassCheckedSet) {
+        int score = 0;
+        // if we visited already the EClass we stop to avoid infinite computing.
+        if (!eClassCheckedSet.contains(targetEClass)) {
+            eClassCheckedSet.add(targetEClass);
+            List<EReference> eAllReferences = targetEClass.getEAllReferences();
+            for (EReference eReference : eAllReferences) {
+                if (eReference.isContainment()) {
+                    score += 1;
+                    EClassifier eType = eReference.getEType();
+                    if (eType instanceof EClass) {
+                        score += computeScoreRecursively((EClass) eType, eClassCheckedSet);
+                    }
+                }
+            }
+        }
+        return score;
+    }
+
+    /**
+     * Return true if the given target EClass contains the given other EClass from recursive containment references
+     * flow.
+     * 
+     * @param targetEClass
+     *            the EClass from which we want to know if it contains the other from recursive containment references
+     *            flow.
+     * @param eClassContainedRecursively
+     *            the EClass from which we want to know if it contained by the other from recursive containment
+     *            references flow.
+     * @param eClassCheckedSet
+     *            A set of EClass that has been visited while computing recursively containment link.
+     * @return true if the given target EClass contains the given other EClass from recursive containment references
+     *         flow. False otherwise.
+     */
+    private static boolean eClassContainsRecursively(EClass targetEClass, EClass eClassContainedRecursively, Set<EClass> eClassCheckedSet) {
+        boolean containedRecursively = false;
+        // if we visited already the EClass we stop to avoid infinite computing.
+        if (!eClassCheckedSet.contains(targetEClass)) {
+            eClassCheckedSet.add(targetEClass);
+            List<EReference> eAllReferences = targetEClass.getEAllReferences();
+            Set<EClass> referencedEClasses = new HashSet<>();
+            for (EReference eReference : eAllReferences) {
+                EClassifier eType = eReference.getEType();
+                if (eReference.isContainment() && eType instanceof EClass) {
+                    EClass referencedEClass = (EClass) eType;
+                    referencedEClasses.add(referencedEClass);
+                    if (eClassContainedRecursively.equals(referencedEClass) || eClassContainedRecursively.getEAllSuperTypes().contains(referencedEClass)) {
+                        return true;
+                    }
+                }
+            }
+            Iterator<EClass> referecedEClassesIte = referencedEClasses.iterator();
+            while (referecedEClassesIte.hasNext() && !containedRecursively) {
+                EClass referencedEClass = referecedEClassesIte.next();
+                containedRecursively = eClassContainsRecursively(referencedEClass, eClassContainedRecursively, eClassCheckedSet);
+            }
+        }
+        return containedRecursively;
+    }
+
+    /**
+     * Get the preferred root element for the given {@link EPackage} from the registry of EPackageExtraData.
+     * 
+     * @see EPackageExtraDataRegistry
+     * @param ePackage
+     *            the given {@link EPackage}.
+     * @return the preferred root element for the given {@link EPackage}, or null if it can't be found.
+     */
+    public static EClass getPreferredRootElementFromEPackageExtraData(EPackage ePackage) {
+        if (ePackage != null) {
+            String nsURI = ePackage.getNsURI();
+            EPackageMetaData metaData = DslCommonPlugin.INSTANCE.getEPackageMetaData(nsURI);
+            if (metaData != null && !metaData.getSuggestedRoots().isEmpty()) {
+                EClassifier result = ePackage.getEClassifier(metaData.getSuggestedRoots().get(0));
+                if (result instanceof EClass) {
+                    return (EClass) result;
+                }
+            }
+        }
+        return null;
+    }
+}
diff --git a/plugins/org.eclipse.sirius.ui/src/org/eclipse/sirius/ui/tools/internal/wizards/newmodel/SelectRootElementWizardPage.java b/plugins/org.eclipse.sirius.ui/src/org/eclipse/sirius/ui/tools/internal/wizards/newmodel/SelectRootElementWizardPage.java
index 7a77109a88..25ab4fc3b6 100644
--- a/plugins/org.eclipse.sirius.ui/src/org/eclipse/sirius/ui/tools/internal/wizards/newmodel/SelectRootElementWizardPage.java
+++ b/plugins/org.eclipse.sirius.ui/src/org/eclipse/sirius/ui/tools/internal/wizards/newmodel/SelectRootElementWizardPage.java
@@ -12,22 +12,21 @@ package org.eclipse.sirius.ui.tools.internal.wizards.newmodel;
 
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
 import java.util.List;
-import java.util.stream.Collectors;
 
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.provider.EcoreEditPlugin;
 import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ITreeContentProvider;
 import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.jface.viewers.TableViewer;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.jface.viewers.ViewerFilter;
 import org.eclipse.jface.wizard.WizardPage;
-import org.eclipse.sirius.common.tools.DslCommonPlugin;
-import org.eclipse.sirius.common.tools.api.ecore.EPackageMetaData;
+import org.eclipse.sirius.common.tools.internal.ecore.EPackageHelper;
 import org.eclipse.sirius.viewpoint.provider.Messages;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.CLabel;
@@ -41,7 +40,6 @@ import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Text;
-import org.eclipse.ui.dialogs.FilteredList;
 
 /**
  * A wizard page allowing to select a root element ({@link EClass}) from an {@link EPackage}.
@@ -49,6 +47,8 @@ import org.eclipse.ui.dialogs.FilteredList;
  * @see CreateEMFModelWizard
  * 
  * @author <a href="mailto:axel.richard@obeo.fr">Axel Richard</a>
+ * @author <a href="mailto:pierre.guilet@obeo.fr">Pierre Guilet</a>
+ *
  */
 public class SelectRootElementWizardPage extends WizardPage implements PropertyChangeListener {
 
@@ -66,7 +66,7 @@ public class SelectRootElementWizardPage extends WizardPage implements PropertyC
     private Button rootElementCheckbox;
 
     /** The list of root elements. */
-    private FilteredList rootElementFilteredList;
+    private TableViewer rootElementFilteredList;
 
     /** The filter used by the text field and the filtered list. */
     private String rootElementFilter;
@@ -75,6 +75,11 @@ public class SelectRootElementWizardPage extends WizardPage implements PropertyC
     private CreateEMFModelWizardDataModel dataModel;
 
     /**
+     * Filter selecting elements if they match a given regular expression.
+     */
+    private RegexpViewerFilter filter;
+
+    /**
      * Default constructor for this page.
      * 
      * @param dataModel
@@ -90,14 +95,14 @@ public class SelectRootElementWizardPage extends WizardPage implements PropertyC
     /**
      * Sets the filter pattern.
      *
-     * @param filter
+     * @param theFilter
      *            the filter pattern.
      */
-    public void setRootElementFilter(String filter) {
+    public void setRootElementFilter(String theFilter) {
         if (this.rootElementText == null) {
-            this.rootElementFilter = filter;
+            this.rootElementFilter = theFilter;
         } else {
-            this.rootElementText.setText(filter);
+            this.rootElementText.setText(theFilter);
         }
     }
 
@@ -107,6 +112,7 @@ public class SelectRootElementWizardPage extends WizardPage implements PropertyC
      * @param parent
      *            the parent composite.
      */
+    @Override
     public void createControl(Composite parent) {
         Composite container = new Composite(parent, SWT.NULL);
 
@@ -134,12 +140,16 @@ public class SelectRootElementWizardPage extends WizardPage implements PropertyC
         this.rootElementText = new Text(parent, SWT.BORDER);
         this.rootElementText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
         this.rootElementText.setText(this.rootElementFilter == null ? "" : this.rootElementFilter); //$NON-NLS-1$
-        this.rootElementText.addListener(SWT.Modify, event -> this.rootElementFilteredList.setFilter(this.rootElementText.getText()));
+        this.rootElementText.addListener(SWT.Modify, event -> {
+            filter.setFilter(this.rootElementText.getText());
+            rootElementFilteredList.refresh(true);
+
+        });
         this.rootElementText.addKeyListener(new KeyAdapter() {
             @Override
             public void keyPressed(KeyEvent e) {
                 if (e.keyCode == SWT.ARROW_DOWN) {
-                    rootElementFilteredList.setFocus();
+                    rootElementFilteredList.getTable().setFocus();
                 }
             }
         });
@@ -172,15 +182,40 @@ public class SelectRootElementWizardPage extends WizardPage implements PropertyC
      *            the parent composite.
      */
     private void createRootElementFilteredList(Composite parent) {
-        this.rootElementFilteredList = new FilteredList(parent, SWT.BORDER | SWT.FULL_SELECTION | SWT.V_SCROLL | SWT.H_SCROLL | SWT.SINGLE, new RootElementsListLabelProvider(), true, false, false);
-        this.rootElementFilteredList.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
-        this.rootElementFilteredList.setFilter(this.rootElementFilter == null ? "" : this.rootElementFilter); //$NON-NLS-1$
-        this.rootElementFilteredList.addSelectionListener(new SelectionAdapter() {
+        this.rootElementFilteredList = new TableViewer(parent, SWT.BORDER | SWT.FULL_SELECTION | SWT.V_SCROLL | SWT.H_SCROLL | SWT.SINGLE);
+        this.rootElementFilteredList.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
+        this.filter = new RegexpViewerFilter();
+        this.filter.setFilter(this.rootElementFilter == null ? "" : this.rootElementFilter); //$NON-NLS-1$
+        this.rootElementFilteredList.setFilters(filter);
+        this.rootElementFilteredList.addSelectionChangedListener((event) -> {
+            updateSelectedRootElement();
+        });
+        this.rootElementFilteredList.setContentProvider(new ITreeContentProvider() {
+
             @Override
-            public void widgetSelected(SelectionEvent e) {
-                updateSelectedRootElement();
+            public boolean hasChildren(Object element) {
+                return false;
+            }
+
+            @Override
+            public Object getParent(Object element) {
+                return null;
+            }
+
+            @Override
+            public Object[] getElements(Object inputElement) {
+                if (inputElement instanceof Object[]) {
+                    return (Object[]) inputElement;
+                }
+                return new Object[0];
+            }
+
+            @Override
+            public Object[] getChildren(Object parentElement) {
+                return new Object[0];
             }
         });
+        this.rootElementFilteredList.setLabelProvider(new RootElementsListLabelProvider());
     }
 
     @Override
@@ -195,18 +230,22 @@ public class SelectRootElementWizardPage extends WizardPage implements PropertyC
      * Update the selected root element and validate the page.
      */
     private void updateSelectedRootElement() {
-        Object[] selection = this.rootElementFilteredList.getSelection();
-        if (selection.length == 1) {
-            this.dataModel.setSelectedRootElement((EClass) selection[0]);
-            setPageComplete(true);
-        } else {
-            EClass preferredRootElement = getPreferredRootElementFromEPackageExtraData(this.dataModel.getSelectedPackage());
-            if (preferredRootElement != null) {
-                this.dataModel.setSelectedRootElement(preferredRootElement);
+        ISelection selection = this.rootElementFilteredList.getSelection();
+        if (selection instanceof StructuredSelection) {
+            StructuredSelection structuredSelection = (StructuredSelection) selection;
+            Object[] selectionArray = structuredSelection.toArray();
+            if (selectionArray.length == 1) {
+                this.dataModel.setSelectedRootElement((EClass) selectionArray[0]);
                 setPageComplete(true);
             } else {
-                this.dataModel.setSelectedRootElement(null);
-                setPageComplete(false);
+                EClass preferredRootElement = EPackageHelper.getPreferredRootElementFromEPackageExtraData(this.dataModel.getSelectedPackage());
+                if (preferredRootElement != null) {
+                    this.dataModel.setSelectedRootElement(preferredRootElement);
+                    setPageComplete(true);
+                } else {
+                    this.dataModel.setSelectedRootElement(null);
+                    setPageComplete(false);
+                }
             }
         }
     }
@@ -216,117 +255,58 @@ public class SelectRootElementWizardPage extends WizardPage implements PropertyC
      */
     private void updateRootElementFilteredList() {
         if (this.rootElementCheckbox != null) {
-            Object[] classesArray;
+            Object[] rootElements;
             if (this.rootElementCheckbox.getSelection()) {
-                classesArray = getFilteredConcreteClasses(this.dataModel.getSelectedPackage()).toArray();
+                List<EClass> eClassRootElements = EPackageHelper.getEClassRootElements(this.dataModel.getSelectedPackage());
+                rootElements = eClassRootElements.toArray();
             } else {
-                classesArray = getConcreteClasses(this.dataModel.getSelectedPackage()).toArray();
+                rootElements = EPackageHelper.getConcreteClasses(this.dataModel.getSelectedPackage()).toArray();
             }
-            this.rootElementFilteredList.setElements(classesArray);
-            EClass preferredRootElement = getPreferredRootElementFromEPackageExtraData(this.dataModel.getSelectedPackage());
+            this.rootElementFilteredList.setInput(rootElements);
+            EClass preferredRootElement = EPackageHelper.getPreferredRootElementFromEPackageExtraData(this.dataModel.getSelectedPackage());
             if (preferredRootElement != null) {
-                this.rootElementFilteredList.setSelection(new Object[] { preferredRootElement });
+                this.rootElementFilteredList.setSelection(new StructuredSelection(preferredRootElement));
+            } else if (rootElements.length > 0) {
+                this.rootElementFilteredList.setSelection(new StructuredSelection(rootElements[0]));
             }
+            this.rootElementFilteredList.refresh(true);
         }
     }
 
     /**
-     * Get the concrete classes from the given {@link EPackage} (classes that are not abstract and that are not
-     * interfaces).
+     * Filter selecting elements if they match a given regular expression.
      * 
-     * @param ePackage
-     *            the given {@link EPackage}.
-     * @return the concrete classes from the given {@link EPackage}.
-     */
-    private Collection<EClass> getConcreteClasses(EPackage ePackage) {
-        Collection<EClass> concreteClasses = new HashSet<>();
-        if (ePackage != null) {
-            for (EClassifier eClassifier : ePackage.getEClassifiers()) {
-                if (eClassifier instanceof EClass && !((EClass) eClassifier).isAbstract() && !((EClass) eClassifier).isInterface()) {
-                    concreteClasses.add((EClass) eClassifier);
-                }
-            }
-        }
-        return concreteClasses;
-    }
-
-    /**
-     * Get the filtered concrete classes from the given {@link EPackage} (classes that are not abstract and that are not
-     * interfaces, and that are not child of other classes).
-     * 
-     * @param ePackage
-     *            the given {@link EPackage}.
-     * @return the filtered concrete classes from the given {@link EPackage}.
+     * @author <a href="mailto:pierre.guilet@obeo.fr">Pierre Guilet</a>
+     *
      */
-    private Collection<EClass> getFilteredConcreteClasses(EPackage ePackage) {
-        /*
-         * We'll only consider actually instanciable classes.
+    private final class RegexpViewerFilter extends ViewerFilter {
+        /**
+         * The text filter to use when applying filtering on given elements.
          */
-        Collection<EClass> concreteClasses = getConcreteClasses(ePackage);
+        private String filter;
 
-        /*
-         * If we have explicit metadata associated with the EPackage, use the suggested roots.
+        /**
+         * Set the text filter to use when applying filtering on given elements.
+         * 
+         * @param theFilter
+         *            the text filter to use when applying filtering on given elements.
          */
-        if (ePackage != null) {
-            String nsURI = ePackage.getNsURI();
-            EPackageMetaData metaData = DslCommonPlugin.INSTANCE.getEPackageMetaData(nsURI);
-            List<EClass> roots = new ArrayList<>();
-            if (metaData != null && !metaData.getSuggestedRoots().isEmpty()) {
-                roots = concreteClasses.stream().filter(c -> metaData.getSuggestedRoots().contains(c.getName())).collect(Collectors.toList());
-            }
-            if (!roots.isEmpty()) {
-                return roots;
-            }
+        public void setFilter(String theFilter) {
+            this.filter = theFilter;
         }
 
-        /*
-         * Otherwise, or if there is no instanciable suggested root, try to infer good candidates from the metamodel's
-         * structure (i.e. prefer elements which are not contained by anything).
-         */
-        return inferRootElementsCandidates(concreteClasses);
-    }
-
-    private Collection<EClass> inferRootElementsCandidates(Collection<EClass> concreteClasses) {
-        Collection<EClass> filteredConcreteClasses = new HashSet<>(concreteClasses);
-        for (EClass eClass : concreteClasses) {
-            if (filteredConcreteClasses.contains(eClass)) {
-                eClass.getEAllReferences().stream().filter(EReference::isContainment).forEach(eReference -> {
-                    EClassifier eType = eReference.getEType();
-                    if (concreteClasses.contains(eType) && eType != eClass) {
-                        filteredConcreteClasses.remove(eType);
-                    } else {
-                        concreteClasses.stream().filter(c -> c.getEAllSuperTypes().contains(eType)).forEach(c -> filteredConcreteClasses.remove(c));
-                    }
-                });
-            }
-        }
-        return filteredConcreteClasses;
-    }
-
-    /**
-     * Get the preferred root element for the given {@link EPackage} from the registry of EPackageExtraData.
-     * 
-     * @see EPackageExtraDataRegistry
-     * @param ePackage
-     *            the given {@link EPackage}.
-     * @return the preferred root element for the given {@link EPackage}, or null if it can't be found.
-     */
-    private EClass getPreferredRootElementFromEPackageExtraData(EPackage ePackage) {
-        if (ePackage != null) {
-            String nsURI = ePackage.getNsURI();
-            EPackageMetaData metaData = DslCommonPlugin.INSTANCE.getEPackageMetaData(nsURI);
-            if (metaData != null && !metaData.getSuggestedRoots().isEmpty()) {
-                EClassifier result = ePackage.getEClassifier(metaData.getSuggestedRoots().get(0));
-                if (result instanceof EClass) {
-                    return (EClass) result;
-                }
+        @Override
+        public boolean select(Viewer viewer, Object parentElement, Object element) {
+            if (!filter.equals("*") && element instanceof EClass) { //$NON-NLS-1$
+                EClass eClass = (EClass) element;
+                return eClass.getName() != null && eClass.getName().toLowerCase().contains(filter.toLowerCase());
             }
+            return true;
         }
-        return null;
     }
 
     /**
-     * A label provider for the {@link SelectRootElementWizardPage#rootElementFilteredList}.
+     * A label provider for the {@link SelectRootElementWizardPage#rootElementFilteredTree}.
      */
     private class RootElementsListLabelProvider extends LabelProvider {