Content of file MultiAttributeSWTRenderer.java

/*******************************************************************************
 * Copyright (c) 2011-2019 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:
 * David Soto Setzke - initial API and implementation
 * Johannes Faltermeier - initial API and implementation
 * Christian W. Damus - bug 543348
 ******************************************************************************/
package org.eclipse.emfforms.spi.view.control.multiattribute;

import java.lang.reflect.InvocationTargetException;

import javax.inject.Inject;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.databinding.EMFDataBindingContext;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.DynamicEObjectImpl;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor;
import org.eclipse.emf.ecp.view.model.common.edit.provider.CustomReflectiveItemProviderAdapterFactory;
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.model.VControl;
import org.eclipse.emf.ecp.view.spi.model.VDomainModelReference;
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.util.swt.ImageRegistryService;
import org.eclipse.emf.ecp.view.template.model.VTViewTemplateProvider;
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.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.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
import org.eclipse.emfforms.internal.view.control.multiattribute.Messages;
import org.eclipse.emfforms.internal.view.control.multiattribute.celleditor.CellEditorFactory;
import org.eclipse.emfforms.spi.common.report.AbstractReport;
import org.eclipse.emfforms.spi.common.report.ReportService;
import org.eclipse.emfforms.spi.core.services.databinding.DatabindingFailedException;
import org.eclipse.emfforms.spi.core.services.databinding.EMFFormsDatabinding;
import org.eclipse.emfforms.spi.core.services.label.EMFFormsLabelProvider;
import org.eclipse.emfforms.spi.core.services.label.NoLabelFoundException;
import org.eclipse.emfforms.spi.swt.core.SWTDataElementIdHelper;
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.jface.databinding.viewers.ObservableListContentProvider;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.layout.TableColumnLayout;
import org.eclipse.jface.viewers.CellEditor;
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.ColumnViewerToolTipSupport;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TableViewerColumn;
import org.eclipse.jface.viewers.TableViewerEditor;
import org.eclipse.jface.viewers.TableViewerRow;
import org.eclipse.jface.viewers.ViewerCell;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;
import org.osgi.framework.FrameworkUtil;

/**
 * Renderer for MultiReferenceControl.
 *
 * @author David Soto Setzke
 * @author Johannes Faltermeier
 *
 */
public class MultiAttributeSWTRenderer extends AbstractControlSWTRenderer<VControl> {

	private static final String ICON_ADD = "icons/add.png"; //$NON-NLS-1$
	private static final String ICON_DELETE = "icons/delete.png"; //$NON-NLS-1$
	private static final String ICONS_ARROW_DOWN_PNG = "icons/arrow_down.png";//$NON-NLS-1$
	private static final String ICONS_ARROW_UP_PNG = "icons/arrow_up.png";//$NON-NLS-1$

	private final ImageRegistryService imageRegistryService;

	private AdapterFactoryLabelProvider labelProvider;
	private ComposedAdapterFactory composedAdapterFactory;

	private Composite mainComposite;
	private TableViewer tableViewer;
	private Button removeButton;
	private Button addButton;

	private final EMFDataBindingContext viewModelDBC;
	private Label validationIcon;
	private AddButtonSelectionAdapter addButtonSelectionAdapter;
	private RemoveButtonSelectionAdapter removeButtonSelectionAdapter;
	private UpButtonSelectionAdapter upButtonSelectionAdapter;
	private DownButtonSelectionAdapter downButtonSelectionAdapter;
	private ECPListEditingSupport observableSupport;
	private SWTGridDescription rendererGridDescription;
	private Button upButton;
	private Button downButton;

	/**
	 * 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}
	 */
	@Inject
	public MultiAttributeSWTRenderer(VControl vElement, ViewModelContext viewContext, ReportService reportService,
		EMFFormsDatabinding emfFormsDatabinding, EMFFormsLabelProvider emfFormsLabelProvider,
		VTViewTemplateProvider vtViewTemplateProvider, ImageRegistryService imageRegistryService) {
		super(vElement, viewContext, reportService, emfFormsDatabinding, emfFormsLabelProvider, vtViewTemplateProvider);
		this.imageRegistryService = imageRegistryService;
		viewModelDBC = new EMFDataBindingContext();
	}

	/**
	 * Creates the default {@link VTTableStyleProperty}.
	 *
	 * @return the default {@link VTTableStyleProperty}
	 * @since 1.14
	 */
	protected VTTableStyleProperty createDefaultTableStyleProperty() {
		return VTTableStylePropertyFactory.eINSTANCE.createTableStyleProperty();
	}

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

	@Override
	public SWTGridDescription getGridDescription(SWTGridDescription gridDescription) {
		if (rendererGridDescription == null) {
			// create special grid for compact mode
			if (getTableStyleProperty().getRenderMode() == RenderMode.COMPACT_VERTICALLY) {
				rendererGridDescription = GridDescriptionFactory.INSTANCE.createCompactGrid(false, true, this);
			} else {
				rendererGridDescription = GridDescriptionFactory.INSTANCE.createSimpleGrid(1, 1, this);
			}

		}
		return rendererGridDescription;
	}

	/**
	 * Returns the height for the table that will be created.
	 *
	 * @return the height hint
	 */
	protected int getTableHeightHint() {
		return 200;
	}

	/**
	 * Gives access to the tableViewer used to display the attributes.
	 *
	 * @return the viewer
	 */
	protected TableViewer getTableViewer() {
		return tableViewer;
	}

	/**
	 * Creates the composite which will be the parent for the table.
	 *
	 * @param composite
	 *            the parent composite
	 * @return the table composite
	 */
	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 an {@link Image} from the image registry.
	 *
	 * @param path
	 *            the path to the image
	 * @return the image
	 */
	protected Image getImage(String path) {
		return imageRegistryService.getImage(FrameworkUtil.getBundle(MultiAttributeSWTRenderer.class), path);
	}

	private Button createRemoveRowButton(final Composite buttonComposite, IObservableList list) {
		final EAttribute attribute = EAttribute.class.cast(list.getElementType());
		final Button removeButton = new Button(buttonComposite, SWT.None);
		SWTDataElementIdHelper.setElementIdDataWithSubId(removeButton, getVElement(), "remove", getViewModelContext()); //$NON-NLS-1$
		final Image image = getImage(ICON_DELETE);
		removeButton.setImage(image);
		removeButton.setEnabled(!getVElement().isEffectivelyReadonly());
		if (list.size() <= attribute.getLowerBound()) {
			removeButton.setEnabled(false);
		}
		return removeButton;
	}

	private Button createAddRowButton(final Composite buttonComposite, IObservableList list) {
		final EAttribute attribute = EAttribute.class.cast(list.getElementType());
		final Button addButton = new Button(buttonComposite, SWT.None);
		SWTDataElementIdHelper.setElementIdDataWithSubId(addButton, getVElement(), "add", getViewModelContext()); //$NON-NLS-1$
		final Image image = getImage(ICON_ADD);
		addButton.setImage(image);
		if (attribute.getUpperBound() != -1 && list.size() >= attribute.getUpperBound()) {
			addButton.setEnabled(false);
		}
		addButton.setToolTipText(Messages.MultiAttributeSWTRenderer_AddButtonTooltip);
		return addButton;
	}

	@Override
	protected void applyReadOnly() {
		// do not let the super method disable the control, so the table is still enabled for sorting for example
		// when applying read only, all buttons shall be hidden
		updateButtonVisibility();
	}

	@Override
	protected boolean ignoreEnableOnReadOnly() {
		// always take the enable state into account (read only but enable let the user sort the table content for
		// example)
		return false;
	}

	/**
	 * Updates button visibility and enablement.
	 */
	protected void updateButtons() {
		updateButtonVisibility();
		updateButtonEnabling();
	}

	/**
	 * Updates the visibility of 'Add', 'Remove', 'Up', 'Down' buttons according to the bound input.
	 */
	protected void updateButtonVisibility() {
		final boolean isVisible = !getVElement().isEffectivelyReadonly();

		if (addButton != null) {
			addButton.setVisible(isVisible);
		}
		if (removeButton != null) {
			removeButton.setVisible(isVisible);
		}
		if (upButton != null) {
			upButton.setVisible(isVisible);
		}
		if (downButton != null) {
			downButton.setVisible(isVisible);
		}
	}

	/**
	 * Updates the enablement of 'addExisting', 'addNew', 'delete', 'moveUp' and 'moveDown' buttons according to the
	 * bound input.
	 */
	protected void updateButtonEnabling() {
		final boolean isEnable = getVElement().isEffectivelyEnabled();
		final int listSize = tableViewer != null ? tableViewer.getTable().getItemCount() : 0;
		final int selectionIndex = tableViewer != null ? tableViewer.getTable().getSelectionIndex() : -1;

		enableUpButton(isEnable, listSize, selectionIndex);
		enableDownButton(isEnable, listSize, selectionIndex);
		enableAddButton(isEnable, listSize, selectionIndex);
		enableDeleteButton(isEnable, listSize, selectionIndex);
	}

	private void enableUpButton(boolean baseEnable, int listSize, int selectionIndex) {
		if (upButton != null) {
			final boolean enabled = baseEnable && listSize > 1 && selectionIndex > 0;
			upButton.setEnabled(enabled);
		}
	}

	private void enableDownButton(boolean baseEnable, int listSize, int selectionIndex) {
		if (downButton != null) {
			final boolean enabled = baseEnable && listSize > 1 && selectionIndex != -1 && selectionIndex < listSize - 1;
			downButton.setEnabled(enabled);
		}
	}

	private void enableAddButton(boolean baseEnable, int listSize, int selectionIndex) {
		if (addButton != null) {
			addButton.setEnabled(baseEnable);
		}
	}

	private void enableDeleteButton(boolean baseEnable, int listSize, int selectionIndex) {
		if (removeButton != null) {
			removeButton.setEnabled(baseEnable && listSize > 0 && selectionIndex != -1);
		}
	}

	@Override
	protected Control renderControl(SWTGridCell cell, Composite parent)
		throws NoPropertyDescriptorFoundExeption, NoRendererFoundException {
		if (rendererGridDescription.getColumns() == 1) {
			// Default
			return renderMultiAttributeControl(cell, parent);
		}
		// Compact: render validation icon
		if (cell.getColumn() == 0 && rendererGridDescription.getColumns() > 1) {
			validationIcon = createValidationIcon(parent);
			GridDataFactory.fillDefaults().hint(16, 17).grab(false, false).applyTo(validationIcon);
			return validationIcon;
		}
		// Compact: render list and buttons next to each other
		final Composite composite = new Composite(parent, SWT.NONE);
		composite.setBackground(parent.getBackground());

		try {
			final IObservableList list = getEMFFormsDatabinding().getObservableList(
				getVElement().getDomainModelReference(),
				getViewModelContext().getDomainModel());

			GridLayoutFactory.fillDefaults().numColumns(2).applyTo(composite);
			final Control multiAttributeComposite = renderMultiAttributeControl(cell, composite);
			GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(true, true).applyTo(multiAttributeComposite);
			final Composite buttonComposite = createButtonComposite(composite, list);
			GridDataFactory.fillDefaults().align(SWT.END, SWT.BEGINNING).grab(false, false).applyTo(buttonComposite);
			initButtons(list);

		} catch (final DatabindingFailedException ex) {
			getReportService().report(new RenderingFailedReport(ex));
			return createErrorLabel(composite, ex);
		}
		return composite;
	}

	/**
	 * Renders the MultiAttribute Control.
	 *
	 * Renders the MultiReference control including validation and buttons when {@link RenderMode} is set to
	 * {@link RenderMode#DEFAULT}. Only renders the
	 * MultiReferfence control without validation and buttons when renderMode is set to
	 * {@link RenderMode#COMPACT_VERTICALLY}.
	 *
	 * @param cell 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 renderMultiAttributeControl(SWTGridCell cell, Composite parent)
		throws NoRendererFoundException, NoPropertyDescriptorFoundExeption {

		final Composite composite = new Composite(parent, SWT.NONE);
		composite.setBackground(parent.getBackground());

		if (getTableStyleProperty().getRenderMode() == RenderMode.COMPACT_VERTICALLY) {
			// Avoid the default margins of "new GridLayout()"
			GridLayoutFactory.fillDefaults().applyTo(composite);
		} else {
			composite.setLayout(new GridLayout(1, false));
		}

		createLabelProvider();

		IObservableList list;
		try {
			list = getEMFFormsDatabinding().getObservableList(getVElement().getDomainModelReference(),
				getViewModelContext().getDomainModel());
		} catch (final DatabindingFailedException ex1) {
			getReportService().report(new RenderingFailedReport(ex1));
			return composite;
		}

		if (getTableStyleProperty().getRenderMode() == RenderMode.DEFAULT) {
			final Composite titleComposite = createTitleComposite(composite);
			createButtonComposite(titleComposite, list);
		}

		final Composite controlComposite = createControlComposite(composite);
		createContent(controlComposite, list);

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

		if (getTableStyleProperty().getRenderMode() == RenderMode.DEFAULT) {
			initButtons(list);
		}

		return composite;
	}

	/**
	 * Creates the Title Composite containing validation and buttons. Buttons have to be initialized afterwards.
	 *
	 * @param parent the parent {@link Composite}.
	 * @return the created {@link Composite}.
	 * @since 1.14
	 */
	protected Composite createTitleComposite(Composite parent) {
		final Composite titleComposite = new Composite(parent, SWT.NONE);
		titleComposite.setBackground(parent.getBackground());
		GridDataFactory.fillDefaults().grab(true, false).align(SWT.FILL, SWT.BEGINNING).applyTo(titleComposite);
		GridLayoutFactory.fillDefaults().numColumns(2).equalWidth(false).applyTo(titleComposite);

		validationIcon = createValidationIcon(titleComposite);
		GridDataFactory.fillDefaults().hint(16, 17).grab(false, false).applyTo(validationIcon);
		return titleComposite;
	}

	/**
	 * Create the button composite. Buttons have to be initialized after the table is created.
	 *
	 * @param parent the {@link Composite} parent.
	 * @param list the {@link IObservableList}.
	 * @return the created {@link Composite}.
	 * @since 1.14
	 */
	protected Composite createButtonComposite(Composite parent, IObservableList list) {
		final Composite buttonComposite = new Composite(parent, SWT.NONE);

		final EAttribute attribute = EAttribute.class.cast(list.getElementType());

		buttonComposite.setBackground(parent.getBackground());
		GridDataFactory.fillDefaults().align(SWT.END, SWT.BEGINNING).grab(true, false).applyTo(buttonComposite);
		int numButtons = 0;
		if (attribute.isOrdered()) {
			createUpDownButtons(buttonComposite, list);
			numButtons += 2;
		}

		addButton = createAddRowButton(buttonComposite, list);
		removeButton = createRemoveRowButton(buttonComposite, list);
		numButtons += 2;

		GridLayoutFactory.fillDefaults().numColumns(numButtons).equalWidth(false).applyTo(buttonComposite);
		return buttonComposite;
	}

	/**
	 * Initializes the buttons. Call this after table is created.
	 *
	 * @param list the {@link IObservableList}.
	 * @since 1.14
	 */
	protected void initButtons(IObservableList list) {
		initAddButton(addButton, list);
		initRemoveButton(removeButton, list);
		initUpButton(upButton, list);
		initDownButton(downButton, list);

		getTableViewer().addSelectionChangedListener(new ISelectionChangedListener() {
			@Override
			public void selectionChanged(SelectionChangedEvent event) {
				updateButtonEnabling();
			}
		});
		updateButtons();
	}

	private void createLabelProvider() {
		composedAdapterFactory = new ComposedAdapterFactory(
			new AdapterFactory[] { new CustomReflectiveItemProviderAdapterFactory(),
				new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE) });
		labelProvider = new AdapterFactoryLabelProvider(composedAdapterFactory);
		labelProvider.setFireLabelUpdateNotifications(true);
	}

	private void initAddButton(Button addButton, IObservableList list) {
		if (addButton == null) {
			return;
		}
		addButtonSelectionAdapter = new AddButtonSelectionAdapter(list);
		addButton.addSelectionListener(addButtonSelectionAdapter);
	}

	private void initRemoveButton(Button removeButton, IObservableList list) {
		if (removeButton == null) {
			return;
		}
		removeButtonSelectionAdapter = new RemoveButtonSelectionAdapter(list);
		removeButton.addSelectionListener(removeButtonSelectionAdapter);
	}

	private void initUpButton(Button upButton, IObservableList list) {
		if (upButton == null) {
			return;
		}
		upButtonSelectionAdapter = new UpButtonSelectionAdapter(list);
		upButton.addSelectionListener(upButtonSelectionAdapter);
		upButton.setEnabled(false);
	}

	private void initDownButton(Button downButton, IObservableList list) {
		if (downButton == null) {
			return;
		}
		downButtonSelectionAdapter = new DownButtonSelectionAdapter(list);
		downButton.addSelectionListener(downButtonSelectionAdapter);
		// by default, button should not be enabled (selection is empty)
		downButton.setEnabled(false);
	}

	/**
	 * Create the up and down buttons.
	 *
	 * @param composite The {@link Composite} to create the buttons on
	 * @param list The {@link IObservableList} of the current {@link MultiAttributeSWTRenderer}
	 * @since 1.17
	 */
	protected void createUpDownButtons(Composite composite, IObservableList list) {
		final Image up = getImage(ICONS_ARROW_UP_PNG);
		final Image down = getImage(ICONS_ARROW_DOWN_PNG);

		upButton = new Button(composite, SWT.PUSH);
		SWTDataElementIdHelper.setElementIdDataWithSubId(upButton, getVElement(), "up", getViewModelContext()); //$NON-NLS-1$
		upButton.setImage(up);
		upButton.setEnabled(!getVElement().isEffectivelyReadonly());

		downButton = new Button(composite, SWT.PUSH);
		SWTDataElementIdHelper.setElementIdDataWithSubId(downButton, getVElement(), "down", getViewModelContext()); //$NON-NLS-1$
		downButton.setImage(down);
		downButton.setEnabled(!getVElement().isEffectivelyReadonly());
	}

	private InternalEObject getInstanceOf(EClass clazz) {
		EObject tempInstance;
		if (clazz.isInterface() || clazz.isAbstract() || clazz.getInstanceClass() == null) {
			tempInstance = new DynamicEObjectImpl(clazz);
		} else {
			tempInstance = EcoreUtil.create(clazz);
		}
		return InternalEObject.class.cast(tempInstance);
	}

	private void createContent(Composite composite, IObservableList list) {
		final EAttribute attribute = EAttribute.class.cast(list.getElementType());
		tableViewer = new TableViewer(composite, SWT.MULTI | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
		tableViewer.getTable().setData(CUSTOM_VARIANT, "org_eclipse_emf_ecp_control_multiattribute"); //$NON-NLS-1$
		tableViewer.getTable().setHeaderVisible(true);
		tableViewer.getTable().setLinesVisible(true);

		final ColumnViewerEditorActivationStrategy actSupport = new ColumnViewerEditorActivationStrategy(tableViewer) {
			@Override
			protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
				if (getVElement().isEffectivelyReadonly()) {
					return false;
				}
				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, null, actSupport,
			ColumnViewerEditor.TABBING_HORIZONTAL | ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR
				| ColumnViewerEditor.TABBING_VERTICAL | ColumnViewerEditor.KEYBOARD_ACTIVATION);
		ColumnViewerToolTipSupport.enableFor(tableViewer);

		final ObservableListContentProvider cp = new ObservableListContentProvider();

		final EMFFormsLabelProvider labelService = getEMFFormsLabelProvider();

		final TableViewerColumn column = new TableViewerColumn(tableViewer, SWT.NONE);
		column.getColumn().setResizable(false);
		column.getColumn().setMoveable(false);

		final EClass clazz = attribute.getEContainingClass();
		InternalEObject tempInstance = null;
		if (!clazz.isAbstract() && !clazz.isInterface()) {
			tempInstance = getInstanceOf(clazz);
		}

		final CellEditor cellEditor = createCellEditor(tempInstance, attribute, tableViewer.getTable());

		@SuppressWarnings("deprecation")
		final IObservableValue textObservableValue = org.eclipse.jface.databinding.swt.SWTObservables
			.observeText(column.getColumn());
		@SuppressWarnings("deprecation")
		final IObservableValue tooltipObservableValue = org.eclipse.jface.databinding.swt.SWTObservables
			.observeTooltipText(column.getColumn());
		try {
			viewModelDBC.bindValue(textObservableValue, labelService
				.getDisplayName(getVElement().getDomainModelReference(), getViewModelContext().getDomainModel()));

			viewModelDBC.bindValue(tooltipObservableValue, labelService
				.getDescription(getVElement().getDomainModelReference(), getViewModelContext().getDomainModel()));
		} catch (final NoLabelFoundException e) {
			getReportService().report(new RenderingFailedReport(e));
		}

		tableViewer.setLabelProvider(labelProvider);
		tableViewer.setContentProvider(cp);
		tableViewer.setInput(list);

		final TableColumnLayout layout = new TableColumnLayout();
		composite.setLayout(layout);
		layout.setColumnData(column.getColumn(), new ColumnWeightData(1, false));

		final VDomainModelReference dmr = getVElement().getDomainModelReference();
		observableSupport = new ECPListEditingSupport(tableViewer, cellEditor, getVElement(), dmr,
			list);
		column.setEditingSupport(observableSupport);

	}

	private CellEditor createCellEditor(final EObject tempInstance, final EAttribute attribute, Table table) {
		return CellEditorFactory.INSTANCE.createCellEditor(attribute, tempInstance, table, getViewModelContext());
	}

	/**
	 * Returns the attribute value which should be added as a new element.
	 *
	 * @param attribute the {@link EAttribute} with the data type
	 * @return the new value
	 * @since 1.13
	 */
	protected Object getValueForNewRow(final EAttribute attribute) {
		try {
			Object defaultValue = attribute.getDefaultValue();
			if (defaultValue == null || !attribute.getEType().isInstance(defaultValue)) {
				// Use a singular default value, but not a multiple value if that's
				// what is specified in the model, because we shouldn't add more than
				// one value
				defaultValue = attribute.getEType().getDefaultValue();
			}
			if (defaultValue == null) {
				defaultValue = attribute.getEType().getInstanceClass().getConstructor().newInstance();
			}
			return defaultValue;
		} catch (final InstantiationException ex) {
			getReportService().report(new AbstractReport(ex, Messages.MultiAttributeSWTRenderer_AddFailed));
		} catch (final IllegalAccessException ex) {
			getReportService().report(new AbstractReport(ex, Messages.MultiAttributeSWTRenderer_AddFailed));
		} catch (final IllegalArgumentException ex) {
			getReportService().report(new AbstractReport(ex, Messages.MultiAttributeSWTRenderer_AddFailed));
		} catch (final InvocationTargetException ex) {
			getReportService().report(new AbstractReport(ex, Messages.MultiAttributeSWTRenderer_AddFailed));
		} catch (final NoSuchMethodException ex) {
			getReportService().report(new AbstractReport(ex, Messages.MultiAttributeSWTRenderer_AddFailed));
		} catch (final SecurityException ex) {
			getReportService().report(new AbstractReport(ex, Messages.MultiAttributeSWTRenderer_AddFailed));
		}
		throw new IllegalStateException();
	}

	@Override
	protected void applyValidation() {
		Display.getDefault().asyncExec(new Runnable() {

			@Override
			public void run() {
				if (validationIcon == null) {
					return;
				}
				if (validationIcon.isDisposed()) {
					return;
				}
				if (getVElement().getDiagnostic() == null) {
					return;
				}
				validationIcon.setImage(getValidationIcon());
				validationIcon.setToolTipText(ECPTooltipModifierHelper.modifyString(getVElement().getDiagnostic()
					.getMessage(), null));
			}
		});
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.ecp.view.spi.core.swt.AbstractControlSWTRenderer#applyEnable()
	 */
	@Override
	protected void applyEnable() {
		super.applyEnable();
		updateButtonEnabling();
	}

	/**
	 * @return
	 */
	private Button getMoveDownButton() {
		return downButton;
	}

	/**
	 * @return
	 */
	private Button getMoveUpButton() {
		return upButton;
	}

	/**
	 * @return
	 */
	private Button getRemoveButton() {
		return removeButton;
	}

	/**
	 * @return
	 */
	private Button getAddButton() {
		return addButton;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public void dispose() {
		if (mainComposite != null) {
			mainComposite.dispose();
		}
		if (labelProvider != null) {
			labelProvider.dispose();
		}
		if (composedAdapterFactory != null) {
			composedAdapterFactory.dispose();
		}
		super.dispose();
	}

	/**
	 * Listener for the down button.
	 *
	 * @author David Soto Setzke
	 * @author Johannes Faltermeier
	 *
	 */
	private final class DownButtonSelectionAdapter extends SelectionAdapter {

		private IObservableList list;

		DownButtonSelectionAdapter(IObservableList list) {
			setObservableList(list);
		}

		public void setObservableList(IObservableList list) {
			this.list = list;
		}

		@Override
		public void widgetSelected(SelectionEvent e) {
			final IObserving observing = IObserving.class.cast(list);
			final EObject eObject = EObject.class.cast(observing.getObserved());
			final EAttribute attribute = EAttribute.class.cast(list.getElementType());

			final int currentIndex = tableViewer.getTable().getSelectionIndex();
			if (currentIndex + 1 < tableViewer.getTable().getItems().length) {
				final EditingDomain editingDomain = getEditingDomain(eObject);
				editingDomain.getCommandStack()
					.execute(new MoveCommand(editingDomain, eObject, attribute, currentIndex, currentIndex + 1));
				tableViewer.refresh();
				tableViewer.getTable().setSelection(currentIndex + 1);
				final TableItem[] selection = tableViewer.getTable().getSelection();
				if (selection.length > 0) {
					tableViewer.getTable().showItem(selection[0]);
				}
			}
		}
	}

	/**
	 * Listener for the up button.
	 *
	 * @author David Soto Setzke
	 * @author Johannes Faltermeier
	 *
	 */
	private final class UpButtonSelectionAdapter extends SelectionAdapter {

		private IObservableList list;

		UpButtonSelectionAdapter(IObservableList list) {
			setObservableList(list);
		}

		public void setObservableList(IObservableList list) {
			this.list = list;
		}

		@Override
		public void widgetSelected(SelectionEvent e) {
			final IObserving observing = IObserving.class.cast(list);
			final EObject eObject = EObject.class.cast(observing.getObserved());
			final EAttribute attribute = EAttribute.class.cast(list.getElementType());

			final int currentIndex = tableViewer.getTable().getSelectionIndex();
			if (currentIndex != 0) {
				final EditingDomain editingDomain = getEditingDomain(eObject);

				editingDomain.getCommandStack()
					.execute(new MoveCommand(editingDomain, eObject, attribute, currentIndex, currentIndex - 1));
				tableViewer.refresh();
				tableViewer.getTable().setSelection(currentIndex - 1);
				final TableItem[] selection = tableViewer.getTable().getSelection();
				if (selection.length > 0) {
					tableViewer.getTable().showItem(selection[0]);
				}
			}
		}
	}

	/**
	 * Listener for the remove button.
	 *
	 * @author David Soto Setzke
	 * @author Johannes Faltermeier
	 *
	 */
	private final class RemoveButtonSelectionAdapter extends SelectionAdapter {

		private IObservableList list;

		RemoveButtonSelectionAdapter(IObservableList list) {
			setObservableList(list);
		}

		public void setObservableList(IObservableList list) {
			this.list = list;
		}

		@Override
		public void widgetSelected(SelectionEvent e) {
			final IObserving observing = IObserving.class.cast(list);
			final EObject eObject = EObject.class.cast(observing.getObserved());
			final EAttribute attribute = EAttribute.class.cast(list.getElementType());

			final EditingDomain editingDomain = getEditingDomain(eObject);
			final IStructuredSelection selection = tableViewer.getStructuredSelection();
			if (!selection.isEmpty()) {
				editingDomain.getCommandStack().execute(RemoveCommand.create(editingDomain, eObject, attribute,
					selection.toList()));
				postRemove(selection);
			}
		}
	}

	/**
	 * Listener for the add button.
	 *
	 * @author David Soto Setzke
	 * @author Johannes Faltermeier
	 *
	 */
	private final class AddButtonSelectionAdapter extends SelectionAdapter {

		private IObservableList list;

		AddButtonSelectionAdapter(IObservableList list) {
			setObservableList(list);
		}

		public void setObservableList(IObservableList list) {
			this.list = list;
		}

		@Override
		public void widgetSelected(SelectionEvent event) {
			try {
				final IObserving observing = IObserving.class.cast(list);
				final EObject eObject = EObject.class.cast(observing.getObserved());
				final EAttribute attribute = EAttribute.class.cast(list.getElementType());

				final Object defaultValue = getValueForNewRow(attribute);
				if (defaultValue == null) {
					return;
				}
				final EditingDomain editingDomain = getEditingDomain(getViewModelContext().getDomainModel());
				editingDomain.getCommandStack()
					.execute(AddCommand.create(editingDomain, eObject, attribute, defaultValue));
			} catch (final IllegalStateException ex) {
				/* logged by getValueForNewRow* already */
			}
		}
	}

	/**
	 * Editing support for a single element in a multi {@link EAttribute}.
	 *
	 * @author jfaltermeier
	 *
	 */
	private class ECPListEditingSupport extends EditingSupport {

		private final CellEditor cellEditor;

		private final VControl control;

		private IObservableList valueProperty;

		ECPListEditingSupport(ColumnViewer viewer, CellEditor cellEditor, VControl control,
			VDomainModelReference domainModelReference, IObservableList valueProperty) {
			super(viewer);
			this.cellEditor = cellEditor;
			this.control = control;
			this.valueProperty = valueProperty;
		}

		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) {

			final boolean editable = control.isEffectivelyEnabled() && !control.isEffectivelyReadonly();

			if (ECPCellEditor.class.isInstance(cellEditor)) {
				ECPCellEditor.class.cast(cellEditor).setEditable(editable);
				return editable;
			}
			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) {
			final IObservableValue target = doCreateCellEditorObservable(cellEditor);
			final TableViewerRow viewerRow = (TableViewerRow) cell.getViewerRow();
			final TableItem item = (TableItem) viewerRow.getItem();
			final int index = item.getParent().indexOf(item);
			final EAttribute fakeAttribute = EcoreUtil.copy(EAttribute.class.cast(valueProperty.getElementType()));
			fakeAttribute.setUpperBound(1);
			fakeAttribute.setLowerBound(0);
			final IObservableValue model = new org.eclipse.emf.ecp.edit.internal.swt.util.ECPObservableValue(
				valueProperty, index,
				fakeAttribute);

			final Binding binding = createBinding(target, model);

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

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

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

		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);
		}

		@SuppressWarnings("deprecation")
		protected IObservableValue doCreateCellEditorObservable(CellEditor cellEditor) {
			if (ECPCellEditor.class.isInstance(cellEditor)) {
				return ((ECPCellEditor) cellEditor).getValueProperty().observe(cellEditor);
			}
			return org.eclipse.jface.databinding.swt.SWTObservables.observeText(cellEditor.getControl(), SWT.FocusOut);
		}

		@Override
		protected final void saveCellEditorValue(CellEditor cellEditor, ViewerCell cell) {
			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) {
				// do nothing
			}

			@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;

			EditingState(Binding binding, IObservableValue target, IObservableValue model) {
				this.binding = binding;
				this.target = target;
				this.model = model;
			}

			void dispose() {
				binding.dispose();
				target.dispose();
				model.dispose();
			}
		}

		public void setObservableList(IObservableList list) {
			valueProperty = list;
		}
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.ecp.view.spi.core.swt.AbstractControlSWTRenderer#rootDomainModelChanged()
	 */
	@Override
	protected void rootDomainModelChanged() throws DatabindingFailedException {
		final IObservableList oldList = (IObservableList) getTableViewer().getInput();
		oldList.dispose();

		final IObservableList list = getEMFFormsDatabinding().getObservableList(
			getVElement().getDomainModelReference(),
			getViewModelContext().getDomainModel());
		// addRelayoutListenerIfNeeded(list, composite);
		getTableViewer().setInput(list);

		addButtonSelectionAdapter.setObservableList(list);
		removeButtonSelectionAdapter.setObservableList(list);
		upButtonSelectionAdapter.setObservableList(list);
		downButtonSelectionAdapter.setObservableList(list);
		observableSupport.setObservableList(list);
	}

	/**
	 * This is called after the selected elements were deleted so that the user can handle this removal.
	 *
	 * @param selection The {@link IStructuredSelection} of the TableViewer before deletion.
	 * @since 1.17
	 */
	protected void postRemove(IStructuredSelection selection) {
		// do nothing
	}

	/**
	 * Creates an error label for the given {@link Exception}.
	 *
	 * @param parent The parent of the {@link Label}
	 * @param ex The {@link Exception} causing the error
	 * @return The error {@link Label}
	 * @since 1.14
	 */
	protected Control createErrorLabel(Composite parent, final Exception ex) {
		final Label errorLabel = new Label(parent, SWT.NONE);
		errorLabel.setText(ex.getMessage());
		return errorLabel;
	}

}