/*****************************************************************************
 * Copyright (c) 2021 CEA LIST and others.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *   Asma Smaoui (CEA LIST) asma.smaoui@cea.fr - Initial API and implementation
 *
 *****************************************************************************/
package org.eclipse.papyrus.aas.ui.widgets;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;

import org.eclipse.core.internal.runtime.InternalPlatform;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EModelElement;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
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.ecore.xmi.XMLResource;
import org.eclipse.emf.edit.command.AddCommand;
import org.eclipse.emf.edit.command.SetCommand;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.RollbackException;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.editparts.AbstractEditPart;
import org.eclipse.gmf.runtime.common.core.command.ICommand;
import org.eclipse.gmf.runtime.emf.type.core.ElementTypeRegistry;
import org.eclipse.gmf.runtime.emf.type.core.IElementType;
import org.eclipse.gmf.runtime.emf.type.core.requests.CreateElementRequest;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.nebula.widgets.nattable.NatTable;
import org.eclipse.papyrus.aas.ConceptDescription;
import org.eclipse.papyrus.aas.HasSemantics;
import org.eclipse.papyrus.aas.Reference;
import org.eclipse.papyrus.aas.profile.ui.Activator;
import org.eclipse.papyrus.aas.ui.utils.IAASElementTypes;
import org.eclipse.papyrus.infra.core.resource.EditingDomainServiceFactory;
import org.eclipse.papyrus.infra.core.resource.ModelSet;
import org.eclipse.papyrus.infra.core.services.ServiceDescriptor;
import org.eclipse.papyrus.infra.core.services.ServiceDescriptor.ServiceTypeKind;
import org.eclipse.papyrus.infra.core.services.ServiceException;
import org.eclipse.papyrus.infra.core.services.ServiceMultiException;
import org.eclipse.papyrus.infra.core.services.ServiceStartKind;
import org.eclipse.papyrus.infra.core.services.ServicesRegistry;
import org.eclipse.papyrus.infra.emf.gmf.command.GMFtoEMFCommandWrapper;
import org.eclipse.papyrus.infra.emf.gmf.util.GMFUnsafe;
import org.eclipse.papyrus.infra.emf.nattable.selection.EObjectSelectionExtractor;
import org.eclipse.papyrus.infra.emf.utils.EMFHelper;
import org.eclipse.papyrus.infra.nattable.manager.table.INattableModelManager;
import org.eclipse.papyrus.infra.nattable.manager.table.NattableModelManager;
import org.eclipse.papyrus.infra.nattable.manager.table.TreeNattableModelManager;
import org.eclipse.papyrus.infra.nattable.model.nattable.NattableFactory;
import org.eclipse.papyrus.infra.nattable.model.nattable.NattablePackage;
import org.eclipse.papyrus.infra.nattable.model.nattable.Table;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattableaxis.IAxis;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattableaxisconfiguration.AxisManagerRepresentation;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattableaxisconfiguration.EStructuralFeatureValueFillingConfiguration;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattableaxisconfiguration.IAxisConfiguration;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattableaxisconfiguration.TableHeaderAxisConfiguration;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattableaxisprovider.AbstractAxisProvider;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattableaxisprovider.NattableaxisproviderFactory;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattableaxisprovider.NattableaxisproviderPackage;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattableconfiguration.TableConfiguration;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattablestyle.BooleanValueStyle;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattablestyle.NattablestyleFactory;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattablestyle.NattablestylePackage;
import org.eclipse.papyrus.infra.nattable.model.nattable.nattablestyle.Style;
import org.eclipse.papyrus.infra.nattable.resource.TableResourceHelper;
import org.eclipse.papyrus.infra.nattable.tree.ITreeItemAxisHelper;
import org.eclipse.papyrus.infra.nattable.utils.HeaderAxisConfigurationManagementUtils;
import org.eclipse.papyrus.infra.nattable.utils.NamedStyleConstants;
import org.eclipse.papyrus.infra.nattable.utils.NattableModelManagerFactory;
import org.eclipse.papyrus.infra.nattable.utils.TableHelper;
import org.eclipse.papyrus.infra.nattable.utils.TableResourceConstants;
import org.eclipse.papyrus.infra.properties.contexts.Property;
import org.eclipse.papyrus.infra.properties.ui.modelelement.CompositeModelElement;
import org.eclipse.papyrus.infra.properties.ui.modelelement.DataSource;
import org.eclipse.papyrus.infra.properties.ui.modelelement.DataSourceChangedEvent;
import org.eclipse.papyrus.infra.properties.ui.modelelement.EMFModelElement;
import org.eclipse.papyrus.infra.properties.ui.modelelement.IDataSourceListener;
import org.eclipse.papyrus.infra.properties.ui.modelelement.ModelElement;
import org.eclipse.papyrus.infra.properties.ui.widgets.AbstractPropertyEditor;
import org.eclipse.papyrus.infra.services.edit.service.ElementEditServiceUtils;
import org.eclipse.papyrus.infra.services.edit.service.IElementEditService;
import org.eclipse.papyrus.infra.widgets.creation.IAtomicOperationExecutor;
import org.eclipse.papyrus.uml.properties.modelelement.UMLNotationModelElement;
import org.eclipse.papyrus.uml.properties.widgets.TreeNattablePropertyEditor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyComposite;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.util.UMLUtil;

/**
 * The property editor for the nattable widget.
 */
@SuppressWarnings("restriction")
public class AASNattablePropertyEditor extends AbstractPropertyEditor {

	/**
	 * The save options to use.
	 *
	 * @deprecated since 3.0. Use TableResourceFactory.
	 */
	@Deprecated
	private static final Map<Object, Object> saveOptions = new HashMap<>();

	static {
		saveOptions.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED, Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER);
		saveOptions.put(Resource.OPTION_LINE_DELIMITER, Resource.OPTION_LINE_DELIMITER_UNSPECIFIED);
		saveOptions.put(XMLResource.OPTION_SAVE_TYPE_INFORMATION, true);
	}

	/**
	 * The folders in which we will save the table configured by the user.
	 */
	private static final String TABLES_PREFERENCES_FOLDER_NAME = "tables";//$NON-NLS-1$

	/**
	 * The file in which the table will be saved.
	 *
	 * It doesn't work using .notation as extension file. In this case, the commands are not executed, because it is read-only, but why ?
	 *
	 * @deprecated since 3.0. Use TableResourceConstants.TABLE_FILE_EXTENSION.
	 */
	@Deprecated
	@SuppressWarnings("unused")
	private static final String FILE_EXTENSION = "table";//$NON-NLS-1$

	/**
	 * The composite.
	 */
	protected Group self = null;;

	/**
	 * The table configuration URI.
	 */
	private URI tableConfigURI = null;

	/**
	 * The nattable widget.
	 */
	protected NatTable natTableWidget = null;

	/**
	 * The nattable manager.
	 */
	protected INattableModelManager nattableManager = null;

	/**
	 * The dispose listener.
	 */
	private DisposeListener nattableDisposeListener = null;

	/**
	 * The data source listener.
	 */
	private IDataSourceListener dataSourceListener;

	/**
	 * The service registry used to manipulate the table
	 */
	private ServicesRegistry serviceRegistry = null;

	/**
	 * the resource where the table will be saved
	 */
	private Resource resource = null;

	/**
	 * the edited Papyrus table
	 */
	private Table table = null;

	/**
	 * the table configuration
	 */
	private TableConfiguration tableConfiguration = null;

	/**
	 * if <code>true</code> we register table configuration by eClass and not only by table type
	 */
	private boolean registerTableConfigurationByEClass = false;

	/**
	 * Constructor.
	 *
	 * @param parent
	 *            The parent composite.
	 * @param style
	 *            The style of the composite.
	 */
	public AASNattablePropertyEditor(final Composite parent, final int style) {
		self = new Group(parent, SWT.NONE);
		FillLayout fillLayout = new FillLayout();
		fillLayout.marginHeight = 10;
		fillLayout.marginWidth = 10;
		self.setLayout(fillLayout);
	}

	/**
	 *
	 * @param newValue
	 *            if <code>true</code> we register the table configuration by type AND by the ECLass of the selected element
	 * @since 2.0
	 */
	public final void setRegisterTableConfigurationByEClass(final boolean newValue) {
		this.registerTableConfigurationByEClass = newValue;
	}

	/**
	 * Set the table URI.
	 *
	 * @param uri
	 *            The URI of the table (as String).
	 * @since 2.0
	 */
	public void setTableConfigurationURI(final String uri) {
		tableConfigURI = URI.createURI(uri);
		checkInput();
	}

	/**
	 * Get the table configuration URI.
	 *
	 * @return The table configuration URI.
	 * @since 2.0
	 *
	 */
	public String getTableConfigurationURI() {
		return tableConfigURI == null ? null : tableConfigURI.toString();
	}

	/**
	 * Set the table URI.
	 *
	 * @param uri
	 *            The URI of the table (as String).
	 *
	 * @deprecated since 2.0, use setTableConfigurationURI instead
	 */
	@Deprecated
	public void setTableURI(final String uri) {
		setTableConfigurationURI(uri);
	}

	/**
	 * Get the table configuration URI.
	 *
	 * @return The table configuration URI.
	 * @deprecated since 2.0, use getTableConfigurationUri instead
	 */
	@Deprecated
	public String getTableURI() {
		return getTableConfigurationURI();
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.papyrus.infra.properties.ui.widgets.AbstractPropertyEditor#checkInput()
	 */
	@Override
	protected void checkInput() {
		if (tableConfigURI != null) {
			super.checkInput();
		}
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.papyrus.infra.properties.ui.widgets.AbstractPropertyEditor#doBinding()
	 */
	@Override
	protected void doBinding() {
		super.doBinding();

		// final ModelElement modelElement = input.getModelElement(propertyPath);
		ModelElement modelElement = null;
		final ModelElement modelElementHassemantic = input.getModelElement("AAS:HasSemantics:semanticId");
		final ModelElement modelElementConceptDescription = input.getModelElement("AAS:ConceptDescription:isCaseOf");
		// final ModelElement modelElementdataSpecification = input.getModelElement("AAS:HasDataSpecification:dataSpecification");
		// final ModelElement modelElementMultiLanguageProp = input.getModelElement("AAS:MultiLanguageProperty:valueId");
		final List<ModelElement> modelElements = new ArrayList(Arrays.asList(modelElementHassemantic, modelElementConceptDescription));
		// final List<ModelElement> modelElements = new ArrayList(Arrays.asList(modelElementHassemantic, modelElementConceptDescription, modelElementdataSpecification, modelElementMultiLanguageProp));
		if (modelElements.stream().filter(Objects::nonNull).findAny().isPresent()) {
			modelElement = modelElements.stream().filter(Objects::nonNull).findAny().get();
		}
		// The data needed to create the table
		final List<Object> rows = new ArrayList<>();
		EObject sourceElement = null;
		EStructuralFeature feature = null;

		// Manage the data needed for the table creation
		if (modelElement instanceof CompositeModelElement) {
			if (!((CompositeModelElement) modelElement).getSubElements().isEmpty()) {
				if (((CompositeModelElement) modelElement).getSubElements().get(0) instanceof UMLNotationModelElement) {
					final EModelElement eModelElement = ((UMLNotationModelElement) ((CompositeModelElement) modelElement).getSubElements().get(0)).getEModelElement();
					// Fill the list of views to determinate the axis to display (cannot be created without the table editing domain)
					for (ModelElement subModelElement : ((CompositeModelElement) modelElement).getSubElements()) {
						if (subModelElement instanceof UMLNotationModelElement) {
							rows.add(((UMLNotationModelElement) subModelElement).getEModelElement());
						}
					}
					sourceElement = eModelElement;
				} else if (((CompositeModelElement) modelElement).getSubElements().get(0) instanceof EMFModelElement) {
					final EMFModelElement emfModelElement = (EMFModelElement) ((CompositeModelElement) modelElement).getSubElements().get(0);
					sourceElement = emfModelElement.getSource();
					feature = emfModelElement.getFeature(getLocalPropertyPath());
				}
			}
		} else if (modelElement instanceof UMLNotationModelElement) {
			final EModelElement eModelElement = ((UMLNotationModelElement) modelElement).getEModelElement();
			// Fill the list of views to determinate the axis to display (cannot be created without the table editing domain)
			rows.add(eModelElement);
			sourceElement = eModelElement;
		} else if (modelElement instanceof EMFModelElement) {
			final EMFModelElement emfModelElement = (EMFModelElement) modelElement;
			EObject source = emfModelElement.getSource();

			// case of hasSemantic
			if (source != null && source instanceof HasSemantics) {
				if (((HasSemantics) source).getSemanticId() != null) {
					source = ((HasSemantics) source).getSemanticId();
				} else {


					Element element = UMLUtil.getBaseElement(source);
					HasSemantics has = (HasSemantics) source;
					getOperationExecutor(element).execute(new Runnable() {

						@SuppressWarnings("unchecked")
						@Override
						public void run() {

							if (element instanceof Element) {

								Element container = element.getModel();
								EditingDomain domain = EMFHelper.resolveEditingDomain(container);
								IElementType referenceElementType = ElementTypeRegistry.getInstance().getType(IAASElementTypes.REFERENCE_ID);
								CreateElementRequest request = null;

								request = new CreateElementRequest((TransactionalEditingDomain) domain, container, referenceElementType);

								IElementEditService provider = ElementEditServiceUtils.getCommandProvider(container);
								ICommand createReference = provider.getEditCommand(request);
								if (createReference.canExecute()) {
									domain.getCommandStack().execute(new GMFtoEMFCommandWrapper(createReference));
									Object result = createReference.getCommandResult().getReturnValue();
									Reference reference = getReference(result);
									has.setSemanticId(reference);
								} else {
									System.out.println("can not execute command");
								}
							}

						}
					}, "message");
					// Create the Reference if the sourceElement is a HasSemantic
					source = ((HasSemantics) source).getSemanticId();
				}

			} // case of ConceptDescription

			else if (source != null && source instanceof ConceptDescription) {
				if (((ConceptDescription) source).getIsCaseOf() != null && !((ConceptDescription) source).getIsCaseOf().isEmpty()) {
					source = ((ConceptDescription) source).getIsCaseOf().get(0);
				} else {


					Element element = UMLUtil.getBaseElement(source);
					ConceptDescription cons = (ConceptDescription) source;
					getOperationExecutor(element).execute(new Runnable() {

						@SuppressWarnings("unchecked")
						@Override
						public void run() {

							if (element instanceof Element) {

								Element container = element.getModel();
								EditingDomain domain = EMFHelper.resolveEditingDomain(container);
								IElementType referenceElementType = ElementTypeRegistry.getInstance().getType(IAASElementTypes.REFERENCE_ID);
								CreateElementRequest request = null;

								request = new CreateElementRequest((TransactionalEditingDomain) domain, container, referenceElementType);

								IElementEditService provider = ElementEditServiceUtils.getCommandProvider(container);
								ICommand createReference = provider.getEditCommand(request);
								if (createReference.canExecute()) {
									domain.getCommandStack().execute(new GMFtoEMFCommandWrapper(createReference));
									Object result = createReference.getCommandResult().getReturnValue();
									Reference reference = getReference(result);
									cons.getIsCaseOf().add(reference);
								} else {
									System.out.println("can not execute command");
								}
							}

						}
					}, "message");
					// Create the Reference if the sourceElement is a HasSemantic
					source = ((ConceptDescription) source).getIsCaseOf().get(0);
				}
			}

			if (!(source instanceof Element)) {
				final Element baseElement = UMLUtil.getBaseElement(source);
				if (baseElement != null) {// in other case we will get an exeption somewhere
					source = baseElement;
				}
			}
			sourceElement = source;
			if (emfModelElement.getSource() instanceof HasSemantics) {
				feature = emfModelElement.getFeature("semanticId");
			} else if (emfModelElement.getSource() instanceof ConceptDescription) {
				feature = emfModelElement.getFeature("isCaseOf");
			}
			// rows.add(emfModelElement);
		} else {
			displayError("Invalid table context"); //$NON-NLS-1$
			return;
		}

		// Create the widgets
		createWidgets(sourceElement, feature, rows);
	}

	/**
	 * This allow to create the widgets.
	 *
	 * @param sourceElement
	 *            The source Element.
	 * @param feature
	 *            The feature.
	 * @param rows
	 *            The rows of the table.
	 * @since 2.0
	 */
	protected void createWidgets(final EObject sourceElement, final EStructuralFeature feature, final Collection<?> rows) {
		createPreviousWidgets(sourceElement, feature);
		createTableWidget(sourceElement, feature, rows);
		createFollowingWidgets(sourceElement, feature);

		// Configure the layout and the layout data
		configureLayout(sourceElement);
		self.layout();
	}

	/**
	 * This allow to create the widgets displayed before the table widget.
	 *
	 * @param sourceElement
	 *            The source Element.
	 * @param feature
	 *            The feature.
	 * @since 2.0
	 */
	protected void createPreviousWidgets(final EObject sourceElement, final EStructuralFeature feature) {
		// To implement if some widgets are needed before the table widget
	}

	/**
	 * This allow to create the table widget or to reuse a table previously used in the property view
	 *
	 * @param sourceElement
	 *            The source Element.
	 * @param feature
	 *            The parent structural feature.
	 * @param rows
	 *            The rows of the table.
	 *
	 * @since 2.0
	 */
	protected void createTableWidget(final EObject sourceElement, final EStructuralFeature feature, final Collection<?> rows) {
		// 1. we initialize a service registry
		if (this.serviceRegistry == null) {
			try {
				this.serviceRegistry = createServiceRegistry(sourceElement);
			} catch (Exception e) {
				// Activator.log.error(e);
			}
		}

		if (this.serviceRegistry == null) {
			displayError("Cannot initialize the service registry"); //$NON-NLS-1$
			return;
		}

		// 2. get the editing domain
		TransactionalEditingDomain domain = getTableEditingDomain();
		if (domain == null) {
			displayError("Cannot found the editing domain"); //$NON-NLS-1$
			return;
		}

		// 3. Create the table or get an existing one
		this.table = getOrCreateTable(sourceElement, feature, rows);

		if (this.table == null) {
			displayError("Cannot initialize the table"); //$NON-NLS-1$
			return;
		}

		// 4. we configure the table
		final CompoundCommand cc = new CompoundCommand("Configure table command");//$NON-NLS-1$

		// 4.1 we register it into a resource if required
		if (this.table.eResource() == null) {
			cc.append(addTableToResource(domain, this.resource, this.table));
		}

		// 4.2 we configure the table
		configureTable(domain, this.table, sourceElement, feature, rows, cc);

		if (!cc.canExecute()) {
			displayError("The table can't be initialized");//$NON-NLS-1$
			return;
		}

		final ResourceSet resourceSet = getResourceSet();
		// Bug 502160: Remove the resource from the resource set to execute the command without using the editing command stack
		resourceSet.getResources().remove(this.resource);
		try {
			GMFUnsafe.write(domain, cc);
		} catch (InterruptedException e) {
			// Activator.log.error(e);
		} catch (RollbackException e) {
			// Activator.log.error(e);
		} finally {
			// Bug 502160: Re-add the removed resource before the command execute
			resourceSet.getResources().add(this.resource);
		}

		if (this.table.getContext() == null) {
			displayError("The context of the table hasn't be set");//$NON-NLS-1$
			return;
		}
		// 5. Create the widget
		this.nattableManager = NattableModelManagerFactory.INSTANCE.createNatTableModelManager(this.table, new EObjectSelectionExtractor());
		this.natTableWidget = createNatTableWidget(this.nattableManager, self, SWT.NONE, rows);

		self.addDisposeListener(getDisposeListener());
		// Configure the layout and the layout data
		configureLayout();

		((NattableModelManager) nattableManager).refreshNatTable();
	}

	/**
	 * This allow to create the widgets displayed after the table widget.
	 *
	 * @param sourceElement
	 *            The source Element.
	 * @param feature
	 *            The feature.
	 * @since 2.0
	 */
	protected void createFollowingWidgets(final EObject sourceElement, final EStructuralFeature feature) {
		// To implement if some widgets are needed after the table widget
	}

	/**
	 *
	 * @param parent
	 *            the composite parent
	 * @param style
	 *            the style to use to create the nattable widget
	 * @param rows
	 *            the initial rows
	 * @return
	 *         the created nattable widget
	 * @since 2.0
	 */
	protected NatTable createNatTableWidget(final INattableModelManager manager, final Composite parent, final int style, Collection<?> rows) {
		NatTable natTable = manager.createNattable(self, style, null);
		natTable.setBackground(self.getBackground());
		return natTable;
	}

	/**
	 *
	 * @param sourceElement
	 *            the source element used to initiatiaze the table
	 * @return
	 *         the service registry to use for the table displayed in property view
	 * @throws Exception
	 *
	 *             Duplicated code from org.eclipse.papyrus.junit.utils.rules.ModelSetFixture
	 * @since 2.0
	 */
	protected ServicesRegistry createServiceRegistry(EObject sourceElement) throws Exception {
		ServicesRegistry result = new ServicesRegistry();

		result.add(ModelSet.class, 10, new ModelSet());

		ServiceDescriptor desc = new ServiceDescriptor(TransactionalEditingDomain.class, EditingDomainServiceFactory.class.getName(), ServiceStartKind.STARTUP, 10);// , Collections.singletonList(ResourceSet.class.getName()));
		desc.setServiceTypeKind(ServiceTypeKind.serviceFactory);
		desc.setClassBundleID(Activator.PLUGIN_ID);
		result.add(desc);

		result.startRegistry();
		return result;
	}


	/**
	 * This allows to configure the tree table.
	 *
	 * @param nattableManager
	 *            The nattable model manager.
	 * @param sourceElement
	 *            The source Element.
	 * @param feature
	 *            The feature.
	 * @param rows
	 *            The rows of the table.
	 * @deprecated since 2.0, moved into {@link TreeNattablePropertyEditor}
	 */
	@Deprecated
	protected void configureTreeTable(final TreeNattableModelManager nattableManager, final EObject sourceElement, final EStructuralFeature feature, final Collection<?> rows) {
		// Do nothing
	}

	/**
	 * This allows to configure the layout and the layout data.
	 *
	 * @deprecated since 2.0.0
	 */
	@Deprecated
	protected void configureLayout() {
		// Adapt the group to the table preferred size
		final GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);

		// The preferred height of the nattable calculate it for each row (even if some are hidden)
		// So to calculate the correct height for the composite :
		// - Calculate the header height
		// - Calculate the body height
		// Add these values and add some extra to have correct displays
		final int headerHeight = natTableWidget.getPreferredHeight() - nattableManager.getBodyLayerStack().getRowHideShowLayer().getPreferredHeight();
		final int bodyHeight = nattableManager.getBodyLayerStack().getRowHideShowLayer().getHeight();
		// 16px must be added because of the left area slider
		final int extra = 20 + 16;
		data.minimumHeight = headerHeight + bodyHeight + extra;
		self.setLayoutData(data);

		self.layout();
		natTableWidget.layout();
	}

	/**
	 * This allows to configure the layout and the layout data.
	 *
	 * @param sourceElement
	 *            The source element.
	 * @since 2.0
	 */
	protected void configureLayout(final EObject sourceElement) {
		// must be done first!
		((NattableModelManager) nattableManager).refreshNatTable();

		// Configure the size of the parent container
		configureSize(sourceElement);

		natTableWidget.layout();
	}

	/**
	 * This allows to configure the size of the parent container.
	 *
	 * @param sourceElement
	 *            The source element.
	 * @since 2.0
	 */
	protected void configureSize(final EObject sourceElement) {
		// Adapt the group to the table preferred size
		final GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);

		// The preferred height of the nattable calculate it for each row (even if some are hidden)
		// So to calculate the correct height for the composite :
		// - Calculate the header height
		// - Calculate the body height
		// Add these values and add some extra to have correct displays
		final int headerHeight = natTableWidget.getPreferredHeight() - nattableManager.getBodyLayerStack().getRowHideShowLayer().getPreferredHeight();
		final int bodyHeight = nattableManager.getBodyLayerStack().getRowHideShowLayer().getHeight();
		// 16px must be added because of the left area slider
		final int extra = 20 + 16;
		data.minimumHeight = headerHeight + bodyHeight + extra;
		self.setLayoutData(data);
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.papyrus.infra.properties.ui.widgets.AbstractPropertyEditor#updateDescription(java.lang.String)
	 */
	@Override
	protected void updateDescription(String description) {
		self.setToolTipText(description);
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.papyrus.infra.properties.ui.widgets.AbstractPropertyEditor#updateLabel(java.lang.String)
	 */
	@Override
	public void updateLabel(final String label) {
		if (showLabel) {
			self.setText(getLabel());
		}
	}

	/**
	 * This allow to display the error.
	 *
	 * @param message
	 *            The error message to display.
	 */
	protected void displayError(final String message) {
		final CLabel label = new CLabel(self, SWT.NONE);
		label.setText(message);
		label.setImage(org.eclipse.papyrus.infra.widgets.Activator.getDefault().getImage("icons/error.gif")); //$NON-NLS-1$
	}

	/**
	 *
	 * @param sourceElement
	 *            the source Element
	 * @param synchronizedFeature
	 *            the synchronized feature
	 * @param rows
	 * @return
	 *         the existing table or the new created one
	 * @since 2.0
	 */
	protected Table getOrCreateTable(final EObject sourceElement, final EStructuralFeature synchronizedFeature, final Collection<?> rows) {
		Table returnedTable = null;
		final TableConfiguration tableConfiguration = getTableConfiguration();
		if (tableConfiguration == null) {
			return null;
		}

		if (this.serviceRegistry != null) {
			URI tableURI = createTableURI(sourceElement, tableConfiguration);
			final ResourceSet resourceSet = getResourceSet();
			// Install the table support to manage the table as a correct Resource
			TableResourceHelper.installTableSupport(resourceSet);
			((ModelSet) resourceSet).createModels(tableURI);
			boolean exists = resourceSet.getURIConverter().exists(tableURI, Collections.emptyMap());
			if (exists) {
				this.resource = resourceSet.getResource(tableURI, true);
			} else {
				this.resource = resourceSet.createResource(tableURI);
			}

			Iterator<EObject> iter = this.resource.getContents().iterator();
			while (iter.hasNext() && returnedTable == null) {// the resource should contains only 1 table and this one will get the good type
				EObject object = iter.next();
				if (object instanceof Table) {
					TableConfiguration configuration = ((Table) object).getTableConfiguration();
					if (configuration != null && configuration.getType() != null && configuration.getType().equals(getTableConfiguration().getType())) {
						returnedTable = (Table) object;
					}
				}
			}

			if (null == returnedTable) {
				returnedTable = createTable(sourceElement, synchronizedFeature);
			}

		}

		return returnedTable;
	}

	/**
	 *
	 * @return
	 *         the resource set to use to load/store emf files
	 * @since 2.0
	 */
	protected ResourceSet getResourceSet() {
		ResourceSet set = null;
		if (this.serviceRegistry != null) {
			try {
				set = this.serviceRegistry.getService(ModelSet.class);
			} catch (ServiceException e) {
				// Activator.log.error(e);
			}
		}
		return set;
	}

	/**
	 * Create URI for the table configuration.
	 *
	 * @param sourceElement
	 *            The source Element
	 * @param tableConfiguration
	 *            The tableConfiguration
	 * @return The URI to use to save and load the table
	 * @since 2.0
	 */
	protected URI createTableURI(final EObject sourceElement, final TableConfiguration tableConfiguration) {
		// If the source element has an EClass, the table configuration file name
		// will be suffixed by the name of its eClass
		setRegisterTableConfigurationByEClass((sourceElement != null) && (sourceElement.eClass() != null));

		IPath preferencePath = InternalPlatform.getDefault().getStateLocation(Activator.getContext().getBundle(), true);
		// we create a folder to save the tables used by the property view and we start to create the name of the model owning the table
		preferencePath = preferencePath.append(TABLES_PREFERENCES_FOLDER_NAME).append(tableConfiguration.getType());

		// we continue to build the path, adding the good suffix to the name of the model
		final StringBuilder b = new StringBuilder().append(preferencePath.toPortableString());
		if (this.registerTableConfigurationByEClass) {
			ModelElement modelElement = input.getModelElement(propertyPath);
			EClass eClass = null;
			if (modelElement instanceof CompositeModelElement) {
				CompositeModelElement compoModelElement = (CompositeModelElement) modelElement;
				for (ModelElement next : compoModelElement.getSubElements()) {
					if ((next instanceof UMLNotationModelElement)
							|| (next instanceof EMFModelElement)) {
						modelElement = next;
						break;
					}
				}
			}

			if (modelElement instanceof UMLNotationModelElement) {
				EditPart part = ((UMLNotationModelElement) modelElement).getEditPart();
				eClass = EMFHelper.getEObject(part).eClass();
			} else if (modelElement instanceof EMFModelElement) {
				EObject source = ((EMFModelElement) modelElement).getSource();
				if (source != null) {
					eClass = source.eClass();
				}
			}

			if (eClass != null) {
				b.append("_"); //$NON-NLS-1$
				b.append(eClass.getName());
			}
		}

		URI newURI = URI.createFileURI(b.toString()).appendFileExtension(TableResourceConstants.TABLE_FILE_EXTENSION);
		return newURI;
	}


	/**
	 * This allow to create the nattable.
	 *
	 * @param sourceElement
	 *            The context element.
	 * @param synchronizedFeature
	 *            The synchronized feature.
	 * @param rows
	 *            The rows of the table.
	 * @return The created table.
	 *
	 * @since 2.0
	 */
	protected Table createTable(final EObject sourceElement, final EStructuralFeature synchronizedFeature) {
		final TableConfiguration tableConfiguration = getTableConfiguration();
		if (tableConfiguration == null) {
			return null;
		}
		final Table table = NattableFactory.eINSTANCE.createTable();
		table.setTableConfiguration(tableConfiguration);
		final Property property = getModelProperty();
		if (property != null) {
			String description = property.getDescription();
			if (description != null) {
				table.setDescription(description);
			}
		}

		table.setName(getLabel());
		// for table used in property view, the kindId was null, because it is given by the AF. So we propose to use the type for kindId
		table.setTableKindId(table.getTableConfiguration().getType());

		AbstractAxisProvider rowProvider = tableConfiguration.getDefaultRowAxisProvider();
		if (rowProvider == null) {
			rowProvider = NattableaxisproviderFactory.eINSTANCE.createMasterObjectAxisProvider();
		} else {
			rowProvider = EcoreUtil.copy(rowProvider);
		}

		AbstractAxisProvider columnProvider = tableConfiguration.getDefaultColumnAxisProvider();
		if (columnProvider == null) {
			columnProvider = NattableaxisproviderFactory.eINSTANCE.createSlaveObjectAxisProvider();
		} else {
			columnProvider = EcoreUtil.copy(columnProvider);
		}

		table.getColumnAxisProvidersHistory().add(columnProvider);
		table.setCurrentColumnAxisProvider(columnProvider);
		table.getRowAxisProvidersHistory().add(rowProvider);
		table.setCurrentRowAxisProvider(rowProvider);
		for (final Style style : tableConfiguration.getStyles()) {
			table.getStyles().add(EcoreUtil.copy(style));
		}

		// for the table displayed in property view, we want to use all the available place, so we add a specific named style each time
		// We manage it with percentage named style
		BooleanValueStyle columnsWidthAsPercentage = (BooleanValueStyle) table.getNamedStyle(NattablestylePackage.eINSTANCE.getBooleanValueStyle(), NamedStyleConstants.COLUMNS_WIDTH_AS_PERCENTAGE);
		// if the name style already exists we do nothing
		if (null == columnsWidthAsPercentage) {
			// for the table displayed in property view, we want to use all the available place, so we add a specific named style each time
			BooleanValueStyle fillStyle = (BooleanValueStyle) table.getNamedStyle(NattablestylePackage.eINSTANCE.getBooleanValueStyle(), NamedStyleConstants.FILL_COLUMNS_SIZE);
			// if the name style already exists we do nothing
			if (null == fillStyle) {
				columnsWidthAsPercentage = NattablestyleFactory.eINSTANCE.createBooleanValueStyle();
				columnsWidthAsPercentage.setName(NamedStyleConstants.COLUMNS_WIDTH_AS_PERCENTAGE);
				columnsWidthAsPercentage.setBooleanValue(true);
				table.getStyles().add(columnsWidthAsPercentage);
			}
		}

		// for the table displayed in property view, we expand all directly
		BooleanValueStyle expandStyle = (BooleanValueStyle) table.getNamedStyle(NattablestylePackage.eINSTANCE.getBooleanValueStyle(), NamedStyleConstants.EXPAND_ALL);
		// if the name style already exists we do nothing
		if (null == expandStyle) {
			expandStyle = NattablestyleFactory.eINSTANCE.createBooleanValueStyle();
			expandStyle.setName(NamedStyleConstants.EXPAND_ALL);
			expandStyle.setBooleanValue(true);
			table.getStyles().add(expandStyle);
		}
		return table;
	}

	/**
	 * This allow to create the nattable.
	 *
	 * @param sourceElement
	 *            The context element.
	 * @param synchronizedFeature
	 *            The synchronized feature.
	 * @param rows
	 *            The rows of the table.
	 * @return The created table.
	 *
	 * @deprecated since 2.0, use the same method without the collections of rows as arguments. Rows are set later in the new implementation
	 */
	@Deprecated
	protected Table createTable(final EObject sourceElement, final EStructuralFeature synchronizedFeature, final Collection<?> rows) {
		final TableConfiguration tableConfiguration = getTableConfiguration();
		if (tableConfiguration == null) {
			return null;
		}
		final Table table = NattableFactory.eINSTANCE.createTable();
		table.setTableConfiguration(tableConfiguration);
		final Property property = getModelProperty();
		if (property != null) {
			String description = property.getDescription();
			if (description != null) {
				table.setDescription(description);
			}
		}

		table.setName(getLabel());

		AbstractAxisProvider rowProvider = tableConfiguration.getDefaultRowAxisProvider();
		if (rowProvider == null) {
			rowProvider = NattableaxisproviderFactory.eINSTANCE.createMasterObjectAxisProvider();
		} else {
			rowProvider = EcoreUtil.copy(rowProvider);
		}

		AbstractAxisProvider columnProvider = tableConfiguration.getDefaultColumnAxisProvider();
		if (columnProvider == null) {
			columnProvider = NattableaxisproviderFactory.eINSTANCE.createSlaveObjectAxisProvider();
		} else {
			columnProvider = EcoreUtil.copy(columnProvider);
		}

		if (null != synchronizedFeature) {
			TableHeaderAxisConfiguration rowHeaderAxisconfig = tableConfiguration.getRowHeaderAxisConfiguration();
			for (IAxisConfiguration axisConfig : rowHeaderAxisconfig.getOwnedAxisConfigurations()) {
				if (axisConfig instanceof EStructuralFeatureValueFillingConfiguration) {
					((EStructuralFeatureValueFillingConfiguration) axisConfig).setListenFeature(synchronizedFeature);
				}
			}
		}
		table.getColumnAxisProvidersHistory().add(columnProvider);
		table.setCurrentColumnAxisProvider(columnProvider);
		table.getRowAxisProvidersHistory().add(rowProvider);
		table.setCurrentRowAxisProvider(rowProvider);
		for (final Style style : tableConfiguration.getStyles()) {
			table.getStyles().add(EcoreUtil.copy(style));
		}

		return table;
	}

	/**
	 *
	 * @return
	 *         the editing domain to use
	 *
	 * @since 2.0
	 */
	protected TransactionalEditingDomain getTableEditingDomain() {
		try {
			return this.serviceRegistry.getService(TransactionalEditingDomain.class);
		} catch (ServiceException e) {
			Activator.log.error(e);
		}
		return null;
	}

	/**
	 * Get the table configuration (from the table configuration URI).
	 *
	 * @return The table configuration.
	 */
	protected TableConfiguration getTableConfiguration() {
		if (this.tableConfiguration == null) {
			ResourceSet resourceSet = getResourceSet();
			if (resourceSet != null) {
				try {
					this.tableConfiguration = (TableConfiguration) EMFHelper.loadEMFModel(resourceSet, this.tableConfigURI);
				} catch (Exception ex) {
					Activator.log.error("Invalid table configuration", ex); //$NON-NLS-1$
				}
			}
		}
		return this.tableConfiguration;
	}

	/**
	 * This allow to create the dispose listener for the nattable table manager.
	 *
	 * @return The dispose nattable manager listener.
	 */
	protected DisposeListener getDisposeListener() {
		if (null == this.nattableDisposeListener) {
			this.nattableDisposeListener = new DisposeListener() {

				@Override
				public void widgetDisposed(DisposeEvent e) {
					disposeListener();
				}
			};
		}
		return nattableDisposeListener;
	}

	/**
	 * This allows to dispose the listeners.
	 *
	 * @since 2.0
	 */
	protected void disposeListener() {
		if (AASNattablePropertyEditor.this.serviceRegistry != null) {
			// we dispose it to avoid unecessary refresh
			if (null != this.nattableManager) {
				this.nattableManager.dispose();
			}
			if (null != this.natTableWidget) {
				this.natTableWidget.dispose();
			}
			if (AASNattablePropertyEditor.this.resource != null) {
				try {
					AASNattablePropertyEditor.this.resource.save(null);
				} catch (IOException e1) {
					Activator.log.error(e1);
				}
			}
			try {
				AASNattablePropertyEditor.this.serviceRegistry.disposeRegistry();
			} catch (ServiceMultiException e1) {
				Activator.log.error(e1);
			}
			AASNattablePropertyEditor.this.serviceRegistry = null;
			AASNattablePropertyEditor.this.table = null;

		}
	}

	/**
	 *
	 * @param domain
	 *            the editing domain
	 * @param table
	 *            the table to clean before dispose
	 * @return
	 *         the command to use to clean the table before disposing it
	 * @since 2.0
	 * @deprecated since 3.0
	 */
	@Deprecated
	protected CompoundCommand getDisposeTableCommand(final TransactionalEditingDomain domain, final Table table) {
		CompoundCommand disposeCommand = new CompoundCommand("Command used to clean the table before disposing it"); //$NON-NLS-1$
		disposeCommand.append(SetCommand.create(domain, table, NattablePackage.eINSTANCE.getTable_Context(), null));
		disposeCommand.append(SetCommand.create(domain, table, NattablePackage.eINSTANCE.getTable_Owner(), null));
		// assuming the table is synchronized and not inverted :
		disposeCommand.append(SetCommand.create(domain, table.getCurrentRowAxisProvider(), NattableaxisproviderPackage.eINSTANCE.getAxisProvider_Axis(), Collections.emptyList()));

		return disposeCommand;
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.papyrus.infra.properties.ui.widgets.AbstractPropertyEditor#unhookDataSourceListener(org.eclipse.papyrus.infra.properties.ui.modelelement.DataSource)
	 */
	@Override
	protected void unhookDataSourceListener(DataSource oldInput) {
		oldInput.removeDataSourceListener(getDataSourceListener());
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.papyrus.infra.properties.ui.widgets.AbstractPropertyEditor#hookDataSourceListener(org.eclipse.papyrus.infra.properties.ui.modelelement.DataSource)
	 */
	@Override
	protected void hookDataSourceListener(DataSource newInput) {
		newInput.addDataSourceListener(getDataSourceListener());
	}

	public static Reference getReference(Object result) {
		Reference ref = null;
		if (result != null) {
			ref = UMLUtil.getStereotypeApplication((Element) result, Reference.class);
		}
		return ref;

	}

	public static ConceptDescription getConceptDescription(EObject sourceElement) {
		ConceptDescription conceptDescription = null;
		if (sourceElement != null && sourceElement instanceof Element) {
			conceptDescription = UMLUtil.getStereotypeApplication((Element) sourceElement, ConceptDescription.class);
		}
		return conceptDescription;

	}


	public static HasSemantics gethasSemantic(EObject sourceElement) {
		HasSemantics HasSem = null;
		if (sourceElement != null && sourceElement instanceof Element) {
			HasSem = UMLUtil.getStereotypeApplication((Element) sourceElement, HasSemantics.class);
		}
		return HasSem;

	}

	/**
	 * This allow to create the data source listener.
	 *
	 * @return The created data source listener.
	 */
	private IDataSourceListener getDataSourceListener() {
		if (dataSourceListener == null) {
			dataSourceListener = new IDataSourceListener() {

				@Override
				public void dataSourceChanged(final DataSourceChangedEvent event) {
					// bug 494537 - The diagram selection changed, but the property view has not been disposed
					disposeListener();
					// Bug 492560: The self children control was not all disposed correclty
					if (null != self) {
						if (self.getChildren().length > 0) {
							for (Control control : self.getChildren()) {
								control.dispose();
							}
						}
						self.removeDisposeListener(getDisposeListener());
						nattableDisposeListener = null;
						self.layout();
					}
					// Get the datasource
					final DataSource dataSource = event.getDataSource();
					final StructuredSelection selection = (StructuredSelection) dataSource.getSelection();

					// Manage the context selection
					final List<Object> contexts = new ArrayList<>(selection.size());
					EObject sourceElement = null;
					final Iterator<?> selectionIterator = selection.iterator();
					while (selectionIterator.hasNext()) {
						Object selectedObject = selectionIterator.next();
						if (selectedObject instanceof AbstractEditPart) {
							// contexts.add(((AbstractEditPart) selectedObject).getModel());
						} else {
							// contexts.add(selectedObject);
						}

						if (sourceElement == null) {
							// An edit-part in GMF can resolve its semantic element
							// to something different to the element referenced by
							// its notation view, so don't rely on the notation
							sourceElement = EMFHelper.getEObject(selectedObject);
						}
					}

					// Get the model element
					if (sourceElement != null) {
						ModelElement modelElement = null;
						if (gethasSemantic(sourceElement) != null) {
							modelElement = dataSource.getModelElement("AAS:HasSemantics:semanticId");
						} else if (getConceptDescription(sourceElement) != null) {
							modelElement = dataSource.getModelElement("AAS:ConceptDescription:isCaseOf");
						}
						sourceElement = getEObjectAsTableContext(sourceElement); // Convert to table context
						EStructuralFeature feature = null;
						if (modelElement instanceof CompositeModelElement) {
							if (!((CompositeModelElement) modelElement).getSubElements().isEmpty()) {
								if (((CompositeModelElement) modelElement).getSubElements().get(0) instanceof EMFModelElement) {
									final EMFModelElement emfModelElement = (EMFModelElement) ((CompositeModelElement) modelElement).getSubElements().get(0);
									if (emfModelElement instanceof HasSemantics) {
										feature = emfModelElement.getFeature("semanticId");
									} else if (emfModelElement instanceof ConceptDescription) {
										feature = emfModelElement.getFeature("isCaseOf");
									}

								}
							}
						} else if (modelElement instanceof EMFModelElement) {
							final EMFModelElement emfModelElement = (EMFModelElement) modelElement;
							if (sourceElement != null && gethasSemantic(sourceElement) != null) {
								if (gethasSemantic(sourceElement).getSemanticId() != null) {
									sourceElement = gethasSemantic(sourceElement).getSemanticId();
								}
							} else if (sourceElement != null && getConceptDescription(sourceElement) != null) {
								if (getConceptDescription(sourceElement).getIsCaseOf() != null && getConceptDescription(sourceElement).getIsCaseOf().isEmpty()) {
									sourceElement = getConceptDescription(sourceElement).getIsCaseOf().get(0);
								}
							}
							if (!(sourceElement instanceof Element)) {
								final Element baseElement = UMLUtil.getBaseElement(sourceElement);
								if (baseElement != null) {// in other case we will get an exeption somewhere
									sourceElement = baseElement;
								}
							}

							if (gethasSemantic(sourceElement) != null || getConceptDescription(sourceElement) != null) {


								HasSemantics has = gethasSemantic(sourceElement);
								ConceptDescription cons = getConceptDescription(sourceElement);

								if (has != null && has.getSemanticId() == null) {
									Element element = (Element) sourceElement;
									getOperationExecutor(element).execute(new Runnable() {

										@SuppressWarnings("unchecked")
										@Override
										public void run() {

											if (element instanceof Element) {

												Element container = element.getModel();
												EditingDomain domain = EMFHelper.resolveEditingDomain(container);
												IElementType referenceElementType = ElementTypeRegistry.getInstance().getType(IAASElementTypes.REFERENCE_ID);
												CreateElementRequest request = null;

												request = new CreateElementRequest((TransactionalEditingDomain) domain, container, referenceElementType);

												IElementEditService provider = ElementEditServiceUtils.getCommandProvider(container);
												ICommand createReference = provider.getEditCommand(request);
												if (createReference.canExecute()) {
													domain.getCommandStack().execute(new GMFtoEMFCommandWrapper(createReference));
													Object result = createReference.getCommandResult().getReturnValue();
													Reference reference = getReference(result);
													has.setSemanticId(reference);
												} else {
													System.out.println("can not execute command");
												}
											}

										}
									}, "message");
									// Create the Reference if the sourceElement is a HasSemantic


								} else if (cons != null && (cons.getIsCaseOf() == null || cons.getIsCaseOf().isEmpty())) {
									Element element = (Element) sourceElement;
									getOperationExecutor(element).execute(new Runnable() {

										@SuppressWarnings("unchecked")
										@Override
										public void run() {

											if (element instanceof Element) {

												Element container = element.getModel();
												EditingDomain domain = EMFHelper.resolveEditingDomain(container);
												IElementType referenceElementType = ElementTypeRegistry.getInstance().getType(IAASElementTypes.REFERENCE_ID);
												CreateElementRequest request = null;

												request = new CreateElementRequest((TransactionalEditingDomain) domain, container, referenceElementType);

												IElementEditService provider = ElementEditServiceUtils.getCommandProvider(container);
												ICommand createReference = provider.getEditCommand(request);
												if (createReference.canExecute()) {
													domain.getCommandStack().execute(new GMFtoEMFCommandWrapper(createReference));
													Object result = createReference.getCommandResult().getReturnValue();
													Reference reference = getReference(result);
													cons.getIsCaseOf().add(reference);
												} else {
													System.out.println("can not execute command");
												}
											}

										}
									}, "message");
									// Create the Reference if the sourceElement is a HasSemantic


								}
								if (has != null) {
									sourceElement = UMLUtil.getBaseElement(has.getSemanticId());
									feature = emfModelElement.getFeature("semanticId");
								} else if (cons != null) {
									sourceElement = UMLUtil.getBaseElement(cons.getIsCaseOf().get(0));
									feature = emfModelElement.getFeature("isCaseOf");
								}
							}


							// Recreate the table widget, its adjuncts, and their layout
							createWidgets(sourceElement, feature, contexts);

							// We need to refresh the parent composite to get the needed space
							Composite parent = self.getParent();
							boolean found = false;
							while (null != parent && !found) {
								if (parent instanceof TabbedPropertyComposite) {
									found = true;
								} else {
									parent.layout(true, true);
									parent.redraw();
									parent.update();
								}
								parent = parent.getParent();
							}
						}
					}
				}
			};
		}

		return dataSourceListener;
	}

	/**
	 * This allows to get the table context as EObject (and avoid View).
	 *
	 * @param element
	 *            The initial source element.
	 * @return The source element defining Table context.
	 * @since 2.1
	 */
	protected EObject getEObjectAsTableContext(final EObject element) {
		EObject result = element;
		if (result instanceof View) {
			result = ((View) result).getElement();
		}
		return result;
	}

	/**
	 *
	 * @param domain
	 *            the editing domain to use
	 * @param resource
	 *            the resource where the table must be saved
	 * @param table
	 *            the table to add to the resource
	 * @return
	 *         the command to add the table to the resource
	 */
	private static final Command addTableToResource(final TransactionalEditingDomain domain, final Resource resource, final Table table) {
		return new RecordingCommand(domain) {

			@Override
			protected void doExecute() {
				resource.getContents().add(table);
			}
		};
	}

	/**
	 * @see org.eclipse.papyrus.uml.properties.widgets.NattablePropertyEditor#configureTable(org.eclipse.emf.transaction.TransactionalEditingDomain, org.eclipse.papyrus.infra.nattable.model.nattable.Table, org.eclipse.emf.ecore.EObject,
	 *      org.eclipse.emf.ecore.EStructuralFeature, java.util.Collection, org.eclipse.emf.common.command.CompoundCommand)
	 *
	 * @param domain
	 * @param table
	 * @param sourceElement
	 * @param synchronizedFeature
	 * @param rows
	 * @param command
	 */

	protected void configureTable(TransactionalEditingDomain domain, Table table, EObject sourceElement, EStructuralFeature synchronizedFeature, Collection<?> rows, CompoundCommand command) {
		Assert.isNotNull(domain);
		// 1. we register the context of the table

		Command setContextCommand = SetCommand.create(domain, table, NattablePackage.eINSTANCE.getTable_Context(), sourceElement);
		command.append(setContextCommand);
		if (TableHelper.isTreeTable(table) && null != rows && !rows.isEmpty()) {// add test on TreeTable to fix bug 476623
			final AbstractAxisProvider axisProvider = table.getCurrentRowAxisProvider();
			TableHeaderAxisConfiguration conf = (TableHeaderAxisConfiguration) HeaderAxisConfigurationManagementUtils.getRowAbstractHeaderAxisInTableConfiguration(table);
			AxisManagerRepresentation rep = conf.getAxisManagers().get(0);
			for (Object context : rows) {
				addTreeItemAxis(domain, axisProvider, rep, context, command);
			}
		}
	}

	/**
	 * This allow to add the tree item axis.
	 *
	 * @param axisProvider
	 *            The axis provider.
	 * @param rep
	 *            The axis manager representation.
	 * @param object
	 *            The object to add.
	 */
	protected void addTreeItemAxis(final TransactionalEditingDomain domain, final AbstractAxisProvider axisProvider, final AxisManagerRepresentation rep, final Object object, final CompoundCommand command) {
		final IAxis axis = ITreeItemAxisHelper.createITreeItemAxis(null, null, object, rep);
		Command addCommand = AddCommand.create(getTableEditingDomain(), axisProvider, NattableaxisproviderPackage.eINSTANCE.getAxisProvider_Axis(), Collections.singleton(axis));
		command.append(addCommand);
	}

	public IAtomicOperationExecutor getOperationExecutor(Object context) {
		IAtomicOperationExecutor result;
		if (context instanceof IAdaptable) {
			result = ((IAdaptable) context).getAdapter(IAtomicOperationExecutor.class);
		} else if (context != null) {
			result = Platform.getAdapterManager().getAdapter(context, IAtomicOperationExecutor.class);
		} else {
			// We can't adapt null, of course, so we will have to settle for the default executor
			result = null;
		}

		if (result == null) {
			result = IAtomicOperationExecutor.DEFAULT;
		}

		return result;
	}
}