/*******************************************************************************
 * Copyright (c) 2011-2020 EclipseSource Muenchen GmbH and others.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 * Eugen Neufeld - initial API and implementation
 * Johannes Faltermeier - refactorings
 * Christian W. Damus - bugs 544116, 544537, 545686, 530314, 547271, 547787, 548592, 552385, 559267
 ******************************************************************************/
package org.eclipse.emf.ecp.view.spi.table.swt;

import static org.eclipse.emfforms.spi.swt.table.ViewerRefreshManager.getRefreshRunnable;

import java.net.MalformedURLException;
import java.net.URL;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.stream.Collectors;

import javax.inject.Inject;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.Observables;
import org.eclipse.core.databinding.observable.list.IListChangeListener;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListChangeEvent;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IStatus;
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.notify.Notification;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.Enumerator;
import org.eclipse.emf.databinding.EMFDataBindingContext;
import org.eclipse.emf.databinding.EMFProperties;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.EStructuralFeature.Setting;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecp.edit.spi.ConditionalDeleteService;
import org.eclipse.emf.ecp.edit.spi.DeleteService;
import org.eclipse.emf.ecp.edit.spi.EMFDeleteServiceImpl;
import org.eclipse.emf.ecp.edit.spi.ReferenceService;
import org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor;
import org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditorComparator;
import org.eclipse.emf.ecp.edit.spi.swt.table.ECPCustomUpdateCellEditor;
import org.eclipse.emf.ecp.edit.spi.swt.table.ECPElementAwareCellEditor;
import org.eclipse.emf.ecp.edit.spi.swt.table.ECPFilterableCell;
import org.eclipse.emf.ecp.edit.spi.swt.table.ECPViewerAwareCellEditor;
import org.eclipse.emf.ecp.edit.spi.swt.util.ECPDialogExecutor;
import org.eclipse.emf.ecp.view.internal.table.swt.Activator;
import org.eclipse.emf.ecp.view.internal.table.swt.CellReadOnlyTesterHelper;
import org.eclipse.emf.ecp.view.internal.table.swt.MessageKeys;
import org.eclipse.emf.ecp.view.internal.table.swt.RunnableManager;
import org.eclipse.emf.ecp.view.internal.table.swt.TableConfigurationHelper;
import org.eclipse.emf.ecp.view.model.common.util.RendererUtil;
import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
import org.eclipse.emf.ecp.view.spi.core.swt.AbstractControlSWTRenderer;
import org.eclipse.emf.ecp.view.spi.core.swt.AbstractControlSWTRendererUtil;
import org.eclipse.emf.ecp.view.spi.model.DiagnosticMessageExtractor;
import org.eclipse.emf.ecp.view.spi.model.LabelAlignment;
import org.eclipse.emf.ecp.view.spi.model.ModelChangeListener;
import org.eclipse.emf.ecp.view.spi.model.ModelChangeNotification;
import org.eclipse.emf.ecp.view.spi.model.VDiagnostic;
import org.eclipse.emf.ecp.view.spi.model.VDomainModelReference;
import org.eclipse.emf.ecp.view.spi.model.VElement;
import org.eclipse.emf.ecp.view.spi.model.VViewPackage;
import org.eclipse.emf.ecp.view.spi.provider.ECPTooltipModifierHelper;
import org.eclipse.emf.ecp.view.spi.renderer.NoPropertyDescriptorFoundExeption;
import org.eclipse.emf.ecp.view.spi.renderer.NoRendererFoundException;
import org.eclipse.emf.ecp.view.spi.swt.reporting.RenderingFailedReport;
import org.eclipse.emf.ecp.view.spi.table.model.VEnablementConfiguration;
import org.eclipse.emf.ecp.view.spi.table.model.VTableControl;
import org.eclipse.emf.ecp.view.spi.table.model.VTableDomainModelReference;
import org.eclipse.emf.ecp.view.spi.table.swt.action.AddRowAction;
import org.eclipse.emf.ecp.view.spi.table.swt.action.DuplicateRowAction;
import org.eclipse.emf.ecp.view.spi.table.swt.action.MoveRowDownAction;
import org.eclipse.emf.ecp.view.spi.table.swt.action.MoveRowUpAction;
import org.eclipse.emf.ecp.view.spi.table.swt.action.RemoveRowAction;
import org.eclipse.emf.ecp.view.spi.table.swt.action.TableActionIconButton;
import org.eclipse.emf.ecp.view.spi.table.swt.action.TableRendererActionBar;
import org.eclipse.emf.ecp.view.spi.table.swt.action.TableRendererViewerActionContext;
import org.eclipse.emf.ecp.view.spi.util.swt.ImageRegistryService;
import org.eclipse.emf.ecp.view.template.model.VTStyleProperty;
import org.eclipse.emf.ecp.view.template.model.VTViewTemplateProvider;
import org.eclipse.emf.ecp.view.template.style.background.model.VTBackgroundFactory;
import org.eclipse.emf.ecp.view.template.style.background.model.VTBackgroundStyleProperty;
import org.eclipse.emf.ecp.view.template.style.fontProperties.model.VTFontPropertiesFactory;
import org.eclipse.emf.ecp.view.template.style.fontProperties.model.VTFontPropertiesStyleProperty;
import org.eclipse.emf.ecp.view.template.style.keybinding.model.VTKeyBinding;
import org.eclipse.emf.ecp.view.template.style.keybinding.model.VTKeyBindings;
import org.eclipse.emf.ecp.view.template.style.tableStyleProperty.model.RenderMode;
import org.eclipse.emf.ecp.view.template.style.tableStyleProperty.model.VTTableStyleProperty;
import org.eclipse.emf.ecp.view.template.style.tableStyleProperty.model.VTTableStylePropertyFactory;
import org.eclipse.emf.ecp.view.template.style.tableValidation.model.VTTableValidationFactory;
import org.eclipse.emf.ecp.view.template.style.tableValidation.model.VTTableValidationStyleProperty;
import org.eclipse.emf.edit.command.AddCommand;
import org.eclipse.emf.edit.command.MoveCommand;
import org.eclipse.emf.edit.command.RemoveCommand;
import org.eclipse.emf.edit.domain.EditingDomain;
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.emfforms.common.Optional;
import org.eclipse.emfforms.spi.common.BundleResolver;
import org.eclipse.emfforms.spi.common.BundleResolver.NoBundleFoundException;
import org.eclipse.emfforms.spi.common.BundleResolverFactory;
import org.eclipse.emfforms.spi.common.report.AbstractReport;
import org.eclipse.emfforms.spi.common.report.ReportService;
import org.eclipse.emfforms.spi.common.sort.NumberAwareStringComparator;
import org.eclipse.emfforms.spi.core.services.databinding.DatabindingFailedException;
import org.eclipse.emfforms.spi.core.services.databinding.DatabindingFailedReport;
import org.eclipse.emfforms.spi.core.services.databinding.EMFFormsDatabinding;
import org.eclipse.emfforms.spi.core.services.databinding.emf.EMFFormsDatabindingEMF;
import org.eclipse.emfforms.spi.core.services.editsupport.EMFFormsEditSupport;
import org.eclipse.emfforms.spi.core.services.label.EMFFormsLabelProvider;
import org.eclipse.emfforms.spi.core.services.label.NoLabelFoundException;
import org.eclipse.emfforms.spi.localization.EMFFormsLocalizationService;
import org.eclipse.emfforms.spi.localization.LocalizationServiceHelper;
import org.eclipse.emfforms.spi.swt.core.SWTDataElementIdHelper;
import org.eclipse.emfforms.spi.swt.core.layout.EMFFormsSWTLayoutUtil;
import org.eclipse.emfforms.spi.swt.core.layout.GridDescriptionFactory;
import org.eclipse.emfforms.spi.swt.core.layout.SWTGridCell;
import org.eclipse.emfforms.spi.swt.core.layout.SWTGridDescription;
import org.eclipse.emfforms.spi.swt.core.ui.SWTValidationUiService;
import org.eclipse.emfforms.spi.swt.table.AbstractTableViewerComposite;
import org.eclipse.emfforms.spi.swt.table.CellLabelProviderFactory;
import org.eclipse.emfforms.spi.swt.table.ColumnConfiguration;
import org.eclipse.emfforms.spi.swt.table.ColumnConfigurationBuilder;
import org.eclipse.emfforms.spi.swt.table.DNDProvider;
import org.eclipse.emfforms.spi.swt.table.EditingSupportCreator;
import org.eclipse.emfforms.spi.swt.table.TableConfiguration;
import org.eclipse.emfforms.spi.swt.table.TableConfigurationBuilder;
import org.eclipse.emfforms.spi.swt.table.TableControl;
import org.eclipse.emfforms.spi.swt.table.TableViewerComparator;
import org.eclipse.emfforms.spi.swt.table.TableViewerCompositeBuilder;
import org.eclipse.emfforms.spi.swt.table.TableViewerCreator;
import org.eclipse.emfforms.spi.swt.table.TableViewerFactory;
import org.eclipse.emfforms.spi.swt.table.TableViewerSWTBuilder;
import org.eclipse.emfforms.spi.swt.table.TableViewerSWTCustomization;
import org.eclipse.emfforms.spi.swt.table.ViewerRefreshManager;
import org.eclipse.emfforms.spi.swt.table.action.ActionBar;
import org.eclipse.emfforms.spi.swt.table.action.ActionConfiguration;
import org.eclipse.emfforms.spi.swt.table.action.ActionConfigurationBuilder;
import org.eclipse.emfforms.spi.swt.table.action.TableActionBar;
import org.eclipse.emfforms.spi.swt.table.action.ViewerActionContext;
import org.eclipse.emfforms.view.spi.multisegment.model.MultiSegmentUtil;
import org.eclipse.emfforms.view.spi.multisegment.model.VMultiDomainModelReferenceSegment;
import org.eclipse.jface.databinding.swt.WidgetProperties;
import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
import org.eclipse.jface.databinding.viewers.ObservableMapCellLabelProvider;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogLabelKeys;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.AbstractTableViewer;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.CellLabelProvider;
import org.eclipse.jface.viewers.ColumnViewer;
import org.eclipse.jface.viewers.ColumnViewerEditor;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationListener;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
import org.eclipse.jface.viewers.ColumnViewerEditorDeactivationEvent;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.IColorProvider;
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.TableViewer;
import org.eclipse.jface.viewers.TableViewerEditor;
import org.eclipse.jface.viewers.TableViewerFocusCellManager;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerCell;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DragSourceListener;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.DropTargetListener;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Widget;
import org.osgi.framework.Bundle;
import org.osgi.framework.FrameworkUtil;

/**
 * SWT Renderer for Table Control.
 *
 * @author Eugen Neufeld
 * @author Johannes Faltermeier
 *
 */
public class TableControlSWTRenderer extends AbstractControlSWTRenderer<VTableControl> {

	/**
	 * @since 1.10
	 */
	protected static final String FIXED_COLUMNS = "org.eclipse.rap.rwt.fixedColumns"; //$NON-NLS-1$
	/**
	 * @since 1.10
	 */
	protected static final String TABLE_CUSTOM_VARIANT = "org_eclipse_emf_ecp_control_table"; //$NON-NLS-1$
	/**
	 * @since 1.17
	 */
	protected static final Point VALIDATION_PREFERRED_SIZE = new Point(16, 17);

	private final Map<Integer, ECPCellEditorComparator> columnIndexToComparatorMap = new LinkedHashMap<Integer, ECPCellEditorComparator>();

	private final ImageRegistryService imageRegistryService;
	private final EMFDataBindingContext viewModelDBC;
	private final EMFFormsEditSupport emfFormsEditSupport;

	private SWTGridDescription rendererGridDescription;

	private AbstractTableViewer tableViewer;

	private Label validationIcon;
	private boolean showValidationSummaryTooltip;

	private Optional<Integer> minimumHeight;
	private Optional<Integer> maximumHeight;
	private Optional<Integer> visibleLines;
	private AbstractTableViewerComposite<? extends AbstractTableViewer> tableViewerComposite;
	private int regularColumnsStartIndex;
	private boolean isDisposing;
	private IObservableList<?> list;
	private final RunnableManager runnableManager = new RunnableManager(Display.getDefault());

	private TableViewerSWTCustomization<?> customization;

	/** The EReference describing the list shown by the table. */
	private EReference tableEReference;
	private EStructuralFeature[] columnFeatures;
	/** The feature of the column which is currently used for sorting. */
	private java.util.Optional<EStructuralFeature> sortColumnFeature = java.util.Optional.empty();
	private ModelChangeListener autoSortModelChangeListener;
	private final EMFFormsLocalizationService localizationService;
	private final BundleResolver bundleResolver = BundleResolverFactory.createBundleResolver();
	/** DO NOT USE DIRECTLY! Use {@link #getEnumeratorComparator()} instead. */
	private LocalizedEnumeratorComparator enumeratorComparator;

	private EMFFormsLocalizationService l10n;
	private String referenceDisplayName;

	/**
	 * Legacy constructor for backwards compatibility.
	 *
	 * @param vElement the view model element to be rendered
	 * @param viewContext the view context
	 * @param emfFormsDatabinding The {@link EMFFormsDatabinding}
	 * @param emfFormsLabelProvider The {@link EMFFormsLabelProvider}
	 * @param reportService The {@link ReportService}
	 * @param vtViewTemplateProvider The {@link VTViewTemplateProvider}
	 * @param imageRegistryService The {@link ImageRegistryService}
	 * @param emfFormsEditSupport The {@link EMFFormsEditSupport}
	 * @since 1.8
	 */
	@Deprecated
	// BEGIN COMPLEX CODE
	public TableControlSWTRenderer(
		VTableControl vElement,
		ViewModelContext viewContext,
		ReportService reportService,
		EMFFormsDatabindingEMF emfFormsDatabinding,
		EMFFormsLabelProvider emfFormsLabelProvider,
		VTViewTemplateProvider vtViewTemplateProvider,
		ImageRegistryService imageRegistryService,
		EMFFormsEditSupport emfFormsEditSupport) {
		// END COMPLEX CODE

		this(vElement, viewContext, reportService, emfFormsDatabinding, emfFormsLabelProvider, vtViewTemplateProvider,
			imageRegistryService, emfFormsEditSupport, viewContext.getService(EMFFormsLocalizationService.class));
	}

	/**
	 * Default constructor.
	 *
	 * @param vElement the view model element to be rendered
	 * @param viewContext the view context
	 * @param emfFormsDatabinding The {@link EMFFormsDatabinding}
	 * @param emfFormsLabelProvider The {@link EMFFormsLabelProvider}
	 * @param reportService The {@link ReportService}
	 * @param vtViewTemplateProvider The {@link VTViewTemplateProvider}
	 * @param imageRegistryService The {@link ImageRegistryService}
	 * @param emfFormsEditSupport The {@link EMFFormsEditSupport}
	 * @param localizationService The {@link EMFFormsLocalizationService}
	 * @since 1.22
	 */
	@Inject
	// BEGIN COMPLEX CODE
	public TableControlSWTRenderer(
		VTableControl vElement,
		ViewModelContext viewContext,
		ReportService reportService,
		EMFFormsDatabindingEMF emfFormsDatabinding,
		EMFFormsLabelProvider emfFormsLabelProvider,
		VTViewTemplateProvider vtViewTemplateProvider,
		ImageRegistryService imageRegistryService,
		EMFFormsEditSupport emfFormsEditSupport,
		EMFFormsLocalizationService localizationService) {
		// END COMPLEX CODE

		super(vElement, viewContext, reportService, emfFormsDatabinding, emfFormsLabelProvider, vtViewTemplateProvider);
		this.imageRegistryService = imageRegistryService;
		this.emfFormsEditSupport = emfFormsEditSupport;
		this.localizationService = localizationService;
		viewModelDBC = new EMFDataBindingContext();
	}

	@Override
	public SWTGridDescription getGridDescription(SWTGridDescription gridDescription) {
		if (rendererGridDescription == null) {
			if (getTableStyleProperty().getRenderMode() == RenderMode.COMPACT_VERTICALLY) {
				final boolean includeLabel = getVElement().getLabelAlignment() != LabelAlignment.NONE;
				if (getVElement().getLabelAlignment() == LabelAlignment.TOP) {
					Activator.getInstance().log(IStatus.WARNING, MessageFormat.format(
						Messages.TableControlSWTRenderer_LabelAlignmentTopNotSupportForRenderModeCompactVertically,
						getVElement().getName()));
				}
				rendererGridDescription = GridDescriptionFactory.INSTANCE.createCompactGrid(includeLabel, true, this);
			} else {
				rendererGridDescription = GridDescriptionFactory.INSTANCE.createSimpleGrid(1, 1, this);
			}

		}
		return rendererGridDescription;
	}

	@Override
	protected EMFFormsDatabindingEMF getEMFFormsDatabinding() {
		return (EMFFormsDatabindingEMF) super.getEMFFormsDatabinding();
	}

	@Override
	protected Control renderControl(SWTGridCell gridCell, final Composite parent) throws NoRendererFoundException,
		NoPropertyDescriptorFoundExeption {
		// compact label
		if (gridCell.getColumn() == 0 && rendererGridDescription.getColumns() == 3) {
			return createLabel(parent);
		}
		// compact validation
		if (gridCell.getColumn() == 0 && rendererGridDescription.getColumns() == 2
			|| gridCell.getColumn() == 1 && rendererGridDescription.getColumns() == 3) {
			validationIcon = createValidationIcon(parent);
			return validationIcon;
		}
		// Default
		return renderTableControl(gridCell, parent);
	}

	@SuppressWarnings("unchecked")
	@Override
	protected Control createLabel(final Composite parent) {
		final VDomainModelReference dmrToCheck = getDMRToMultiReference();
		final IObservableValue<?> labelText = getLabelText(dmrToCheck);
		final IObservableValue<?> labelTooltipText = getLabelTooltipText(dmrToCheck);

		final Label titleLabel = new Label(parent, AbstractControlSWTRendererUtil
			.getLabelStyleBits(getVTViewTemplateProvider(), getVElement(), getViewModelContext()));
		titleLabel.setData(CUSTOM_VARIANT, "org_eclipse_emf_ecp_control_label"); //$NON-NLS-1$
		titleLabel.setBackground(parent.getBackground());

		viewModelDBC.bindValue(
			WidgetProperties.text().observe(titleLabel),
			labelText);
		viewModelDBC.bindValue(
			WidgetProperties.tooltipText().observe(titleLabel),
			labelTooltipText);

		return titleLabel;
	}

	/**
	 * Renders the Table Control.
	 *
	 * Renders the Table Control including title and validation when {@link RenderMode} is set to
	 * {@link RenderMode#DEFAULT}. Only renders the
	 * Table Control without title and validation when renderMode is set to {@link RenderMode#COMPACT_VERTICALLY}.
	 *
	 * @param gridCell the {@link SWTGridCell}.
	 * @param parent the {@link Composite}.
	 * @return the rendered {@link Control}.
	 * @throws NoRendererFoundException the {@link NoRendererFoundException}.
	 * @throws NoPropertyDescriptorFoundExeption the {@link NoPropertyDescriptorFoundExeption}.
	 * @since 1.14
	 */
	protected Control renderTableControl(SWTGridCell gridCell, final Composite parent)
		throws NoRendererFoundException,
		NoPropertyDescriptorFoundExeption {
		try {
			/* get the list-setting which is displayed */
			final VDomainModelReference dmrToCheck = getDMRToMultiReference();

			/* get the observable list */
			list = getEMFFormsDatabinding().getObservableList(dmrToCheck,
				getViewModelContext().getDomainModel());

			/* get the EReference describing the list shown by the table */
			tableEReference = (EReference) list.getElementType();

			final TableRendererViewerActionContext actionContext = createViewerActionContext();
			final ActionConfiguration actionConfiguration = configureActions(actionContext);
			final TableActionBar<? extends AbstractTableViewer> actionBar = createActionBar(actionContext,
				actionConfiguration);

			/* get the label text/tooltip */
			final IObservableValue<?> labelText = getLabelText(dmrToCheck);
			final IObservableValue<?> labelTooltipText = getLabelTooltipText(dmrToCheck);

			/* content provider */
			final ObservableListContentProvider cp = new ObservableListContentProvider();

			final TableControlComparator comparator = getVElement().isMoveUpDownDisabled()
				? createTableViewerComparator()
				: null;

			/* render */
			final TableViewerCompositeBuilder compositeBuilder = createTableViewerCompositeBuilder();

			final TableViewerSWTBuilder tableViewerSWTBuilder = createTableViewerSWTBuilder(parent, list, labelText,
				labelTooltipText, compositeBuilder, cp, comparator, actionBar);
			tableViewerSWTBuilder.customizeActionConfiguration(actionConfiguration);

			tableViewerSWTBuilder
				.configureTable(TableConfigurationBuilder.from(tableViewerSWTBuilder)
					.dataMapEntry(TableConfiguration.DMR, dmrToCheck)
					.dataMapEntry(ViewerRefreshManager.REFRESH_MANAGER,
						(ViewerRefreshManager) this::postRefresh)
					.build());

			regularColumnsStartIndex = 0;

			/* validation column */
			if (!getVElement().isEffectivelyReadonly()) {
				regularColumnsStartIndex++;
				createFixedValidationStatusColumn(tableViewerSWTBuilder);
			}
			regularColumnsStartIndex += addAdditionalColumns(tableViewerSWTBuilder);
			addColumns(tableViewerSWTBuilder, EReference.class.cast(list.getElementType()).getEReferenceType(), cp);

			initCompositeHeight();

			tableViewerComposite = tableViewerSWTBuilder.build();

			/* setup selection changes listener */
			tableViewerComposite.getTableViewer().addSelectionChangedListener(new ViewerSelectionChangedListener());
			tableViewerComposite.getTableViewer().addDoubleClickListener(new DoubleClickListener());

			/* setup sorting via column selection */
			if (getVElement().isMoveUpDownDisabled()) {
				setupSorting(comparator, regularColumnsStartIndex, tableViewerComposite);
			}

			/* get validation icon */
			setupValidation(tableViewerComposite);

			/* create the table viewer editor */
			setTableViewer(tableViewerComposite.getTableViewer());

			SWTDataElementIdHelper.setElementIdDataForVControl(tableViewerComposite, getVElement(),
				getViewModelContext());

			// FIXME doesn't work with table with panel
			// setLayoutData(compositeBuilder.getViewerComposite());
			GridData.class
				.cast(compositeBuilder.getViewerComposite().getLayoutData()).heightHint = getTableHeightHint();

			addRelayoutListenerIfNeeded(list, compositeBuilder.getViewerComposite());

			addResizeListener(tableViewerComposite.getTableViewer().getControl(), regularColumnsStartIndex);

			customization = tableViewerSWTBuilder.getCustomization();

			autoSortModelChangeListener = new AutoSortModelChangeListener();
			getViewModelContext().registerDomainChangeListener(autoSortModelChangeListener);

			return tableViewerComposite;

		} catch (final DatabindingFailedException ex) {
			getReportService().report(new RenderingFailedReport(ex));
			final Label errorLabel = new Label(parent, SWT.NONE);
			errorLabel.setText(ex.getMessage());
			return errorLabel;
		}
	}

	/**
	 * Creates a TableControlComparator.
	 *
	 * @return TableControlComparator
	 * @since 1.22
	 */
	protected TableControlComparator createTableViewerComparator() {
		return new ECPTableViewerComparator();
	}

	/**
	 * Create the {@link ViewerActionContext} for the table viewer.
	 *
	 * @return the {@link TableRendererViewerActionContext}
	 * @throws DatabindingFailedException
	 * @since 1.18
	 */
	protected TableRendererViewerActionContext createViewerActionContext() {
		return new TableRendererViewerActionContext() {

			@Override
			public VTableControl getVElement() {
				return TableControlSWTRenderer.this.getVElement();
			}

			@Override
			public Setting getSetting() {
				try {
					return getEMFFormsDatabinding().getSetting(
						getDMRToMultiReference(), getViewModelContext().getDomainModel());
				} catch (final DatabindingFailedException ex) {
					return null; // this should never happen
				}
			}

			@Override
			public EditingDomain getEditingDomain() {
				return TableControlSWTRenderer.this.getEditingDomain(getViewModelContext().getDomainModel());
			}

			@Override
			public AbstractTableViewer getViewer() {
				return TableControlSWTRenderer.this.getTableViewer();
			}
		};
	}

	/**
	 * Configure the actions applicable to this table viewer.
	 *
	 * @param actionContext the action context
	 * @return an {@link ActionConfigurationImpl} built using the {@link ActionConfigurationBuilder}
	 *
	 * @since 1.18
	 */
	protected ActionConfiguration configureActions(TableRendererViewerActionContext actionContext) {
		final ActionConfigurationBuilder actionConfigBuilder = //
			ActionConfigurationBuilder.usingDefaults();

		/**
		 * Note: EMF Forms distinguishes between read-only and enabled.
		 * Read-only is a declarative state defined by the view model and cannot
		 * be overwritten during runtime whereas the enabled state can.
		 * Therefore, if the view element is marked as read-only we must not configure any buttons.
		 *
		 * @see @{link TableRenderAction#isTableDisabled()}
		 */
		if (getVElement().isEffectivelyReadonly()) {
			return actionConfigBuilder.build();
		}

		final Setting setting = actionContext.getSetting();
		final EClass eClass = ((EReference) setting.getEStructuralFeature()).getEReferenceType();

		if (!getVElement().isMoveUpDownDisabled()) {
			final MoveRowUpAction moveRowUpAction = new MoveRowUpAction(actionContext);
			final MoveRowDownAction moveRowDownAction = new MoveRowDownAction(actionContext);

			actionConfigBuilder
				.addAction(moveRowUpAction)
				.addControlFor(moveRowUpAction, new TableActionIconButton(
					formatTooltipText(eClass, MessageKeys.TableControl_MoveUp), getImage("icons/move_up.png"))) //$NON-NLS-1$
				.addKeySequenceFor(moveRowUpAction,
					getKeyBindingsForAction(MoveRowUpAction.ACTION_ID))
				//
				.addAction(moveRowDownAction)
				.addControlFor(moveRowDownAction, new TableActionIconButton(
					formatTooltipText(eClass, MessageKeys.TableControl_MoveDown), getImage("icons/move_down.png"))) //$NON-NLS-1$
				.addKeySequenceFor(moveRowDownAction,
					getKeyBindingsForAction(MoveRowDownAction.ACTION_ID));
		}

		if (!getVElement().isAddRemoveDisabled()) {
			final AddRowAction addRowAction = new AddRowAction(actionContext) {
				@Override
				public void addRowLegacy(
					final EClass eClass, final EStructuralFeature eStructuralFeature, final EObject eObject) {
					addRow(eClass, eObject, eStructuralFeature);
				}
			};
			final RemoveRowAction removeRowAction = new RemoveRowAction(actionContext) {
				@Override
				public void removeRowLegacy(List<EObject> deletionList, EObject eObject,
					EStructuralFeature eStructuralFeature) {
					deleteRowUserConfirmDialog(deletionList, eObject, eStructuralFeature, getAddButton(),
						getRemoveButton());
				}

				@Override
				public boolean canExecute() {
					final Setting setting = getActionContext().getSetting();
					return super.canExecute() && ConditionalDeleteService.getDeleteService(getViewModelContext())
						.canRemove(setting.getEObject(), setting.getEStructuralFeature(),
							getActionContext().getViewer().getStructuredSelection().toList());
				}
			};

			actionConfigBuilder
				.addAction(addRowAction)
				.addControlFor(addRowAction, new TableActionIconButton(
					formatTooltipText(eClass, MessageKeys.TableControl_AddInstanceOf), getImage("icons/add.png"))) //$NON-NLS-1$
				.addKeySequenceFor(addRowAction,
					getKeyBindingsForAction(AddRowAction.ACTION_ID));
			actionConfigBuilder
				.addAction(removeRowAction)
				.addControlFor(removeRowAction, new TableActionIconButton(
					formatTooltipText(eClass, MessageKeys.TableControl_RemoveSelected), getImage("icons/delete.png"))) //$NON-NLS-1$
				.addKeySequenceFor(removeRowAction,
					getKeyBindingsForAction(RemoveRowAction.ACTION_ID));
		}

		if (!getVElement().isDuplicateDisabled()) {
			final DuplicateRowAction duplicateRow = new DuplicateRowAction(actionContext);

			actionConfigBuilder
				.addAction(duplicateRow)
				.addControlFor(duplicateRow, new TableActionIconButton(
					formatTooltipText(eClass, MessageKeys.TableControl_Duplicate), getImage("icons/duplicate.png"))) //$NON-NLS-1$
				.addKeySequenceFor(duplicateRow,
					getKeyBindingsForAction(DuplicateRowAction.ACTION_ID));
		}

		return actionConfigBuilder.build();
	}

	/**
	 * Helper to extract the configured key bindings form the view template model.
	 *
	 * @param actionId the ID of the action to extract the key bindings for
	 * @param defaultKeybindings the default key bindings to use in case there are no bindings configured
	 * @return an array of key bindings
	 *
	 * @since 1.18
	 */
	protected String[] getKeyBindingsForAction(String actionId, String... defaultKeybindings) {
		final VTKeyBindings bindings = getStyleProperty(VTKeyBindings.class);
		if (bindings == null) {
			return defaultKeybindings;
		}
		final Set<String> ret = new LinkedHashSet<String>();
		for (final VTKeyBinding binding : bindings.getBindings()) {
			if (actionId.equals(binding.getId()) && binding.getKeySequence() != null
				&& !binding.getKeySequence().isEmpty()) {
				ret.add(binding.getKeySequence());
			}
		}
		return ret.toArray(new String[] {});
	}

	/**
	 * Creates an action bar.
	 *
	 * @param actionContext the {@link ViewerActionContext} to use
	 * @param actionConfiguration the {@link ActionConfiguration} to use
	 * @return a action bar builder
	 *
	 * @since 1.18
	 */
	protected TableActionBar<? extends AbstractTableViewer> createActionBar(
		TableRendererViewerActionContext actionContext, ActionConfiguration actionConfiguration) {
		return new TableRendererActionBar(actionContext, actionConfiguration, getViewModelContext());
	}

	/**
	 * Creates the {@link TableViewerCompositeBuilder} used to get Composite hierarchy for this table renderer. This
	 * method can be overwritten by sub classes to customize the layout.
	 *
	 * @return The {@link TableViewerCompositeBuilder}
	 * @since 1.13
	 */
	protected TableViewerCompositeBuilder createTableViewerCompositeBuilder() {
		if (getTableStyleProperty().getRenderMode() == RenderMode.COMPACT_VERTICALLY) {
			return new CompactVerticallyTableControlSWTRendererCompositeBuilder(false, false);
		}
		return new TableControlSWTRendererCompositeBuilder();
	}

	/**
	 * Creates a new {@link TableViewerSWTBuilder}.
	 *
	 * @param parent the parent {@link Composite}
	 * @param list the input object
	 * @param labelText the title
	 * @param labelTooltipText the tooltip
	 * @param compositeBuilder the {@link TableViewerCompositeBuilder}
	 * @param cp the content provider
	 * @param comparator the {@link ViewerComparator}; has no effect if move up/down
	 *            functionality is enabled
	 * @param actionBar the {@link ActionBar}
	 * @return the {@link TableViewerSWTBuilder}
	 * @since 1.18
	 * @deprecated Please use
	 *             {@link #createTableViewerSWTBuilder(Composite, IObservableList, IObservableValue, IObservableValue, TableViewerCompositeBuilder, ObservableListContentProvider, ViewerComparator, TableActionBar)}
	 *             instead
	 */
	@Deprecated
	// CHECKSTYLE.OFF: ParameterNumber
	protected TableViewerSWTBuilder createTableViewerSWTBuilder(Composite parent,
		@SuppressWarnings("rawtypes") IObservableList list,
		@SuppressWarnings("rawtypes") IObservableValue labelText,
		@SuppressWarnings("rawtypes") IObservableValue labelTooltipText, TableViewerCompositeBuilder compositeBuilder,
		ObservableListContentProvider cp, ECPTableViewerComparator comparator,
		TableActionBar<? extends AbstractTableViewer> actionBar) {
		// CHECKSTYLE.ON: ParameterNumber

		return createTableViewerSWTBuilder(parent, list, labelText, labelTooltipText, compositeBuilder, cp,
			(ViewerComparator) comparator,
			actionBar);
	}

	/**
	 * Creates a new {@link TableViewerSWTBuilder}.
	 *
	 * @param parent the parent {@link Composite}
	 * @param list the input object
	 * @param labelText the title
	 * @param labelTooltipText the tooltip
	 * @param compositeBuilder the {@link TableViewerCompositeBuilder}
	 * @param cp the content provider
	 * @param comparator the {@link ViewerComparator}; has no effect if move up/down
	 *            functionality is enabled
	 * @param actionBar the {@link ActionBar}
	 * @return the {@link TableViewerSWTBuilder}
	 * @since 1.22
	 *
	 */
	// CHECKSTYLE.OFF: ParameterNumber
	protected TableViewerSWTBuilder createTableViewerSWTBuilder(Composite parent,
		@SuppressWarnings("rawtypes") IObservableList list,
		@SuppressWarnings("rawtypes") IObservableValue labelText,
		@SuppressWarnings("rawtypes") IObservableValue labelTooltipText, TableViewerCompositeBuilder compositeBuilder,
		ObservableListContentProvider cp, ViewerComparator comparator,
		TableActionBar<? extends AbstractTableViewer> actionBar) {
		// CHECKSTYLE.ON: ParameterNumber
		return TableViewerFactory.fillDefaults(parent, SWT.NONE, list, labelText, labelTooltipText)
			.customizeCompositeStructure(compositeBuilder)
			.customizeActionBar(actionBar)
			.customizeTableViewerCreation(getTableViewerCreator())
			.customizeContentProvider(cp)
			.customizeComparator(comparator)
			.customizeDragAndDrop(new TableControlSWTRendererDragAndDrop());

	}

	/**
	 * Creates a new instance of the {@link TableViewerCreator} to be used.
	 *
	 * @return the {@link TableViewerCreator}
	 * @since 1.10
	 */
	protected TableViewerCreator<? extends AbstractTableViewer> getTableViewerCreator() {
		return new TableControlSWTRendererTableViewerCreator();
	}

	/**
	 * Override this method to add additional static columns at the beginning of the table.
	 *
	 * @param tableViewerSWTBuilder the builder
	 * @return the number of columns added
	 * @since 1.9
	 */
	protected int addAdditionalColumns(TableViewerSWTBuilder tableViewerSWTBuilder) {
		return 0;
	}

	/**
	 * Returns the zero-relative index of the item which is currently selected in the receiver, or -1 if no item is
	 * selected.
	 *
	 * @return the index of the selected item
	 * @since 1.10
	 */
	protected int getSelectionIndex() {
		return ((TableViewer) tableViewer).getTable().getSelectionIndex();
	}

	/**
	 * Returns an array of {@link Item items} which are the columns in the table.
	 *
	 * @return the columns of the table
	 * @since 1.10
	 */
	protected Item[] getColumns() {
		return ((TableViewer) tableViewer).getTable().getColumns();
	}

	/**
	 * Returns the receiver's horizontal scroll bar if it has one, and null if it does not.
	 *
	 * @return the horizontal scroll bar (or null)
	 * @since 1.10
	 */
	protected ScrollBar getHorizontalBar() {
		return ((TableViewer) tableViewer).getTable().getHorizontalBar();
	}

	/**
	 * Returns the receiver's vertical scroll bar if it has one, and null if it does not.
	 *
	 * @return the vertical scroll bar (or null)
	 * @since 1.10
	 */
	protected ScrollBar getVerticalBar() {
		return ((TableViewer) tableViewer).getTable().getVerticalBar();
	}

	private void addResizeListener(final Control control, final int regularColumnsStartIndex) {
		final ControlAdapter controlAdapter = new ControlAdapter() {
			@Override
			public void controlResized(ControlEvent e) {
				updateTableColumnWidths(control, regularColumnsStartIndex);
			}
		};
		control.addControlListener(controlAdapter);

		tableViewerComposite.addColumnListener(controlAdapter);
	}

	private void updateTableColumnWidths(Control table, int regularColumnsStartIndex) {
		if (isDisposing) {
			return;
		}
		final VTableControl tableControl = getVElement();
		final Widget[] allColumns = tableViewerComposite.getColumns();
		for (int i = regularColumnsStartIndex; i < allColumns.length; i++) {
			final Widget tableColumn = allColumns[i];
			final VDomainModelReference columnDMR = getColumnDomainModelReferences().get(i - regularColumnsStartIndex);
			TableConfigurationHelper.updateWidthConfiguration(tableControl, columnDMR, tableColumn);
		}
	}

	private void initCompositeHeight() {
		final VTTableStyleProperty styleProperty = getTableStyleProperty();
		minimumHeight = styleProperty.isSetMinimumHeight() ? Optional.of(styleProperty.getMinimumHeight())
			: Optional.<Integer> empty();
		maximumHeight = styleProperty.isSetMaximumHeight() ? Optional.of(styleProperty.getMaximumHeight())
			: Optional.<Integer> empty();
		visibleLines = styleProperty.isSetVisibleLines() ? Optional.of(styleProperty.getVisibleLines())
			: Optional.<Integer> empty();
	}

	private <T> void addRelayoutListenerIfNeeded(IObservableList<T> list, final Composite composite) {
		if (list == null) {
			return;
		}

		// relayout is only needed if min height != max height
		if (!minimumHeight.isPresent() && !maximumHeight.isPresent()) {
			return;
		}
		if (minimumHeight.isPresent() && maximumHeight.isPresent() && minimumHeight.get() == maximumHeight.get()) {
			return;
		}

		final GridData gridData = GridData.class.cast(composite.getLayoutData());
		list.addListChangeListener(new IListChangeListener<T>() {
			@Override
			public void handleListChange(ListChangeEvent<? extends T> event) {
				gridData.heightHint = getTableHeightHint();
				EMFFormsSWTLayoutUtil.adjustParentSize(composite);
			}
		});
	}

	/**
	 * Adds the table columns to the {@link TableViewerSWTBuilder}.
	 *
	 * @param tableViewerSWTBuilder the builder
	 * @param clazz the {@EClass} of the rendered object
	 * @param cp the content provider
	 * @param tableConfiguration
	 *
	 */
	private void addColumns(TableViewerSWTBuilder tableViewerSWTBuilder, EClass clazz,
		ObservableListContentProvider cp) {
		InternalEObject tempInstance = null;
		if (!clazz.isAbstract() && !clazz.isInterface()) {
			tempInstance = getInstanceOf(clazz);
		}

		final List<VDomainModelReference> columns = getColumnDomainModelReferences().stream().filter(Objects::nonNull)
			.collect(Collectors.toList());
		/* regular columns */
		columnFeatures = new EStructuralFeature[columns.size()];
		for (int i = 0; i < columns.size(); i++) {
			try {
				final VDomainModelReference dmr = columns.get(i);
				final IObservableValue<?> text = getLabelTextForColumn(dmr, clazz);
				final IObservableValue<?> tooltip = getLabelTooltipTextForColumn(dmr, clazz);

				// Use the same editing domain for the columns as for the view's domain object
				final EditingDomain editingDomain = getEditingDomain(getViewModelContext().getDomainModel());
				final IValueProperty<?, ?> valueProperty = getEMFFormsDatabinding().getValueProperty(dmr, clazz,
					editingDomain);
				final EStructuralFeature eStructuralFeature = (EStructuralFeature) valueProperty.getValueType();
				columnFeatures[i] = eStructuralFeature;

				@SuppressWarnings("unchecked")
				final IObservableMap<?, ?> observableMap = valueProperty.observeDetail(cp.getKnownElements());

				final TableControlEditingSupportAndLabelProvider labelProvider = new TableControlEditingSupportAndLabelProvider(
					tempInstance, eStructuralFeature, dmr, valueProperty, observableMap,
					getColumnDomainModelReferences().indexOf(dmr));
				final EditingSupportCreator editingSupportCreator = TableConfigurationHelper
					.isReadOnly(getVElement(), dmr) ? null : labelProvider;

				final Optional<Integer> weightConfig = TableConfigurationHelper.getColumnWeight(getVElement(), dmr);
				final Optional<Integer> widthConfig = TableConfigurationHelper.getColumnWidth(getVElement(), dmr);

				int weight;
				int minWidth;
				if (weightConfig.isPresent()) {
					minWidth = widthConfig.get();
					weight = weightConfig.get();
				} else {
					// TODO ugly: we need this temporary cell editor so early just to get size information
					final Shell tempShell = new Shell();
					final CellEditor tempCellEditor = createCellEditor(tempInstance, eStructuralFeature,
						new Table(tempShell, SWT.NONE));
					weight = ECPCellEditor.class.isInstance(tempCellEditor)
						? ECPCellEditor.class.cast(tempCellEditor).getColumnWidthWeight()
						: 100;
					minWidth = ECPCellEditor.class.isInstance(tempCellEditor)
						? ECPCellEditor.class.cast(tempCellEditor).getMinWidth()
						: 10;
					tempShell.dispose();
				}

				tableViewerSWTBuilder.addColumn(
					ColumnConfigurationBuilder.from(tableViewerSWTBuilder)
						.weight(weight)
						.minWidth(minWidth)
						.text(text)
						.tooltip(tooltip)
						.labelProviderFactory(labelProvider)
						.editingSupportCreator(editingSupportCreator)
						.dataMapEntry(ColumnConfiguration.DMR, dmr)
						.build());

			} catch (final DatabindingFailedException ex) {
				getReportService().report(new RenderingFailedReport(ex));
				continue;
			}
		}

	}

	private void setupValidation(
		final AbstractTableViewerComposite<? extends AbstractTableViewer> tableViewerComposite) {
		if (tableViewerComposite.getValidationControls().isPresent()) {
			final List<Control> validationControls = tableViewerComposite.getValidationControls().get();
			if (validationControls.size() == 1 && Label.class.isInstance(validationControls.get(0))) {
				validationIcon = (Label) validationControls.get(0);
			}

			final VTTableStyleProperty tableStyleProperty = getTableStyleProperty();
			showValidationSummaryTooltip = tableStyleProperty.isShowValidationSummaryTooltip();
		}
	}

	private void setupSorting(final TableViewerComparator comparator, int regularColumnsStartIndex,
		final AbstractTableViewerComposite<? extends AbstractTableViewer> tableViewerComposite) {

		final VTTableStyleProperty tableStyleProperty = getTableStyleProperty();
		if (!tableStyleProperty.isEnableSorting()) {
			return;
		}
		final int length = tableViewerComposite.getColumns().length;
		final List<Integer> sortableColumns = new ArrayList<Integer>();
		for (int i = 0; i < length; i++) {
			if (i >= regularColumnsStartIndex) {
				sortableColumns.add(i);
			}
		}
		tableViewerComposite.setComparator(comparator, sortableColumns);
	}

	private IObservableValue<?> getLabelText(VDomainModelReference dmrToCheck) {
		switch (getVElement().getLabelAlignment()) {
		case NONE:
			return Observables.constantObservableValue("", String.class); //$NON-NLS-1$
		default:
			try {
				return getEMFFormsLabelProvider().getDisplayName(dmrToCheck, getViewModelContext().getDomainModel());
			} catch (final NoLabelFoundException e) {
				// FIXME Expectation?
				getReportService().report(new RenderingFailedReport(e));
				return Observables.constantObservableValue(e.getMessage(), String.class);
			}
		}
	}

	private IObservableValue<?> getLabelTextForColumn(VDomainModelReference dmrToCheck, EClass dmrRootEClass) {
		try {
			// See whether the view model specifies a label for the column
			final Optional<VEnablementConfiguration> config = TableConfigurationHelper
				.findEnablementConfiguration(getVElement(), dmrToCheck);
			if (config.isPresent()) {
				final String label = config.get().getLabel();
				if (label != null && !label.isEmpty()) {
					@SuppressWarnings("unchecked")
					final IValueProperty<VElement, String> labelProperty = EMFProperties
						.value(VViewPackage.Literals.ELEMENT__LABEL);
					return labelProperty.observe(config.get());
				}
			}
			return getEMFFormsLabelProvider().getDisplayName(dmrToCheck, dmrRootEClass);
		} catch (final NoLabelFoundException e) {
			// FIXME Expectation?
			getReportService().report(new RenderingFailedReport(e));
			return Observables.constantObservableValue(e.getMessage(), String.class);
		}
	}

	private IObservableValue<?> getLabelTooltipText(VDomainModelReference dmrToCheck) {
		switch (getVElement().getLabelAlignment()) {
		case NONE:
			return Observables.constantObservableValue("", String.class); //$NON-NLS-1$
		default:
			try {
				return getEMFFormsLabelProvider().getDescription(dmrToCheck, getViewModelContext().getDomainModel());
			} catch (final NoLabelFoundException e) {
				// FIXME Expectation?
				getReportService().report(new RenderingFailedReport(e));
				return Observables.constantObservableValue(e.toString(), String.class);
			}
		}
	}

	private IObservableValue<?> getLabelTooltipTextForColumn(VDomainModelReference dmrToCheck, EClass dmrRootEClass) {
		try {
			return getEMFFormsLabelProvider().getDescription(dmrToCheck, dmrRootEClass);
		} catch (final NoLabelFoundException e) {
			// FIXME Expectation?
			getReportService().report(new RenderingFailedReport(e));
			return Observables.constantObservableValue(e.toString(), String.class);
		}
	}

	/**
	 * @return the {@link VDomainModelReference} which ends at the table setting
	 * @since 1.11
	 */
	protected VDomainModelReference getDMRToMultiReference() {
		// A segment based view model uses the plain dmr
		if (getVElement().getDomainModelReference().eClass() == VViewPackage.Literals.DOMAIN_MODEL_REFERENCE) {
			return getVElement().getDomainModelReference();
		}

		final VTableDomainModelReference tableDomainModelReference = (VTableDomainModelReference) getVElement()
			.getDomainModelReference();
		final VDomainModelReference dmrToCheck = tableDomainModelReference.getDomainModelReference() == null
			? tableDomainModelReference
			: tableDomainModelReference.getDomainModelReference();
		return dmrToCheck;
	}

	/**
	 * Allows to add additional buttons to the button bar of the table control.
	 * <p>
	 * The default implementation does not add additional buttons.
	 * </p>
	 *
	 * @param buttonComposite the composite where the buttons are added
	 * @return the total number of buttons added
	 */
	protected int addButtonsToButtonBar(Composite buttonComposite) {
		return 0;
	}

	/**
	 * Creates and returns the composite which will be the parent for the table viewer.
	 *
	 * @param composite the parent composite including the title/button bar
	 * @return the parent for the table viewer
	 */
	protected Composite createControlComposite(Composite composite) {
		final Composite controlComposite = new Composite(composite, SWT.NONE);
		GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).hint(1, getTableHeightHint())
			.applyTo(controlComposite);
		GridLayoutFactory.fillDefaults().numColumns(1).applyTo(controlComposite);
		return controlComposite;
	}

	/**
	 * Returns the preferred height for the table. This will be passed to the layoutdata.
	 *
	 * @return the height in px
	 */
	// BEGIN COMPLEX CODE
	protected int getTableHeightHint() {
		/* if neither min nor max is set we use a fixed height */
		if (!minimumHeight.isPresent() && !maximumHeight.isPresent() && !visibleLines.isPresent()) {
			return 200;
		}
		// if the visible lines attribute is present, it takes precedence over the minimum & maximum height hints
		if (visibleLines.isPresent()) {
			return computeRequiredHeight(visibleLines.get());
		}
		if (minimumHeight.isPresent() && maximumHeight.isPresent() && minimumHeight.get() == maximumHeight.get()) {
			return minimumHeight.get();
		}

		final int requiredHeight = computeRequiredHeight(null);

		if (minimumHeight.isPresent() && !maximumHeight.isPresent()) {
			return requiredHeight < minimumHeight.get() ? minimumHeight.get() : requiredHeight;
		}

		if (!minimumHeight.isPresent() && maximumHeight.isPresent()) {
			return requiredHeight > maximumHeight.get() ? maximumHeight.get() : requiredHeight;
		}

		if (requiredHeight < minimumHeight.get()) {
			return minimumHeight.get();
		}

		if (requiredHeight > maximumHeight.get()) {
			return maximumHeight.get();
		}

		return requiredHeight;
	}
	// END COMPLEX CODE

	/**
	 * Returns the height in pixels required to display the given number of table items. If the visible items are not
	 * specified, the height required to display all the table items is returned.
	 *
	 * @param visibleLines the number of visible table items
	 * @return the required height
	 * @since 1.13
	 */
	protected int computeRequiredHeight(Integer visibleLines) {
		if (tableViewer == null) {
			return SWT.DEFAULT;
		}
		final TableControl table = tableViewerComposite.getTableControl();
		if (table == null) {
			return SWT.DEFAULT;
		}
		if (table.isDisposed()) {
			return SWT.DEFAULT;
		}
		final int itemHeight = table.getItemHeight();
		// show one empty row if table does not contain any items or visibleLines < 1
		int itemCount;
		if (visibleLines != null) {
			itemCount = Math.max(visibleLines, 1);
		} else {
			itemCount = Math.max(table.getItemCount(), 1);
		}
		final int headerHeight = table.getHeaderVisible() ? table.getHeaderHeight() : 0;
		// 4px needed as a buffer to avoid scrollbars
		final int tableHeight = itemHeight * itemCount + headerHeight + 4;
		return tableHeight;
	}

	/**
	 * Returns the table viewer.
	 *
	 * @return the viewer
	 * @since 1.10
	 */
	protected AbstractTableViewer getTableViewer() {
		return tableViewer;
	}

	/**
	 * Returns the {@link AbstractTableViewerComposite}.
	 *
	 * @return the table viewer composite
	 * @since 1.13
	 */
	@SuppressWarnings("rawtypes")
	protected AbstractTableViewerComposite getTableViewerComposite() {
		return tableViewerComposite;
	}

	/**
	 * Sets the table viewer.
	 *
	 * @param tableViewer the viewer
	 * @since 1.10
	 */
	protected void setTableViewer(AbstractTableViewer tableViewer) {
		this.tableViewer = tableViewer;
	}

	/**
	 * This method gets called when the selection on the {@link TableViewer} (see {@link #getTableViewer()}) has
	 * changed.
	 * <p>
	 * If you override this method make sure to call super.
	 * </p>
	 *
	 * @param event the {@link SelectionChangedEvent}
	 */
	protected void viewerSelectionChanged(SelectionChangedEvent event) {
		// The default implementation does not need to do anything
	}

	private void createFixedValidationStatusColumn(TableViewerSWTBuilder tableViewerSWTBuilder) {
		final VTTableValidationStyleProperty tableValidationStyleProperty = getTableValidationStyleProperty();
		final int columnWidth = tableValidationStyleProperty.getColumnWidth();
		final String columnName = tableValidationStyleProperty.getColumnName();
		final String imagePath = tableValidationStyleProperty.getImagePath();
		Image image = null;
		if (imagePath != null && !imagePath.isEmpty()) {
			try {
				image = getImage(new URL(imagePath));
			} catch (final MalformedURLException ex) {
				getReportService().report(new AbstractReport(ex));
			}
		}

		tableViewerSWTBuilder.addColumn(
			ColumnConfigurationBuilder.usingDefaults()
				.minWidth(columnWidth)
				.text(columnName)
				.tooltip(columnName)
				.labelProvider(new ValidationStatusCellLabelProvider(getVElement()))
				.image(image)
				.build());

	}

	/**
	 * Retrieve images from the {@link ImageRegistryService} using an {@link URL}.
	 *
	 * @param url The {@link URL} pointing to the image
	 * @return The retrieved Image
	 * @since 1.6
	 */
	protected Image getImage(URL url) {
		return imageRegistryService.getImage(url);
	}

	/**
	 * Retrieve images from the {@link ImageRegistryService} using a bundle relative path.
	 *
	 * @param path The bundle relative path pointing to the image
	 * @return The retrieved Image
	 * @since 1.6
	 */
	protected Image getImage(String path) {
		Image result = imageRegistryService.getImage(FrameworkUtil.getBundle(getClass()), path);
		if (result == null && getClass() != TableControlSWTRenderer.class) {
			result = imageRegistryService.getImage(FrameworkUtil.getBundle(TableControlSWTRenderer.class), path);
		}
		return result;
	}

	/**
	 * Returns the {@link VTTableValidationStyleProperty}.
	 *
	 * @return the {@link VTTableValidationStyleProperty}
	 * @since 1.14
	 */
	protected VTTableValidationStyleProperty getTableValidationStyleProperty() {
		VTTableValidationStyleProperty tableValidationStyleProperties = getStyleProperty(
			VTTableValidationStyleProperty.class);
		if (tableValidationStyleProperties == null) {
			tableValidationStyleProperties = createDefaultTableValidationStyleProperty();
		}
		return tableValidationStyleProperties;
	}

	/**
	 * Creates the default {@link VTTableValidationStyleProperty}.
	 *
	 * @return the default {@link VTTableValidationStyleProperty}
	 * @since 1.14
	 */
	protected VTTableValidationStyleProperty createDefaultTableValidationStyleProperty() {
		final VTTableValidationStyleProperty tableValidationProp = VTTableValidationFactory.eINSTANCE
			.createTableValidationStyleProperty();
		tableValidationProp.setColumnWidth(80);
		tableValidationProp.setColumnName(LocalizationServiceHelper.getString(TableControlSWTRenderer.class,
			MessageKeys.TableControl_ValidationStatusColumn));
		tableValidationProp.setImagePath(null);
		return tableValidationProp;
	}

	/**
	 * Returns the {@link VTBackgroundStyleProperty}.
	 *
	 * @return the {@link VTBackgroundStyleProperty}
	 *
	 * @since 1.10
	 */
	protected VTBackgroundStyleProperty getBackgroundStyleProperty() {
		VTBackgroundStyleProperty styleProperty = getStyleProperty(VTBackgroundStyleProperty.class);
		if (styleProperty == null) {
			styleProperty = createDefaultBackgroundStyleProperty();
		}
		return styleProperty;
	}

	/**
	 * Creates the default {@link VTBackgroundStyleProperty}.
	 *
	 * @return the default {@link VTBackgroundStyleProperty}
	 * @since 1.14
	 */
	protected VTBackgroundStyleProperty createDefaultBackgroundStyleProperty() {
		return VTBackgroundFactory.eINSTANCE.createBackgroundStyleProperty();
	}

	/**
	 * Returns the {@link VTTableStyleProperty}.
	 *
	 * @return the {@link VTTableStyleProperty}
	 * @since 1.14
	 */
	protected VTTableStyleProperty getTableStyleProperty() {
		VTTableStyleProperty styleProperty = getStyleProperty(VTTableStyleProperty.class);
		if (styleProperty == null) {
			styleProperty = createDefaultTableStyleProperty();
		}
		return styleProperty;
	}

	/**
	 * Creates the default {@link VTTableStyleProperty}.
	 *
	 * @return the default {@link VTTableStyleProperty}
	 * @since 1.14
	 */
	protected VTTableStyleProperty createDefaultTableStyleProperty() {
		final VTTableStyleProperty tableStyleProperty = VTTableStylePropertyFactory.eINSTANCE
			.createTableStyleProperty();
		tableStyleProperty.setMaximumHeight(200);
		if (!getVElement().isEffectivelyReadonly()) {
			tableStyleProperty.setMinimumHeight(200);
		}
		return tableStyleProperty;
	}

	/**
	 * Returns the {@link VTFontPropertiesStyleProperty}.
	 *
	 * @return the {@link VTFontPropertiesStyleProperty}
	 * @since 1.10
	 */
	protected VTFontPropertiesStyleProperty getFontPropertiesStyleProperty() {
		VTFontPropertiesStyleProperty styleProperty = getStyleProperty(VTFontPropertiesStyleProperty.class);
		if (styleProperty == null) {
			styleProperty = createDefaultFontPropertiesStyleProperty();
		}
		return styleProperty;
	}

	/**
	 * Creates the default {@link VTFontPropertiesStyleProperty}.
	 *
	 * @return the default {@link VTFontPropertiesStyleProperty}
	 * @since 1.14
	 */
	protected VTFontPropertiesStyleProperty createDefaultFontPropertiesStyleProperty() {
		final VTFontPropertiesStyleProperty property = VTFontPropertiesFactory.eINSTANCE
			.createFontPropertiesStyleProperty();
		property.setColorHEX("000000"); //$NON-NLS-1$
		return property;
	}

	private <SP extends VTStyleProperty> SP getStyleProperty(Class<SP> stylePropertyClass) {
		return RendererUtil.getStyleProperty(getVTViewTemplateProvider(), getVElement(), getViewModelContext(),
			stylePropertyClass);
	}

	/**
	 * Returns the {@link Color} specified by the provided String.
	 *
	 * @param colorHex the Hex String describing the color
	 * @return the {@link Color}
	 * @since 1.10
	 *
	 */
	protected Color getSWTColor(String colorHex) {
		final String redString = colorHex.substring(0, 2);
		final String greenString = colorHex.substring(2, 4);
		final String blueString = colorHex.substring(4, 6);
		final int red = Integer.parseInt(redString, 16);
		final int green = Integer.parseInt(greenString, 16);
		final int blue = Integer.parseInt(blueString, 16);
		return new Color(Display.getDefault(), red, green, blue);
	}

	/**
	 * Retrieves this table's column DMRs from the table DMR.
	 *
	 * @return The domain model references defining the columns of this table.
	 * @since 1.19
	 */
	protected EList<VDomainModelReference> getColumnDomainModelReferences() {
		final VDomainModelReference dmr = getVElement().getDomainModelReference();
		final java.util.Optional<VMultiDomainModelReferenceSegment> multiSegment = MultiSegmentUtil
			.getMultiSegment(dmr);
		if (multiSegment.isPresent()) {
			return multiSegment.get().getChildDomainModelReferences();
		}
		return VTableDomainModelReference.class.cast(dmr).getColumnDomainModelReferences();
	}

	/**
	 * This is called in order to setup the editing support for a table column.
	 *
	 * @param tempInstance the temporary input instance of the table
	 * @param feature the feature of the column
	 * @param table the table/parent
	 * @return the cell editor
	 * @since 1.10
	 */
	protected CellEditor createCellEditor(final EObject tempInstance, final EStructuralFeature feature,
		Composite table) {
		return CellEditorFactory.INSTANCE.getCellEditor(feature,
			tempInstance, table, getViewModelContext());
	}

	private InternalEObject getInstanceOf(EClass clazz) {
		return InternalEObject.class.cast(clazz.getEPackage().getEFactoryInstance().create(clazz));
	}

	/**
	 * This method shows a user confirmation dialog when the user attempts to delete a row in the table.
	 *
	 * @deprecated this method will be moved to {@link RemoveRowAction} in the future
	 * @param deletionList the list of selected EObjects to delete
	 * @param eObject The containment reference {@link EObject}
	 * @param structuralFeature The containment reference {@link EStructuralFeature}
	 * @param addButton the add button
	 * @param removeButton the remove button
	 * @since 1.6
	 */
	@Deprecated
	protected void deleteRowUserConfirmDialog(final List<EObject> deletionList, final EObject eObject,
		final EStructuralFeature structuralFeature, final Button addButton, final Button removeButton) {
		final MessageDialog dialog = new MessageDialog(addButton.getShell(),
			LocalizationServiceHelper.getString(TableControlSWTRenderer.class, MessageKeys.TableControl_Delete), null,
			LocalizationServiceHelper.getString(TableControlSWTRenderer.class,
				MessageKeys.TableControl_DeleteAreYouSure),
			MessageDialog.CONFIRM, new String[] {
				JFaceResources.getString(IDialogLabelKeys.YES_LABEL_KEY),
				JFaceResources.getString(IDialogLabelKeys.NO_LABEL_KEY) },
			0);

		new ECPDialogExecutor(dialog) {

			@Override
			public void handleResult(int codeResult) {
				if (codeResult == IDialogConstants.CANCEL_ID
					|| codeResult == SWT.DEFAULT) { // SWT.DEFAULT is return by closing a message dialog
					return;
				}

				deleteRows(deletionList, eObject, structuralFeature);

				final List<?> containments = (List<?>) eObject.eGet(structuralFeature, true);
				if (containments.size() < structuralFeature.getUpperBound()) {
					addButton.setEnabled(true);
				}
				if (containments.size() <= structuralFeature.getLowerBound()) {
					removeButton.setEnabled(false);
				}
			}
		}.execute();
	}

	/**
	 * This is called by {@link #deleteRowUserConfirmDialog(List)} after the user confirmed to delete the selected
	 * elements.
	 *
	 * @deprecated this method will be moved to {@link RemoveRowAction} in the future
	 * @param deletionList the list of {@link EObject EObjects} to delete
	 * @param eObject The containment reference {@link EObject}
	 * @param structuralFeature The containment reference {@link EStructuralFeature}
	 * @since 1.6
	 */
	@Deprecated
	protected void deleteRows(List<EObject> deletionList, final EObject eObject,
		final EStructuralFeature structuralFeature) {

		final EditingDomain editingDomain = getEditingDomain(eObject);

		/* assured by #isApplicable */
		final EReference reference = EReference.class.cast(structuralFeature);
		final List<Object> toDelete = new ArrayList<Object>(deletionList);
		if (reference.isContainment()) {
			DeleteService deleteService = getViewModelContext().getService(DeleteService.class);
			if (deleteService == null) {
				/*
				 * #getService(Class<?>) will report to the reportservice if it could not be found
				 * Use Default
				 */
				deleteService = new EMFDeleteServiceImpl();
			}
			deleteService.deleteElements(toDelete);
		} else {
			removeElements(editingDomain, eObject, reference, toDelete);
		}
	}

	private void removeElements(EditingDomain editingDomain, Object source, EStructuralFeature feature,
		Collection<Object> toRemove) {
		final Command removeCommand = RemoveCommand.create(editingDomain, source, feature, toRemove);
		if (removeCommand.canExecute()) {
			if (editingDomain.getCommandStack() == null) {
				removeCommand.execute();
			} else {
				editingDomain.getCommandStack().execute(removeCommand);
			}
		}
	}

	/**
	 * This method is called to add a new entry in the domain model and thus to create a new row in the table. The
	 * element to create is defined by the provided class.
	 * You can override this method but you have to call super nonetheless.
	 *
	 * @deprecated this method will be move to {@link AddRowAction} in the future
	 * @param clazz the {@link EClass} defining the EObject to create
	 * @param eObject The containment reference {@link EObject}
	 * @param structuralFeature The containment reference {@link EStructuralFeature}
	 * @since 1.6
	 */
	@Deprecated
	protected void addRow(EClass clazz, EObject eObject, EStructuralFeature structuralFeature) {
		Optional<EObject> eObjectToAdd = null;

		/* table service available => use specific behavior to create row */
		if (getViewModelContext().hasService(TableControlService.class)) {
			final TableControlService tableService = getViewModelContext()
				.getService(TableControlService.class);
			eObjectToAdd = tableService.createNewElement(clazz, eObject, structuralFeature);
		}
		/* no table service available, fall back to default */
		if (eObjectToAdd == null) {
			final ReferenceService referenceService = getViewModelContext().getService(ReferenceService.class);
			eObjectToAdd = referenceService.addNewModelElements(eObject, EReference.class.cast(structuralFeature),
				false);
		}

		if (!eObjectToAdd.isPresent()) {
			return;
		}

		final EObject instance = eObjectToAdd.get();
		final EditingDomain editingDomain = getEditingDomain(eObject);
		if (editingDomain == null) {
			return;
		}
		editingDomain.getCommandStack().execute(
			AddCommand.create(editingDomain, eObject, structuralFeature, instance));
		tableViewer.setSelection(new StructuredSelection(eObjectToAdd.get()), true);

	}

	@Override
	protected void applyValidation(VDiagnostic oldDiagnostic, VDiagnostic newDiagnostic) {
		getRunnableManager().executeAsync(new ComputeValidationUpdate(oldDiagnostic, newDiagnostic));
	}

	@Override
	protected void applyValidation() {
		if (!getRunnableManager().isRunning()) {
			getRunnableManager().executeAsync(new ApplyValidationRunnable());
		}
	}

	/**
	 * Obtain my runnable manager (visible for testability).
	 *
	 * @return my runnable manager
	 */
	final RunnableManager getRunnableManager() {
		return runnableManager;
	}

	/**
	 * Post a request to refresh my {@linkplain #getTableViewer() viewer} on the
	 * asynchronous refresh manager.
	 *
	 * @since 1.21
	 * @see #getTableViewer()
	 * @see ViewerRefreshManager
	 */
	protected void postRefresh() {
		postRefresh(getRefreshRunnable(getTableViewer()));
	}

	/**
	 * Post a refresh request on the asynchronous refresh manager.
	 *
	 * @param refreshRunnable the refresh operation to execute
	 * @since 1.21
	 * @see ViewerRefreshManager
	 */
	protected void postRefresh(Runnable refreshRunnable) {
		final Viewer viewer = getTableViewer();
		if (viewer != null && !viewer.getControl().isDisposed()) {
			getRunnableManager().executeAsync(refreshRunnable);
		}
	}

	/**
	 * Returns the add button created by the framework.
	 *
	 * @deprecated use {@link #getControlForAction(String)} instead
	 * @return the addButton
	 * @since 1.6
	 */
	@Deprecated
	protected Button getAddButton() {
		final Optional<Control> control = getControlForAction(AddRowAction.ACTION_ID);
		if (control.isPresent()) {
			return (Button) control.get();
		}
		return null; // happens when add/remove has been disabled in the view model
	}

	/**
	 * Returns the remove button created by the framework.
	 *
	 * @deprecated use {@link #getControlForAction(String)} instead
	 * @return the removeButton
	 * @since 1.6
	 */
	@Deprecated
	protected Button getRemoveButton() {
		final Optional<Control> control = getControlForAction(RemoveRowAction.ACTION_ID);
		if (control.isPresent()) {
			return (Button) control.get();
		}
		return null; // happens when add/remove has been disabled in the view model
	}

	/**
	 * Returns the control created to trigger a certain action.
	 *
	 * @param actionId the action ID of the action that is bound to the control
	 * @return an optional for the control of the given action ID
	 * @since 1.18
	 */
	public Optional<Control> getControlForAction(String actionId) {
		if (tableViewerComposite.getActionBar().isPresent()) {
			return tableViewerComposite.getActionBar().get().getControlById(actionId);
		}
		return Optional.empty();
	}

	/**
	 * Helper method which uses an EMFForms observable value to get the setting for the given
	 * {@link VDomainModelReference}.
	 *
	 * @param dmr the {@link VDomainModelReference}
	 * @param eObject the {@link EObject} to get the setting for
	 * @return an Optional<Setting>
	 *
	 * @since 1.17
	 */
	protected Optional<Setting> getSettingFromObservable(VDomainModelReference dmr, EObject eObject) {
		@SuppressWarnings("rawtypes")
		IObservableValue observableValue = null;
		try {
			observableValue = getEMFFormsDatabinding().getObservableValue(dmr, eObject);

			final EStructuralFeature feature = (EStructuralFeature) observableValue.getValueType();
			final EObject observed = (EObject) ((IObserving) observableValue).getObserved();

			// Given EClass has no such feature
			if (observed == null || observed.eClass().getFeatureID(feature) == -1) {
				return Optional.empty();
			}

			return Optional.of(((InternalEObject) observed).eSetting(feature));

		} catch (final DatabindingFailedException ex) {
			getReportService().report(new DatabindingFailedReport(ex));
			return Optional.empty();
		} finally {
			if (observableValue != null) {
				observableValue.dispose();
			}
		}

	}

	@Override
	protected void applyEnable() {
		updateActionBar();
	}

	@Override
	protected void applyReadOnly() {
		updateActionBar();
	}

	@Override
	protected void applyUnchangeableFeature() {
		getVElement().setAddRemoveDisabled(true);
		getVElement().setDuplicateDisabled(true);
		getVElement().setMoveUpDownDisabled(true);
		updateActionBar();
	}

	/**
	 * Update this table control's action bar if it is present.
	 *
	 * @since 1.20
	 */
	protected void updateActionBar() {
		if (tableViewerComposite != null && tableViewerComposite.getActionBar().isPresent()) {
			tableViewerComposite.getActionBar().get().updateActionBar();
		}
	}

	@Override
	protected void dispose() {
		isDisposing = true;
		rendererGridDescription = null;
		viewModelDBC.dispose();
		if (list != null) {
			list.dispose();
		}
		if (columnIndexToComparatorMap != null) {
			for (final ECPCellEditorComparator value : columnIndexToComparatorMap.values()) {
				if (value instanceof CellEditor) {
					((CellEditor) value).dispose();
				}
			}
			columnIndexToComparatorMap.clear();
		}
		if (tableViewerComposite != null) {
			tableViewerComposite.dispose();
			tableViewerComposite = null;
		}
		if (tableViewer != null) {
			tableViewer.getControl().dispose();
			tableViewer = null;
		}

		if (customization != null) {
			for (final ColumnConfiguration columnConfig : customization.getColumnConfigurations()) {
				columnConfig.visible().dispose();
				columnConfig.dispose();
			}
			customization.getTableConfiguration().dispose();
		}

		if (autoSortModelChangeListener != null) {
			getViewModelContext().unregisterDomainChangeListener(autoSortModelChangeListener);
			autoSortModelChangeListener = null;
		}
		super.dispose();
	}

	/**
	 * Get called by the {@link ECPTableViewerComparator} in order to compare the given objects.
	 *
	 * @param viewer the table viewer
	 * @param left the first object of the comparison
	 * @param right the second object of the comparison
	 * @param propertyIndex index of the selection column. the index is aligned with the index of the associated column
	 *            domain model reference
	 * @param direction 0 (no sorting = insertion order := {@link SWT#NONE}), 1 (ascending := {@link SWT#DOWN}) or 2
	 *            (descending := {@link SWT#UP}) according to the indication displayed at
	 *            the table column.
	 * @return a negative number if the first element is less than the
	 *         second element; the value <code>0</code> if the first element is
	 *         equal to the second element; and a positive number if the first
	 *         element is greater than the second element
	 * @since 1.8
	 */
	// BEGIN COMPLEX CODE
	@SuppressWarnings("unchecked")
	protected int compare(Viewer viewer, Object left, Object right, int direction, int propertyIndex) {
		if (direction == 0) {
			return 0;
		}

		// We might have ignored columns at the beginning
		propertyIndex = propertyIndex - regularColumnsStartIndex;
		if (propertyIndex < 0) {
			return 0;
		}
		int rc = 0;

		final VDomainModelReference dmr = getColumnDomainModelReferences().get(propertyIndex);

		final Optional<Setting> leftSetting = getSettingFromObservable(dmr, (EObject) left);
		final Optional<Setting> rightSetting = getSettingFromObservable(dmr, (EObject) right);

		final Object leftValue = leftSetting.isPresent() ? leftSetting.get().get(true) : null;
		final Object rightValue = rightSetting.isPresent() ? rightSetting.get().get(true) : null;

		if (columnIndexToComparatorMap.containsKey(propertyIndex)) {
			return columnIndexToComparatorMap.get(propertyIndex).compare(leftValue, rightValue, direction);
		}

		if (leftValue == null) {
			if (rightValue == null) {
				rc = 0;
			} else {
				rc = 1;
			}
		} else if (rightValue == null) {
			rc = -1;
		} else {
			if (leftValue instanceof Enumerator) {
				final EStructuralFeature feature = leftSetting.get().getEStructuralFeature();
				rc = getEnumeratorComparator().compare(feature, (Enumerator) leftValue, (Enumerator) rightValue);
			} else if (!(leftValue instanceof String) && leftValue instanceof Comparable
				&& leftValue.getClass().isInstance(rightValue)) {
				rc = Comparable.class.cast(leftValue).compareTo(rightValue);
			} else {
				rc = NumberAwareStringComparator.getInstance().compare(leftValue.toString(), rightValue.toString());
			}
		}
		// If descending order, flip the direction
		if (direction == 2) {
			rc = -rc;
		}
		return rc;
	}
	// END COMPLEX CODE

	@Override
	protected void rootDomainModelChanged() throws DatabindingFailedException {

		final IObservableList<?> oldList = (IObservableList<?>) getTableViewer().getInput();
		oldList.dispose();

		final EObject domainModel = getViewModelContext().getDomainModel();
		final IObservableList<?> list = getEMFFormsDatabinding().getObservableList(getDMRToMultiReference(),
			domainModel);
		getTableViewer().setInput(list);

		if (tableViewerComposite.getActionBar().isPresent()) {
			tableViewerComposite.getActionBar().get().updateActionBar();
		}
	}

	/**
	 * Checks whether an element is editable or not.
	 *
	 * @param element The list entry to be checked
	 * @return True if the element can be edited, false otherwise
	 *
	 * @since 1.11
	 */
	protected boolean canEditObject(Object element) {
		return true;
	}

	/**
	 * Defined whether a cell editor should be created or not.
	 *
	 * @param element The table entry to be checked
	 * @return True if a CellEditor should be created, false otherwise
	 * @since 1.12
	 */
	protected boolean shouldCreateCellEditor(Object element) {
		final boolean isObjectEditable = canEditObject(element);
		if (!isObjectEditable) {
			return false;
		}
		final boolean editable = getVElement().isEffectivelyEnabled()
			&& !getVElement().isEffectivelyReadonly();
		return editable;
	}

	private boolean isDisabled(EObject eObject, VDomainModelReference columnDmr) {

		final Optional<VEnablementConfiguration> enablmentConf = TableConfigurationHelper
			.findEnablementConfiguration(getVElement(), columnDmr);

		if (enablmentConf.isPresent()) {
			return !enablmentConf.get().isEnabled();
		}

		return false;
	}

	/**
	 * Called by the {@link TableControlEditingSupportAndLabelProvider}.
	 *
	 * @param feature the feature of the column
	 * @param cellEditor the cell editor for the column
	 * @param attributeMap the attribute map displayed in the table
	 * @param vTableControl the table view model element
	 * @param dmr the domain model reference of the column
	 * @param table the table control
	 * @return the {@link CellLabelProvider} of the column
	 * @since 1.12
	 */
	protected CellLabelProvider createCellLabelProvider(
		EStructuralFeature feature,
		CellEditor cellEditor,
		@SuppressWarnings("rawtypes") IObservableMap attributeMap,
		VTableControl vTableControl,
		VDomainModelReference dmr,
		Control table) {
		return new ECPCellLabelProvider(
			feature,
			cellEditor,
			attributeMap,
			getVElement(),
			dmr,
			table);
	}

	/**
	 * @return The {@link FeatureAwareComparator} used to compare {@link Enumerator enum values} when sorting the table
	 * @since 1.22
	 */
	protected FeatureAwareComparator<Enumerator> getEnumeratorComparator() {
		if (enumeratorComparator == null) {
			enumeratorComparator = new LocalizedEnumeratorComparator(localizationService, bundleResolver,
				getReportService());
		}
		return enumeratorComparator;
	}

	/**
	 * Reeveal the given {@code object} in my table.
	 *
	 * @param object an object to reveal
	 * @return whether I succeeded in revealing it
	 *
	 * @since 1.22
	 */
	public boolean reveal(Object object) {
		final AbstractTableViewer viewer = getTableViewer();
		final IObservableList<?> list = (IObservableList<?>) viewer.getInput();
		final boolean result = list.contains(object);

		if (result) {
			final IStructuredSelection selection = new StructuredSelection(object);
			if (!selection.equals(viewer.getSelection())) {
				viewer.setSelection(selection, true);
			}
		} else {
			viewer.reveal(object);
		}

		return result;
	}

	/**
	 * The {@link DNDProvider} for this renderer.
	 *
	 * @author Johannes Faltermeier
	 *
	 */
	private final class TableControlSWTRendererDragAndDrop implements DNDProvider {

		/**
		 * The drop adapter.
		 */
		private final class TableControlDropAdapter extends EditingDomainViewerDropAdapter {

			private EObject eObject;
			private EStructuralFeature eStructuralFeature;
			private List<Object> list;

			@SuppressWarnings("unchecked")
			TableControlDropAdapter(EditingDomain domain, Viewer viewer, AbstractTableViewer tableViewer) {
				super(domain, viewer);
				try {
					final Setting setting = getEMFFormsDatabinding().getSetting(getDMRToMultiReference(),
						getViewModelContext().getDomainModel());
					eObject = setting.getEObject();
					eStructuralFeature = setting.getEStructuralFeature();
					list = (List<Object>) setting.get(true);
				} catch (final DatabindingFailedException ex) {
					getReportService().report(new AbstractReport(ex));
				}
			}

			@Override
			protected void helper(DropTargetEvent event) {
				final Object target = extractDropTarget(event.item);
				final Collection<?> dragSource = getDragSource(event);

				if (dragSource == null) {
					/* possible on non-win32 platforms */
					/* in this case we will just wait until the data is available without setting a detail */
					return;
				}

				if (target == null || dragSource.contains(target)) {
					event.detail = DND.DROP_NONE;
					return;
				}

				event.detail = DND.DROP_MOVE;
			}

			@Override
			public void drop(DropTargetEvent event) {

				final Collection<?> dragSource = getDragSource(event);
				final Object target = extractDropTarget(event.item);
				final float location = getLocation(event);

				final List<Command> commands = new ArrayList<Command>();
				final boolean insertAfter = location >= 0.5;

				for (final Object toMove : dragSource) {
					final int indexTarget = list.indexOf(target);
					final int indexToMove = list.indexOf(toMove);

					if (indexTarget == -1 || indexToMove == -1) {
						return;
					}

					final boolean moveIsLocatedBeforeTarget = indexToMove < indexTarget;

					int index;
					if (insertAfter) {
						if (moveIsLocatedBeforeTarget) {
							index = indexTarget;
						} else {
							index = indexTarget + 1;
						}
					} else {
						/* insert Before Target */
						if (moveIsLocatedBeforeTarget) {
							index = indexTarget - 1;
						} else {
							index = indexTarget;
						}
					}

					commands.add(MoveCommand.create(domain, eObject, eStructuralFeature, toMove, index));
				}

				final Command command = new CompoundCommand(commands);

				if (!command.canExecute()) {
					return;
				}
				domain.getCommandStack().execute(command);

				postRefresh();
			}
		}

		@Override
		public int getDragOperations() {
			return getDNDOperations();
		}

		@Override
		public Transfer[] getDragTransferTypes() {
			return getDNDTransferTypes();
		}

		@Override
		public DragSourceListener getDragListener(AbstractTableViewer tableViewer) {
			return new ViewerDragAdapter(tableViewer);
		}

		@Override
		public int getDropOperations() {
			return getDNDOperations();
		}

		@Override
		public Transfer[] getDropTransferTypes() {
			return getDNDTransferTypes();
		}

		@Override
		public DropTargetListener getDropListener(final AbstractTableViewer tableViewer) {
			return new TableControlDropAdapter(getEditingDomain(getViewModelContext().getDomainModel()), tableViewer,
				tableViewer);
		}

		private int getDNDOperations() {
			return DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
		}

		private Transfer[] getDNDTransferTypes() {
			return new Transfer[] { LocalTransfer.getInstance() };
		}

		@Override
		public boolean hasDND() {
			return true;
		}
	}

	/**
	 * Double click listener.
	 *
	 */
	private final class DoubleClickListener implements IDoubleClickListener {
		@Override
		public void doubleClick(DoubleClickEvent event) {
			if (!getViewModelContext().hasService(TableControlService.class)) {
				return;
			}
			final ISelection selection = event.getSelection();
			if (!StructuredSelection.class.isInstance(selection)) {
				return;
			}
			final TableControlService tableService = getViewModelContext()
				.getService(TableControlService.class);
			tableService.doubleClick(getVElement(),
				(EObject) StructuredSelection.class.cast(selection).getFirstElement());
		}
	}

	/**
	 * The Listener which is set on the table viewer to inform the renderer about selection changes.
	 *
	 */
	private final class ViewerSelectionChangedListener implements ISelectionChangedListener {
		@Override
		public void selectionChanged(SelectionChangedEvent event) {
			viewerSelectionChanged(event);
		}
	}

	/**
	 * A two-stage asynchronous task that first, in the background, computes the objects
	 * that have actually seen validation changes and then post the viewer update
	 * on the UI thread.
	 */
	private final class ComputeValidationUpdate implements Runnable, RunnableManager.BackgroundStage {
		private final Set<Diagnostic> oldDiagnostics;
		private final Set<Diagnostic> newDiagnostics;

		private Runnable update;

		/**
		 * Initializes me with the old and new diagnostics from which to compute the objects
		 * that need to be updated in my viewer.
		 *
		 * @param oldDiagnostic the old validation state
		 * @param newDiagnostic the new validation state
		 */
		ComputeValidationUpdate(VDiagnostic oldDiagnostic, VDiagnostic newDiagnostic) {
			super();

			// These have to be extracted on the calling thread because the ELists
			// are not thread-safe
			oldDiagnostics = getDiagnostics(oldDiagnostic);
			newDiagnostics = getDiagnostics(newDiagnostic);
		}

		@Override
		public Runnable getNextStage() {
			return update;
		}

		@Override
		public void run() {
			// Compute the difference between the diagnostics to find what actually
			// are the logical changes in validation that will need updates in the UI
			final Set<Diagnostic> difference = difference(oldDiagnostics, newDiagnostics);
			final Set<Object> updates = difference.stream().map(this::getSubject).filter(Objects::nonNull)
				.collect(Collectors.toSet());
			if (!updates.isEmpty()) {
				update = new ApplyValidationRunnable(updates);
			} // Otherwise we don't need the UI update stage
		}

		private Set<Diagnostic> getDiagnostics(VDiagnostic container) {
			return container == null ? Collections.emptySet()
				: container.getDiagnostics().stream()
					.filter(Diagnostic.class::isInstance).map(Diagnostic.class::cast)
					.collect(Collectors.toSet());
		}

		private Object getSubject(Diagnostic diagnostic) {
			final List<?> data = diagnostic.getData();
			return data.isEmpty() ? null : data.get(0);
		}

		private Set<Diagnostic> difference(Set<Diagnostic> set1, Set<Diagnostic> set2) {
			// Diagnostics do not implement equals(), so we have to do it for them.
			// Most straightforward approach is to use a tree set, which uses the
			// comparator's zero result to test equality
			final SortedSet<Diagnostic> sorted1 = new TreeSet<>(this::compare);
			sorted1.addAll(set1);
			final SortedSet<Diagnostic> sorted2 = new TreeSet<>(this::compare);
			sorted2.addAll(set2);

			// Difference each side
			sorted1.removeAll(set2);
			sorted2.removeAll(set1);

			// And the union of that
			sorted1.addAll(sorted2);

			return sorted1;
		}

		private int compare(Diagnostic d1, Diagnostic d2) {
			int result = d1.getSeverity() - d2.getSeverity();
			if (result != 0) {
				return result;
			}

			result = d1.getCode() - d2.getCode();
			if (result != 0) {
				return result;
			}

			result = compare(d1.getSource(), d2.getSource());
			if (result != 0) {
				return result;
			}

			result = compare(d1.getMessage(), d2.getMessage());
			if (result != 0) {
				return result;
			}

			result = compare(d1.getData(), d2.getData());

			// The diagnostics from validation should not have exceptions and
			// the children are immaterial because we've already flattened them

			return result;
		}

		private int compare(String s1, String s2) {
			if (s1 == null) {
				return s2 == null ? 0 : -1;
			}
			if (s2 == null) {
				return +1;
			}
			return s1.compareTo(s2);
		}

		private int compare(List<?> s1, List<?> s2) {
			if (s1 == null) {
				return s2 == null ? 0 : -1;
			}
			if (s2 == null) {
				return +1;
			}

			final int size = s1.size();
			int result = size - s2.size();
			if (result != 0) {
				return result;
			}

			int i = 0;
			for (i = 0; i < size; i++) {
				final Object e1 = s1.get(i);
				final Object e2 = s2.get(i);
				if (e1 != e2) {
					// Arbitrary but stable order
					result = System.identityHashCode(e1) - System.identityHashCode(e2);
					break;
				}
			}

			return result;
		}
	}

	/**
	 * Runnable which is called by {@link TableControlSWTRenderer#applyValidation() applyValidation}.
	 *
	 */
	private final class ApplyValidationRunnable implements Runnable {
		private Collection<?> updates;

		ApplyValidationRunnable() {
			super();
		}

		ApplyValidationRunnable(Collection<?> updates) {
			super();

			this.updates = updates;
		}

		@Override
		public void run() {
			if (isDisposing) {
				return;
			}
			// triggered due to another validation rule before this control is rendered
			// validation rule triggered after the control was disposed
			if (validationIcon == null || validationIcon.isDisposed()) {
				return;
			}

			// no diagnostic set
			if (getVElement().getDiagnostic() == null) {
				return;
			}

			final VDomainModelReference dmr = getDMRToMultiReference();
			final Optional<Setting> setting = getSettingFromObservable(dmr, getViewModelContext().getDomainModel());

			if (!setting.isPresent()) {
				return;
			}

			validationIcon.setImage(getValidationIcon());
			showValidationSummaryTooltip(setting.get(), showValidationSummaryTooltip);

			if (updates != null) {
				// Update these specific objects
				getTableViewer().update(updates.toArray(), null);
			} else {
				// Just refresh everything. We are already in the RunnableManager
				// context, so don't post but do it directly
				getTableViewer().refresh();
			}
		}

		// extracted in order to avoid checkstyle complexity warning
		private void showValidationSummaryTooltip(Setting tableSetting, boolean doShow) {
			if (doShow) {
				validationIcon.setToolTipText(ECPTooltipModifierHelper.modifyString(getVElement().getDiagnostic()
					.getMessage(), null));
				return;
			}

			// Even if the display of a validation summary tooltip is disabled, we still show validation errors directly
			// related to the table feature (e.g. multiplicity errors)
			final StringBuilder builder = new StringBuilder();
			final List<Diagnostic> tableDiagnostics = getVElement().getDiagnostic()
				.getDiagnostic(tableSetting.getEObject(), tableSetting.getEStructuralFeature());
			for (final Diagnostic diagnostic : tableDiagnostics) {
				builder.append(diagnostic.getMessage());
				builder.append("\n"); //$NON-NLS-1$
			}
			final String toolTipText = ECPTooltipModifierHelper.modifyString(builder.toString().trim(), null);
			validationIcon.setToolTipText(toolTipText);
		}
	}

	/**
	 * Implements {@link EditingSupportCreator} and {@link CellLabelProviderFactory} for the table control swt renderer.
	 *
	 * This allows us to access the actual cell editor from the cell label provider.
	 *
	 * @author Johannes Faltermeier
	 *
	 */
	protected final class TableControlEditingSupportAndLabelProvider
		implements EditingSupportCreator, CellLabelProviderFactory {
		private final InternalEObject tempInstance;
		private final EStructuralFeature eStructuralFeature;
		private final VDomainModelReference dmr;
		private final IValueProperty<?, ?> valueProperty;
		private final IObservableMap<?, ?> observableMap;

		private CellEditor cellEditor;
		private ECPTableEditingSupport observableSupport;

		private boolean initialized;
		private final int indexOfColumn;

		private TableControlEditingSupportAndLabelProvider(InternalEObject tempInstance,
			EStructuralFeature eStructuralFeature, VDomainModelReference dmr,
			IValueProperty<?, ?> valueProperty, IObservableMap<?, ?> observableMap, int indexOfColumn) {
			this.tempInstance = tempInstance;
			this.eStructuralFeature = eStructuralFeature;
			this.dmr = dmr;
			this.valueProperty = valueProperty;
			this.observableMap = observableMap;
			this.indexOfColumn = indexOfColumn;
		}

		@Override
		public EditingSupport createEditingSupport(AbstractTableViewer tableViewer) {
			if (!initialized) {
				init(tableViewer);
			}
			return observableSupport;
		}

		private void init(AbstractTableViewer tableViewer) {
			cellEditor = createCellEditor(tempInstance, eStructuralFeature,
				(Composite) tableViewer.getControl());
			if (cellEditor instanceof ECPViewerAwareCellEditor) {
				((ECPViewerAwareCellEditor) cellEditor).setTableViewer(tableViewer);
				((ECPViewerAwareCellEditor) cellEditor).setTableFeature((EReference) list.getElementType());
			}
			tableViewer.getControl().addDisposeListener(new DisposeListener() {

				@Override
				public void widgetDisposed(DisposeEvent arg0) {
					cellEditor.dispose();
				}
			});
			if (ECPCellEditorComparator.class.isInstance(cellEditor)) {
				columnIndexToComparatorMap.put(indexOfColumn, ECPCellEditorComparator.class.cast(cellEditor));
			}
			observableSupport = new ECPTableEditingSupport(tableViewer, cellEditor, dmr, valueProperty);
			initialized = true;
		}

		@Override
		public CellLabelProvider createCellLabelProvider(AbstractTableViewer table) {
			if (!initialized) {
				init(table);
			}
			return TableControlSWTRenderer.this.createCellLabelProvider(eStructuralFeature, cellEditor, observableMap,
				getVElement(), dmr, table.getControl());
		}
	}

	/**
	 * {@link TableViewerCreator} for the table control swt renderer. It will create a GridTableViewer with the expected
	 * custom variant data and the correct style properties as defined in the template model.
	 *
	 * @since 1.10
	 *
	 */
	protected class TableControlSWTRendererTableViewerCreator implements TableViewerCreator<TableViewer> {

		@Override
		public TableViewer createTableViewer(Composite parent) {
			final TableViewer tableViewer = new TableViewer(parent,
				SWT.MULTI | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
			tableViewer.getTable().setData(CUSTOM_VARIANT, TABLE_CUSTOM_VARIANT);
			tableViewer.getTable().setHeaderVisible(true);
			tableViewer.getTable().setLinesVisible(true);

			/* Set background color */
			final VTBackgroundStyleProperty backgroundStyleProperty = getBackgroundStyleProperty();
			if (backgroundStyleProperty.getColor() != null) {
				tableViewer.getTable().setBackground(getSWTColor(backgroundStyleProperty.getColor()));
			}

			/* Set foreground color */
			final VTFontPropertiesStyleProperty fontPropertiesStyleProperty = getFontPropertiesStyleProperty();
			if (fontPropertiesStyleProperty.getColorHEX() != null) {
				tableViewer.getTable()
					.setForeground(getSWTColor(fontPropertiesStyleProperty.getColorHEX()));
			}

			tableViewer.getTable().setData(FIXED_COLUMNS, new Integer(1));

			/* manage editing support activation */
			createTableViewerEditor(tableViewer);
			return tableViewer;
		}

		/**
		 * This method creates and initialises a {@link TableViewerEditor} for the given {@link TableViewer}.
		 *
		 * @param tableViewer the table viewer
		 */
		protected void createTableViewerEditor(final TableViewer tableViewer) {
			final TableViewerFocusCellManager focusCellManager = new TableViewerFocusCellManager(tableViewer,
				new org.eclipse.emf.ecp.edit.internal.swt.controls.ECPFocusCellDrawHighlighter(tableViewer));
			final ColumnViewerEditorActivationStrategy actSupport = new ColumnViewerEditorActivationStrategy(
				tableViewer) {
				@Override
				protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
					return event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL
						|| event.eventType == ColumnViewerEditorActivationEvent.MOUSE_CLICK_SELECTION
						|| event.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR
						|| event.eventType == ColumnViewerEditorActivationEvent.PROGRAMMATIC;
				}
			};
			TableViewerEditor.create(
				tableViewer,
				focusCellManager,
				actSupport,
				ColumnViewerEditor.TABBING_HORIZONTAL | ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR
					| ColumnViewerEditor.TABBING_VERTICAL | ColumnViewerEditor.KEYBOARD_ACTIVATION);
		}
	}

	/**
	 * {@link org.eclipse.emfforms.spi.swt.table.TableViewerCompositeBuilder TableViewerCompositeBuilder} which calls
	 * the existing template method to create the validation label.
	 *
	 * @since 1.13
	 *
	 */
	protected class TableControlSWTRendererCompositeBuilder
		extends org.eclipse.emfforms.spi.swt.table.DefaultTableViewerCompositeBuilder {
		@Override
		protected Label createValidationLabel(Composite topComposite) {
			final Label validationLabel = createValidationIcon(topComposite);
			GridDataFactory.fillDefaults().hint(16, 17).grab(false, false).applyTo(validationLabel);
			return validationLabel;
		}

		@Override
		protected Composite createViewerComposite(Composite composite) {
			return createControlComposite(composite);
		}
	}

	/**
	 * {@link org.eclipse.emfforms.spi.swt.table.TableViewerCompositeBuilder TableViewerCompositeBuilder} which calls
	 * the existing template method to create the validation label.
	 *
	 * @since 1.14
	 *
	 */
	protected class CompactVerticallyTableControlSWTRendererCompositeBuilder
		extends org.eclipse.emfforms.spi.swt.table.CompactVerticallyTableViewerCompositeBuilder {
		/**
		 * Constructor.
		 *
		 * @param createTitleLabel indicates whether to create a title label.
		 * @param createValidationLabel indicates whether to create a validation label.
		 */
		public CompactVerticallyTableControlSWTRendererCompositeBuilder(
			boolean createTitleLabel, boolean createValidationLabel) {
			super(createTitleLabel, createValidationLabel);
		}

		@Override
		protected Label createValidationLabel(Composite composite) {
			final Label validationLabel = createValidationIcon(composite);
			GridDataFactory.fillDefaults().hint(16, 17).grab(false, false).applyTo(validationLabel);
			return validationLabel;
		}

		@Override
		protected Composite createViewerComposite(Composite composite) {
			return createControlComposite(composite);
		}
	}

	/**
	 * This class combines the {@link ViewerComparator} with the {@link TableViewerComparator}.
	 * This is needed to allow customizations.
	 *
	 * @author Eugen Neufeld
	 * @since 1.22
	 */
	protected abstract class TableControlComparator extends ViewerComparator implements TableViewerComparator {
	}

	/**
	 * The {@link ViewerComparator} for this table which allows 3 states for sort order:
	 * none, up and down.
	 *
	 * @author Eugen Neufeld
	 * @since 1.10
	 *
	 */
	protected class ECPTableViewerComparator extends TableControlComparator {
		private int propertyIndex;
		private static final int NONE = 0;
		private int direction = NONE;

		/** Constructs a new instance. */
		ECPTableViewerComparator() {
			propertyIndex = 0;
			direction = NONE;
		}

		@Override
		public int getDirection() {
			switch (direction) {
			case 0:
				return SWT.NONE;
			case 1:
				return SWT.DOWN; // ascending
			case 2:
				return SWT.UP; // descending
			default:
				return SWT.NONE;
			}

		}

		@Override
		public void setColumn(int column) {
			if (column == propertyIndex) {
				// Same column as last sort; toggle the direction
				direction = (direction + 1) % 3;
			} else {
				// New column; do an ascending sort
				propertyIndex = column;
				direction = 1;
			}
			// No sorting is the same as no column being selected for sorting
			if (direction == NONE) {
				setSortColumnFeature(null);
			} else {
				// columnFeatures starts at index 0 with the first regular column
				setSortColumnFeature(getColumnFeature(propertyIndex));
			}
		}

		@Override
		public int compare(Viewer viewer, Object e1, Object e2) {
			return TableControlSWTRenderer.this.compare(viewer, e1, e2, direction, propertyIndex);
		}
	}

	/**
	 * Domain model change listener that re-sorts the table and reveals the added resp. changed object.
	 *
	 * @since 1.20
	 */
	protected class AutoSortModelChangeListener implements ModelChangeListener {

		@Override
		public void notifyChange(ModelChangeNotification notification) {
			final int event = notification.getRawNotification().getEventType();
			if (notification.getStructuralFeature() == tableEReference
				&& getSortColumnFeature().isPresent()
				&& (event == Notification.ADD || event == Notification.ADD_MANY)) {
				sortAndReveal(notification.getNewEObjects());
			} else if (getSortColumnFeature().isPresent()
				&& notification.getStructuralFeature() == getSortColumnFeature().get()) {
				sortAndReveal(notification.getNotifier());
			}
		}

		private void sortAndReveal(Object toReveal) {
			final AbstractTableViewer viewer = getTableViewer();
			postRefresh(() -> {
				viewer.refresh();
				viewer.reveal(toReveal);
			});
		}
	}

	/**
	 * ECP specific cell label provider that does also implement {@link IColorProvider} in
	 * order to correctly.
	 *
	 * @author emueller
	 *
	 */
	public class ECPCellLabelProvider extends ObservableMapCellLabelProvider implements IColorProvider, IAdaptable {

		private final EStructuralFeature feature;
		private final CellEditor cellEditor;
		private final VTableControl vTableControl;
		private final VDomainModelReference dmr;
		private final Control table;

		/**
		 * Constructor.
		 *
		 * @param feature
		 *            the {@link EStructuralFeature} the cell is bound to
		 * @param cellEditor
		 *            the {@link CellEditor} instance
		 * @param attributeMap
		 *            an {@link IObservableMap} instance that is passed to the {@link ObservableMapCellLabelProvider}
		 * @param vTableControl the {@link VTableControl}
		 * @param dmr the {@link VDomainModelReference} for this cell
		 * @param table the swt table
		 * @since 1.10
		 */
		public ECPCellLabelProvider(EStructuralFeature feature, CellEditor cellEditor,
			@SuppressWarnings("rawtypes") IObservableMap attributeMap,
			VTableControl vTableControl, VDomainModelReference dmr, Control table) {
			super(attributeMap);
			this.vTableControl = vTableControl;
			this.feature = feature;
			this.cellEditor = cellEditor;
			this.dmr = dmr;
			this.table = table;
		}

		@Override
		public String getToolTipText(Object element) {
			final EObject domainObject = (EObject) element;

			final Optional<Setting> setting = getSettingFromObservable(dmr, domainObject);
			if (!setting.isPresent()) {
				return null;
			}

			final VDiagnostic vDiagnostic = vTableControl.getDiagnostic();
			if (vDiagnostic != null) {
				final String message = DiagnosticMessageExtractor.getMessage(vDiagnostic.getDiagnostic(domainObject,
					feature));
				if (message != null && !message.isEmpty()) {
					return ECPTooltipModifierHelper.modifyString(message, setting.get());
				}
			}
			final Object value = setting.get().get(true);
			if (value == null) {
				return null;
			}
			final String tooltip = ECPTooltipModifierHelper.modifyString(String.valueOf(value), setting.get());
			if (tooltip == null || tooltip.isEmpty()) {
				return null;
			}
			return tooltip;

		}

		@Override
		public void update(ViewerCell cell) {
			final EObject element = (EObject) cell.getElement();
			final Object value = getValue(element);
			if (ECPCustomUpdateCellEditor.class.isInstance(cellEditor)) {
				((ECPCustomUpdateCellEditor) cellEditor).updateCell(cell, value);
			} else {
				String text;
				Image image = null;

				if (ECPCellEditor.class.isInstance(cellEditor)) {
					final ECPCellEditor ecpCellEditor = (ECPCellEditor) cellEditor;
					text = Objects.toString(ecpCellEditor.getFormatedString(value), ""); //$NON-NLS-1$
					image = ecpCellEditor.getImage(value);
				} else {
					text = Objects.toString(value, ""); //$NON-NLS-1$
					cell.getControl().setData(CUSTOM_VARIANT, "org_eclipse_emf_ecp_edit_cellEditor_string"); //$NON-NLS-1$
				}

				if (!Objects.equals(text, cell.getText())) {
					cell.setText(text);
				}

				// Don't try to compare images
				if (image != null || cell.getImage() != null) {
					cell.setImage(image);
				}
			}

			final Color foreground = getForeground(element);
			if (!Objects.equals(cell.getForeground(), foreground)) {
				cell.setForeground(foreground);
			}
			final Color background = getBackground(element);
			if (!Objects.equals(cell.getBackground(), background)) {
				cell.setBackground(background);
			}
		}

		/**
		 * Get the value for an {@code object} from my observable map.
		 *
		 * @param object an object to look up the value for
		 * @return its value
		 */
		Object getValue(Object object) {
			return attributeMaps[0].get(object);
		}

		@Override
		public Color getForeground(Object element) {
			return table.getForeground();
		}

		@Override
		public Color getBackground(Object element) {
			final VDiagnostic vDiagnostic = vTableControl.getDiagnostic();
			final SWTValidationUiService validationUiService = getViewModelContext()
				.getService(SWTValidationUiService.class);
			if (vDiagnostic == null) {
				return validationUiService.getValidationBackgroundColor(Diagnostic.OK_INSTANCE, vTableControl,
					getViewModelContext());
			}
			final List<Diagnostic> diagnostic = vDiagnostic.getDiagnostic((EObject) element, feature);
			final Diagnostic iconDiagnostic = diagnostic.size() == 0 ? Diagnostic.OK_INSTANCE : diagnostic.get(0);
			return validationUiService.getValidationBackgroundColor(iconDiagnostic, vTableControl,
				getViewModelContext());
		}

		/**
		 * @return the cellEditor
		 */
		protected CellEditor getCellEditor() {
			return cellEditor;
		}

		/**
		 * @return the feature
		 */
		protected EStructuralFeature getFeature() {
			return feature;
		}

		/**
		 * @return the dmr
		 */
		protected VDomainModelReference getDmr() {
			return dmr;
		}

		@Override
		public <T> T getAdapter(Class<T> adapter) {
			T result = null;

			// For custom cell update, we must ask the cell editor to render a string for filtering
			if (adapter == ECPFilterableCell.class && !(cellEditor instanceof ECPCustomUpdateCellEditor)) {
				ECPFilterableCell filterable = null;

				if (cellEditor instanceof ECPCellEditor) {
					final ECPCellEditor ecpCellEditor = (ECPCellEditor) cellEditor;
					filterable = object -> ecpCellEditor.getFormatedString(getValue(object));
				} else {
					filterable = object -> Objects.toString(object, ""); //$NON-NLS-1$
				}

				result = adapter.cast(filterable);
			} else {
				result = Platform.getAdapterManager().getAdapter(this, adapter);
			}

			return result;
		}

	}

	/**
	 * Implementation of the {@link EditingSupport} for the generic ECP Table.
	 *
	 * @author Eugen Neufeld
	 *
	 */
	class ECPTableEditingSupport extends EditingSupport {

		private final CellEditor cellEditor;

		@SuppressWarnings("rawtypes")
		private final IValueProperty valueProperty;

		private final VDomainModelReference domainModelReference;

		/**
		 * Initializes me.
		 *
		 * @param viewer the viewer to edit
		 * @param cellEditor the cell editor used to edit the {@code viewer}
		 * @param domainModelReference the model reference that populates the {@code viewer}
		 * @param valueProperty the value property that supplies the {@code viewer}
		 */
		ECPTableEditingSupport(ColumnViewer viewer, CellEditor cellEditor, VDomainModelReference domainModelReference,
			IValueProperty<?, ?> valueProperty) {
			super(viewer);
			this.cellEditor = cellEditor;
			this.valueProperty = valueProperty;
			this.domainModelReference = domainModelReference;
		}

		private EditingState editingState;

		private final ColumnViewerEditorActivationListenerHelper activationListener = new ColumnViewerEditorActivationListenerHelper();

		/**
		 * Default implementation always returns <code>true</code>.
		 *
		 * @see org.eclipse.jface.viewers.EditingSupport#canEdit(java.lang.Object)
		 */
		@Override
		protected boolean canEdit(Object element) {
			if (!shouldCreateCellEditor(element)) {
				return false;
			}

			// TODO: use getSettingFromObservable(dmr, eObject) instead?
			@SuppressWarnings("unchecked")
			final IObservableValue<?> observableValue = valueProperty.observe(element);
			final EObject eObject = (EObject) ((IObserving) observableValue).getObserved();

			final EStructuralFeature structuralFeature = (EStructuralFeature) observableValue.getValueType();

			// Given EClass has no such feature
			if (eObject == null || eObject.eClass().getFeatureID(structuralFeature) == -1) {
				return false;
			}

			final Setting setting = ((InternalEObject) eObject).eSetting(structuralFeature);

			if (isDisabled(eObject, domainModelReference)
				|| CellReadOnlyTesterHelper.getInstance().isReadOnly(getVElement(), setting)) {
				return false;
			}

			final boolean editable = emfFormsEditSupport.canSetProperty(domainModelReference, (EObject) element);

			if (ECPCellEditor.class.isInstance(cellEditor)) {
				ECPCellEditor.class.cast(cellEditor).setEditable(editable);
				return true;
			}
			return editable;
		}

		/**
		 * Default implementation always returns <code>null</code> as this will be
		 * handled by the Binding.
		 *
		 * @see org.eclipse.jface.viewers.EditingSupport#getValue(java.lang.Object)
		 */
		@Override
		protected Object getValue(Object element) {
			// no op
			return null;
		}

		/**
		 * Default implementation does nothing as this will be handled by the
		 * Binding.
		 *
		 * @see org.eclipse.jface.viewers.EditingSupport#setValue(java.lang.Object, java.lang.Object)
		 */
		@Override
		protected void setValue(Object element, Object value) {
			// no op
		}

		/**
		 * Creates a {@link Binding} between the editor and the element to be
		 * edited. Invokes {@link #doCreateCellEditorObservable(CellEditor)},
		 * {@link #doCreateElementObservable(Object, ViewerCell)}, and then
		 * {@link #createBinding(IObservableValue, IObservableValue)}.
		 */
		@Override
		protected void initializeCellEditorValue(CellEditor cellEditor, ViewerCell cell) {

			if (ECPElementAwareCellEditor.class.isInstance(cellEditor)) {
				ECPElementAwareCellEditor.class.cast(cellEditor).updateRowElement(cell.getElement());
			}

			final IObservableValue<?> target = doCreateCellEditorObservable(cellEditor);
			Assert.isNotNull(target, "doCreateCellEditorObservable(...) did not return an observable"); //$NON-NLS-1$

			@SuppressWarnings("unchecked")
			final IObservableValue<?> model = valueProperty.observe(cell.getElement());
			Assert.isNotNull(model, "The databinding service did not return an observable"); //$NON-NLS-1$

			final Binding binding = createBinding(target, model);

			Assert.isNotNull(binding, "createBinding(...) did not return a binding"); //$NON-NLS-1$

			editingState = new EditingState(binding, target, model);

			getViewer().getColumnViewerEditor().addEditorActivationListener(activationListener);
		}

		@Override
		protected CellEditor getCellEditor(Object element) {
			return cellEditor;
		}

		/**
		 * Bind a {@code model} value to a {@code target} value.
		 *
		 * @param target the binding target
		 * @param model the binding source
		 * @return the binding
		 */
		@SuppressWarnings({ "rawtypes", "unchecked" })
		protected Binding createBinding(IObservableValue target, IObservableValue model) {
			if (ECPCellEditor.class.isInstance(cellEditor)) {
				return getDataBindingContext().bindValue(target, model,
					((ECPCellEditor) cellEditor).getTargetToModelStrategy(getDataBindingContext()),
					((ECPCellEditor) cellEditor).getModelToTargetStrategy(getDataBindingContext()));
			}
			return getDataBindingContext().bindValue(target, model);
		}

		/**
		 * Create an observable value to supply the cells edited by a cell editor.
		 *
		 * @param cellEditor a cell editor
		 * @return the observable value to supply it with data to edit
		 */
		@SuppressWarnings({ "rawtypes", "unchecked" })
		protected IObservableValue doCreateCellEditorObservable(CellEditor cellEditor) {
			if (ECPCellEditor.class.isInstance(cellEditor)) {
				return ((ECPCellEditor) cellEditor).getValueProperty().observe(cellEditor);
			}
			return WidgetProperties.text(SWT.FocusOut).observe(cellEditor.getControl());
		}

		@Override
		protected final void saveCellEditorValue(CellEditor cellEditor, ViewerCell cell) {
			if (editingState.isUpdateNeeded()) {
				editingState.binding.updateTargetToModel();
			}
		}

		/**
		 * A ColumnViewerEditorActivationListener to reset the cells after focus lost.
		 *
		 * @author Eugen Neufeld
		 *
		 */
		private class ColumnViewerEditorActivationListenerHelper extends ColumnViewerEditorActivationListener {

			@Override
			public void afterEditorActivated(ColumnViewerEditorActivationEvent event) {
				// set colors for cell editor
				final Control control = cellEditor.getControl();
				if (control == null || control.isDisposed()) {
					return;
				}
				control.setBackground(getViewer().getControl().getBackground());
				control.setForeground(getViewer().getControl().getForeground());
			}

			@Override
			public void afterEditorDeactivated(ColumnViewerEditorDeactivationEvent event) {
				editingState.dispose();
				editingState = null;

				getViewer().getColumnViewerEditor().removeEditorActivationListener(this);
				final ViewerCell focusCell = getViewer().getColumnViewerEditor().getFocusCell();
				if (focusCell != null) {
					getViewer().update(focusCell.getElement(), null);
				}
			}

			@Override
			public void beforeEditorActivated(ColumnViewerEditorActivationEvent event) {
				// do nothing
			}

			@Override
			public void beforeEditorDeactivated(ColumnViewerEditorDeactivationEvent event) {
				// do nothing
			}
		}

		/**
		 * Maintains references to objects that only live for the length of the edit
		 * cycle.
		 */
		class EditingState {

			private final IObservableValue<?> target;
			private final IObservableValue<?> model;
			private final Binding binding;

			/**
			 * Initializes me with the data binding details involved in editing.
			 *
			 * @param binding the data binding
			 * @param target the bound target value
			 * @param model the bound model value
			 */
			EditingState(Binding binding, IObservableValue<?> target, IObservableValue<?> model) {
				this.binding = binding;
				this.target = target;
				this.model = model;
			}

			/**
			 * Dispose the data binding that I maintain.
			 */
			void dispose() {
				binding.dispose();
				target.dispose();
				model.dispose();
			}

			/**
			 * Checks if an update is really needed.
			 *
			 * @return <code>true</code> if update is really needed, <code>false</code> otherwise.
			 */
			boolean isUpdateNeeded() {
				final Object targetValue = target.getValue();
				final Object modelValue = model.getValue();

				if (targetValue == null) {
					return modelValue != null;
				}
				return !targetValue.equals(modelValue);
			}
		}
	}

	/**
	 * The {@link CellLabelProvider} to update the validation status on the cells.
	 *
	 * @author Eugen Neufeld
	 *
	 */
	private class ValidationStatusCellLabelProvider extends CellLabelProvider {
		private final VTableControl vTableControl;

		ValidationStatusCellLabelProvider(
			VTableControl vTableControl) {
			this.vTableControl = vTableControl;
		}

		@Override
		public void update(ViewerCell cell) {
			final VDiagnostic vDiagnostic = vTableControl.getDiagnostic();
			if (vDiagnostic == null) {
				return;
			}
			final List<Diagnostic> diagnostics = vDiagnostic.getDiagnostics((EObject) cell.getElement());
			Diagnostic cellDiagnostic;
			if (diagnostics.size() != 0) {
				cellDiagnostic = diagnostics.get(0);
			} else {
				// If there is no diagnostic, we assume everything is ok
				cellDiagnostic = Diagnostic.OK_INSTANCE;
			}
			final Image validationIcon = getViewModelContext().getService(SWTValidationUiService.class)
				.getValidationIcon(cellDiagnostic, getVElement(), getViewModelContext());
			cell.setImage(validationIcon);
		}

		@Override
		public String getToolTipText(Object element) {
			final VDiagnostic vDiagnostic = vTableControl.getDiagnostic();
			if (vDiagnostic == null) {
				return null;
			}
			final String message = DiagnosticMessageExtractor.getMessage(vDiagnostic.getDiagnostics((EObject) element));
			return ECPTooltipModifierHelper.modifyString(message, null);
		}
	}

	/**
	 * Localize the message.
	 *
	 * @param eClass The EClass of the table setting.
	 * @param messageKey key of the string
	 * @return tooltip.
	 * @since 1.26
	 */
	protected String formatTooltipText(EClass eClass, String messageKey) {
		final String instanceName = getReferenceDisplayName(eClass);
		return String.format(LocalizationServiceHelper.getString(
			TableControlSWTRenderer.class, messageKey),
			instanceName);
	}

	/**
	 * Returns the current sort column feature.
	 *
	 * @return an {@link java.util.Optional} containing the feature used for sorting
	 * @since 1.22
	 */
	protected java.util.Optional<EStructuralFeature> getSortColumnFeature() {
		return sortColumnFeature;
	}

	/**
	 * Set the column to use for sorting.
	 *
	 * @param sortColumnFeature an optional containing the feature to use for sorting
	 * @since 1.22
	 */
	protected void setSortColumnFeature(EStructuralFeature sortColumnFeature) {
		this.sortColumnFeature = java.util.Optional.ofNullable(sortColumnFeature);
	}

	/**
	 * Find the feature for a specific index.
	 *
	 * @param propertyIndex The index to find the feature for
	 * @return The {@link EStructuralFeature} for the provided index
	 * @since 1.22
	 */
	protected EStructuralFeature getColumnFeature(int propertyIndex) {
		return columnFeatures[propertyIndex - regularColumnsStartIndex];
	}

	/**
	 * Obtains a user-presentable name for the reference that I edit, to be used for example
	 * in button tool-tips.
	 *
	 * @return the reference display name
	 * @since 1.25
	 */
	protected String getReferenceDisplayName(EClassifier type) {
		if (referenceDisplayName == null) {
			if (l10n == null) {
				// Maybe the view-model context has one
				l10n = getViewModelContext().getService(EMFFormsLocalizationService.class);
			}

			if (type != null && l10n != null) {
				try {
					final Bundle editBundle = bundleResolver.getEditBundle(type);
					referenceDisplayName = l10n.getString(editBundle, String.format("_UI_%s_type", type.getName())); //$NON-NLS-1$
				} catch (final NoBundleFoundException ex) {
					referenceDisplayName = type.getName();
				}
			}

			if (referenceDisplayName == null) {
				referenceDisplayName = LocalizationServiceHelper.getString(TableControlSWTRenderer.class,
					MessageKeys.TableControlSWTRenderer_defaultReferenceDisplayName);
			}
		}

		return referenceDisplayName;
	}
}