Attachment #184328 for bug #331633

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 331633
Collapse All | Expand All

Lines 22-28 Link Here

(-)src/org/eclipse/emf/facet/widgets/nattable/RowHeaderLayerStack.java (-1 / +2 lines)
22	private static final int DEFAULT_ROW_HEIGHT = 20;	22	private static final int DEFAULT_ROW_HEIGHT = 20;
23		23
24	public RowHeaderLayerStack(final IDataProvider dataProvider, final BodyLayerStack bodyLayer) {	24	public RowHeaderLayerStack(final IDataProvider dataProvider, final BodyLayerStack bodyLayer) {
25	DataLayer dataLayer = new DataLayer(dataProvider, RowHeaderLayerStack.DEFAULT_COLUMN_WIDTH, RowHeaderLayerStack.DEFAULT_ROW_HEIGHT);	25	DataLayer dataLayer = new DataLayer(dataProvider, RowHeaderLayerStack.DEFAULT_COLUMN_WIDTH,
		26	RowHeaderLayerStack.DEFAULT_ROW_HEIGHT);
26	RowHeaderLayer rowHeaderLayer = new RowHeaderLayer(dataLayer, bodyLayer,	27	RowHeaderLayer rowHeaderLayer = new RowHeaderLayer(dataLayer, bodyLayer,
27	bodyLayer.getSelectionLayer());	28	bodyLayer.getSelectionLayer());
28	setUnderlyingLayer(rowHeaderLayer);	29	setUnderlyingLayer(rowHeaderLayer);





	private void addSelectedModeStyling(final IConfigRegistry configRegistry) {
		ICellPainter selectedCellPainter = new BackgroundImagePainter(createCellPainter(),
				StyledColumnHeaderConfiguration.SELECTED_BG_IMAGE,
				StyledColumnHeaderConfiguration.COLOR_GRAY);

		// If sorting is enabled we still want the sort icon to be drawn.
		SortableHeaderTextPainter selectedHeaderPainter = new SortableHeaderTextPainter(

	private void addNormalModeStyling(final IConfigRegistry configurationRegistry) {

		ICellPainter normalCellPainter = new BackgroundImagePainter(createCellPainter(),
				StyledColumnHeaderConfiguration.BG_IMAGE,
				StyledColumnHeaderConfiguration.COLOR_GRAY);

		SortableHeaderTextPainter headerPainter = new SortableHeaderTextPainter(normalCellPainter,
				false);

	private void addCornerStyling(final IConfigRegistry configurationRegistry) {
		// adds painting of the the gray triangle in the upper left corner
		ICellPainter cornerPainter = new BackgroundImagePainter(createCellPainter(),
				StyledColumnHeaderConfiguration.BG_IMAGE,
				StyledColumnHeaderConfiguration.COLOR_GRAY) {
			@Override
			public void paintCell(final LayerCell cell, final GC gc, final Rectangle rectangle,
					final IConfigRegistry configRegistry) {




import net.sourceforge.nattable.util.GUIHelper;
import net.sourceforge.nattable.viewport.ViewportLayer;

import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EDataType;
import org.eclipse.emf.ecore.EEnum;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.edit.ui.dnd.LocalTransfer;

import org.eclipse.emf.facet.widgets.celleditors.IModelCellEditor;
import org.eclipse.emf.facet.widgets.celleditors.IModelCellEditorValidator;
import org.eclipse.emf.facet.widgets.celleditors.INaryFeatureCellEditor;
import org.eclipse.emf.facet.widgets.celleditors.ModelCellEditor;
import org.eclipse.emf.facet.widgets.celleditors.core.EEnumCellEditor;
import org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.AbstractModelCellEditor;
import org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.NaryFeatureCellEditor;
import org.eclipse.emf.facet.widgets.nattable.ColumnDescription.Type;
import org.eclipse.emf.facet.widgets.nattable.TableInput.ElementsDescription;
import org.eclipse.jface.action.MenuManager;

			// not editable if no editing domain was provided
			public void configureRegistry(final IConfigRegistry configRegistry) {
				if (NatTableWidget.this.fTableInput.getEditingDomain() != null) {
					List<ModelCellEditorContainer<? extends AbstractModelCellEditor>> allCellEditorContainers = CellEditorsRegistry
							.getInstance().getAllCellEditors();
					for (int nColumn = 0; nColumn < NatTableWidget.this.fColumnDescriptions.size(); nColumn++) {
						ColumnDescription columnDescription = NatTableWidget.this.fColumnDescriptions
								.get(nColumn);

						if (columnDescription.getType() == Type.ATTRIBUTE
								&& columnDescription.getAttribute().getEType() instanceof EEnum) {
							registerEnumCellEditor(configRegistry, (EEnum) columnDescription
									.getFeature().getEType(), columnLabelAccumulator, nColumn,
									columnDescription);
						} else {
							registerCellEditorForColumn(columnLabelAccumulator, nColumn,
									columnDescription);
						}
					}

					List<ModelCellEditorContainer<? extends AbstractModelCellEditor>> allCellEditorContainers = CellEditorsRegistry
							.getInstance().getAllCellEditors();
					for (ModelCellEditorContainer<? extends AbstractModelCellEditor> modelCellEditorContainer : allCellEditorContainers) {
						registerCellEditor(modelCellEditorContainer, configRegistry);
					}

	}

	private void registerCellEditorForColumn(
			final ColumnOverrideLabelAccumulator columnLabelAccumulator, final int nColumn,
			final ColumnDescription columnDescription) {
			final int nColumn, final ColumnDescription columnDescription) {
		if (columnDescription.getType() == ColumnDescription.Type.ATTRIBUTE
				|| columnDescription.getType() == ColumnDescription.Type.REFERENCE) {
			EStructuralFeature feature = columnDescription.getFeature();

			if (!feature.isChangeable()) {
				return;
			}
			ModelCellEditor selectedCellEditor = CellEditorsRegistry.getInstance()
					.getCellEditorFor(feature.getEType(), feature.isMany());

			class CellEditor {
				private final String bundleName;
				private final String cellID;

				public CellEditor(final String bundleName, final String cellID) {
					this.bundleName = bundleName;
					this.cellID = cellID;
				}

				public String getBundleName() {
					return this.bundleName;
				}

				public String getCellID() {
					return this.cellID;
				}
			}
			List<CellEditor> cellEditors = new ArrayList<CellEditor>();

			for (ModelCellEditorContainer<? extends AbstractModelCellEditor> modelCellEditorContainer : allCellEditorContainers) {
				AbstractModelCellEditor modelCellEditor = modelCellEditorContainer
						.getModelCellEditor();

				if (feature.isMany() != (modelCellEditor instanceof NaryFeatureCellEditor)) {
					continue;
				}

				if (isSuperType(modelCellEditor.getCellType(), eType)) {
					cellEditors.add(new CellEditor(modelCellEditorContainer.getBundleName(),
							modelCellEditor.getCellId()));
				}
			}

			CellEditor selectedCellEditor = null;
			if (cellEditors.size() == 1) {
				selectedCellEditor = cellEditors.get(0);
			} else if (cellEditors.size() > 1) {
				boolean skippedDefault = false;
				for (CellEditor cellEditor : cellEditors) {
					// lower priority for
					// org.eclipse.emf.facet.widgets.celleditors.*
					if (cellEditor.getBundleName().startsWith(
							"org.eclipse.emf.facet.widgets.celleditors")) { //$NON-NLS-1$
						if (skippedDefault) {
							Logger.logError(
									"Several default cell editors are defined in EMF Facet for type: " //$NON-NLS-1$
											+ eType.getName(), Activator.getDefault());
							selectedCellEditor = cellEditor;
							break;
						}
						skippedDefault = true;
						continue;
					}
					if (selectedCellEditor != null) {
						Logger.logWarning("Several cell editors are defined for type: " //$NON-NLS-1$
								+ eType.getName(), Activator.getDefault());
						break;
					}
					selectedCellEditor = cellEditor;
				}
			}

			if (selectedCellEditor != null) {
				// register cell editor for this column

						selectedCellEditor.getCellID());
			} else {
				Logger.logWarning(
						"No cell editor defined for type: " + EcoreUtil.getURI(feature.getEType()) + " (column " + nColumn + ")", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
						Activator.getDefault());
			}
		}
	}

	private boolean isSuperType(final EClassifier superType, final EClassifier subType) {
		if (superType == subType) {
			return true;
		}

		if (superType instanceof EClass && subType instanceof EClass) {
			// special case because isSuperTypeOf doesn't handle it
			if (superType == EcorePackage.eINSTANCE.getEObject()) {
				return true;
			}

			EClass superTypeEClass = (EClass) superType;
			EClass subTypeEClass = (EClass) subType;
			return superTypeEClass.isSuperTypeOf(subTypeEClass);
		}

		if (superType == EcorePackage.eINSTANCE.getEDataType() && subType instanceof EDataType) {
			// cf Bug 331539 - cell editor registered for type "EDataType"
			return true;
		}

		return false;
	}

	/**
	 * Registers a cell editor in the config registry
	 * 

	 * @param nColumn
	 * @param columnDescription
	 */
	private void registerEnumCellEditor(final IConfigRegistry configRegistry, final EEnum eType,
			final ColumnOverrideLabelAccumulator columnLabelAccumulator, final int nColumn,
			final ColumnDescription columnDescription) {
			final ColumnOverrideLabelAccumulator columnLabelAccumulator,
			final List<ModelCellEditorContainer<? extends AbstractModelCellEditor>> allCellEditorContainers,
			final int nColumn, final ColumnDescription columnDescription) {
		columnLabelAccumulator.registerColumnOverrides(nColumn,
				NatTableWidget.ENUM_CELLEDITOR_LABEL);
		configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR,

	private void registerCellEditor(
			final ModelCellEditorContainer<? extends AbstractModelCellEditor> modelCellEditorContainer,
			final IConfigRegistry configRegistry) {
		AbstractModelCellEditor modelCellEditor = modelCellEditorContainer.getModelCellEditor();
		String className = modelCellEditor.getModelCellEditorImpl();

		Class<?> classInstance = null;
		try {
			classInstance = Platform.getBundle(modelCellEditorContainer.getBundleName()).loadClass(
					className);
		} catch (Exception e) {
			Logger.logError("Could not find class: " + className, //$NON-NLS-1$
					Activator.getDefault());
			return;
		}

		ModelCellEditor cellEditor = new ModelCellEditor(modelCellEditorContainer.getBundleName(),
				modelCellEditorContainer.getModelCellEditor());
		Object cellEditorImplementation = cellEditor.getCellEditorImplementation();
		} catch (Exception e) {
			Logger.logError("Could not instantiate class: " + className, //$NON-NLS-1$
					Activator.getDefault());
			return;
		}

		if (cellEditorImplementation instanceof IModelCellEditor) {
			IModelCellEditor modelCellEditorImpl = (IModelCellEditor) cellEditorImplementation;

			configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR,
					new NatTableCellEditorAdapter(modelCellEditorImpl,
							NatTableWidget.this.fColumnDescriptions), DisplayMode.NORMAL,
					cellEditor.getCellID());
			configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITABLE_RULE,
					IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, cellEditor.getCellID());
		} else if (cellEditorImplementation instanceof INaryFeatureCellEditor) {
			INaryFeatureCellEditor modelCellEditorImpl = (INaryFeatureCellEditor) cellEditorImplementation;

			configRegistry.registerConfigAttribute(
					EditConfigAttributes.CELL_EDITOR,
					new NatTableNaryReferenceCellEditorAdapter(modelCellEditorImpl,
							NatTableWidget.this.fColumnDescriptions, this.fTableInput
									.getEditingDomain()), DisplayMode.NORMAL, cellEditor
							.getCellID());
			configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITABLE_RULE,
					IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, cellEditor.getCellID());
			// disable automatic commit for INaryReferenceCellEditor
			configRegistry.registerConfigAttribute(EditConfigAttributes.DATA_VALIDATOR,
					IDataValidator.NEVER_VALID, DisplayMode.EDIT, cellEditor.getCellID());
		} else {
			Logger.logError("Model cell editor implementation must be an instance of " //$NON-NLS-1$
					+ IModelCellEditor.class.getSimpleName() + " or " //$NON-NLS-1$

			return;
		}

		if (cellEditorImplementation instanceof IModelCellEditorValidator) {
			IModelCellEditorValidator modelCellEditorValidator = (IModelCellEditorValidator) cellEditorImplementation;
			configRegistry.registerConfigAttribute(EditConfigAttributes.DATA_VALIDATOR,
					new DataValidatorAdapter(modelCellEditorValidator), DisplayMode.EDIT,
					cellEditor.getCellID());
		}
	}


Lines 17-26 Link Here

(-)src/org/eclipse/emf/facet/widgets/celleditors/CellEditorsRegistry.java (+80 lines)
17	import org.eclipse.core.runtime.IConfigurationElement;	17	import org.eclipse.core.runtime.IConfigurationElement;
18	import org.eclipse.emf.common.util.EList;	18	import org.eclipse.emf.common.util.EList;
19	import org.eclipse.emf.common.util.URI;	19	import org.eclipse.emf.common.util.URI;
		20	import org.eclipse.emf.ecore.EClass;
		21	import org.eclipse.emf.ecore.EClassifier;
		22	import org.eclipse.emf.ecore.EDataType;
20	import org.eclipse.emf.ecore.EObject;	23	import org.eclipse.emf.ecore.EObject;
		24	import org.eclipse.emf.ecore.EcorePackage;
21	import org.eclipse.emf.ecore.resource.Resource;	25	import org.eclipse.emf.ecore.resource.Resource;
22	import org.eclipse.emf.ecore.resource.ResourceSet;	26	import org.eclipse.emf.ecore.resource.ResourceSet;
23	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;	27	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
		28	import org.eclipse.emf.ecore.util.EcoreUtil;
24	import org.eclipse.emf.facet.infra.common.core.internal.extensions.AbstractRegistry;	29	import org.eclipse.emf.facet.infra.common.core.internal.extensions.AbstractRegistry;
25	import org.eclipse.emf.facet.infra.common.core.logging.Logger;	30	import org.eclipse.emf.facet.infra.common.core.logging.Logger;
26	import org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.AbstractModelCellEditor;	31	import org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.AbstractModelCellEditor;
Lines 85-90 Link Here
85	return allCellEditors;	90	return allCellEditors;
86	}	91	}
87		92
		93	public ModelCellEditor getCellEditorFor(final EClassifier type, final boolean many) {
		94
		95	List<CellEditorsRegistry.ModelCellEditorContainer<? extends AbstractModelCellEditor>> allCellEditorContainers = getAllCellEditors();
		96
		97	List<ModelCellEditor> cellEditors = new ArrayList<ModelCellEditor>();
		98
		99	for (ModelCellEditorContainer<? extends AbstractModelCellEditor> modelCellEditorContainer : allCellEditorContainers) {
		100	AbstractModelCellEditor modelCellEditor = modelCellEditorContainer.getModelCellEditor();
		101
		102	if (many != (modelCellEditor instanceof NaryFeatureCellEditor)) {
		103	continue;
		104	}
		105
		106	if (isSuperType(modelCellEditor.getCellType(), type)) {
		107	cellEditors.add(new ModelCellEditor(modelCellEditorContainer.getBundleName(),
		108	modelCellEditorContainer.getModelCellEditor()));
		109	}
		110	}
		111
		112	ModelCellEditor selectedCellEditor = null;
		113	if (cellEditors.size() == 1) {
		114	selectedCellEditor = cellEditors.get(0);
		115	} else if (cellEditors.size() > 1) {
		116	boolean skippedDefault = false;
		117	for (ModelCellEditor cellEditor : cellEditors) {
		118	// lower priority for
		119	// org.eclipse.emf.facet.widgets.celleditors.*
		120	if (cellEditor.getBundleName().startsWith(
		121	"org.eclipse.emf.facet.widgets.celleditors")) { //$NON-NLS-1$
		122	if (skippedDefault) {
		123	Logger.logError(
		124	"Several default cell editors are defined in EMF Facet for type: " //$NON-NLS-1$
		125	+ EcoreUtil.getURI(type), Activator.getDefault());
		126	selectedCellEditor = cellEditor;
		127	break;
		128	}
		129	skippedDefault = true;
		130	continue;
		131	}
		132	if (selectedCellEditor != null) {
		133	Logger.logWarning("Several cell editors are defined for type: " //$NON-NLS-1$
		134	+ EcoreUtil.getURI(type), Activator.getDefault());
		135	break;
		136	}
		137	selectedCellEditor = cellEditor;
		138	}
		139	}
		140
		141	return selectedCellEditor;
		142	}
		143
		144	private boolean isSuperType(final EClassifier superType, final EClassifier subType) {
		145	if (superType == subType) {
		146	return true;
		147	}
		148
		149	if (superType instanceof EClass && subType instanceof EClass) {
		150	// special case because isSuperTypeOf doesn't handle it
		151	if (superType == EcorePackage.eINSTANCE.getEObject()) {
		152	return true;
		153	}
		154
		155	EClass superTypeEClass = (EClass) superType;
		156	EClass subTypeEClass = (EClass) subType;
157	return superTypeEClass.isSuperTypeOf(subTypeEClass);
158	}
159
160	if (superType == EcorePackage.eINSTANCE.getEDataType() && subType instanceof EDataType) {
161	// cf Bug 331539 - cell editor registered for type "EDataType"
162	return true;
163	}
164
165	return false;
166	}
167
88	public List<CellEditorsRegistry.ModelCellEditorContainer<BasicCellEditor>> getBasicCellEditors() {	168	public List<CellEditorsRegistry.ModelCellEditorContainer<BasicCellEditor>> getBasicCellEditors() {
89	return this.basicCellEditors;	169	return this.basicCellEditors;
90	}	170	}

Lines 152-158 Link Here

(-)src/org/eclipse/emf/facet/widgets/celleditors/modelCellEditor/impl/NaryFeatureCellEditorImpl.java (-1 / +2 lines)
152	switch (featureID) {	152	switch (featureID) {
153	case ModelCellEditorPackage.NARY_FEATURE_CELL_EDITOR__NARY_FEATURE_CELL_EDITOR_IMPL:	153	case ModelCellEditorPackage.NARY_FEATURE_CELL_EDITOR__NARY_FEATURE_CELL_EDITOR_IMPL:
154	return NaryFeatureCellEditorImpl.NARY_FEATURE_CELL_EDITOR_IMPL_EDEFAULT == null ? this.naryFeatureCellEditorImpl != null	154	return NaryFeatureCellEditorImpl.NARY_FEATURE_CELL_EDITOR_IMPL_EDEFAULT == null ? this.naryFeatureCellEditorImpl != null
155	: !NaryFeatureCellEditorImpl.NARY_FEATURE_CELL_EDITOR_IMPL_EDEFAULT.equals(this.naryFeatureCellEditorImpl);	155	: !NaryFeatureCellEditorImpl.NARY_FEATURE_CELL_EDITOR_IMPL_EDEFAULT
		156	.equals(this.naryFeatureCellEditorImpl);
156	}	157	}
157	return super.eIsSet(featureID);	158	return super.eIsSet(featureID);
158	}	159	}

Lines 34-39 Link Here

(-)src/org/eclipse/emf/facet/widgets/celleditors/DefaultCommandFactory.java (+5 lines)
34	return SetCommand.create(domain, owner, feature, value);	34	return SetCommand.create(domain, owner, feature, value);
35	}	35	}
36		36
		37	public Command createSetCommand(final EditingDomain domain, final Object owner,
		38	final Object feature, final Object value, final int index) {
		39	return SetCommand.create(domain, owner, feature, value, index);
		40	}
		41
37	public Command createMoveCommand(final EditingDomain domain, final Object owner,	42	public Command createMoveCommand(final EditingDomain domain, final Object owner,
38	final Object feature, final Object value, final int index) {	43	final Object feature, final Object value, final int index) {
39	return MoveCommand.create(domain, owner, feature, value, index);	44	return MoveCommand.create(domain, owner, feature, value, index);




/*******************************************************************************
 * Copyright (c) 2010 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Nicolas Bros (Mia-Software) - initial API and implementation
 *******************************************************************************/
package org.eclipse.emf.facet.widgets.celleditors;

import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.facet.infra.common.core.logging.Logger;
import org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.AbstractModelCellEditor;

public class ModelCellEditor {
	private final String bundleName;
	private final AbstractModelCellEditor modelCellEditor;

	public ModelCellEditor(final String bundleName, final AbstractModelCellEditor modelCellEditor) {
		this.bundleName = bundleName;
		this.modelCellEditor = modelCellEditor;
	}

	public String getBundleName() {
		return this.bundleName;
	}

	public String getCellID() {
		return this.modelCellEditor.getCellId();
	}

	public AbstractModelCellEditor getModelCellEditor() {
		return this.modelCellEditor;
	}

	public Object getCellEditorImplementation() {
		String className = this.modelCellEditor.getModelCellEditorImpl();

		Class<?> classInstance = null;
		try {
			classInstance = Platform.getBundle(this.bundleName).loadClass(className);
		} catch (Exception e) {
			Logger.logError("Could not find class: " + className, //$NON-NLS-1$
					Activator.getDefault());
			return null;
		}

		Object instance = null;
		try {
			instance = classInstance.newInstance();
		} catch (Exception e) {
			Logger.logError("Could not instantiate class: " + className, //$NON-NLS-1$
					Activator.getDefault());
			return null;
		}
		return instance;
	}

	@Override
	public boolean equals(final Object obj) {
		if (obj instanceof ModelCellEditor) {
			ModelCellEditor other = (ModelCellEditor) obj;
			return other.getCellID().equals(getCellID());
		}
		return false;
	}

	@Override
	public int hashCode() {
		return getCellID().hashCode();
	}

	@Override
	public String toString() {
		return getBundleName() + "#" + getCellID(); //$NON-NLS-1$
	}
}




/*******************************************************************************
 * Copyright (c) 2010 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Nicolas Bros (Mia-Software) - initial API and implementation
 *******************************************************************************/
package org.eclipse.emf.facet.widgets.celleditors.ui;

import java.util.List;

import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.facet.widgets.celleditors.CellEditorsRegistry;
import org.eclipse.emf.facet.widgets.celleditors.CommandFactoriesRegistry;
import org.eclipse.emf.facet.widgets.celleditors.ICommandFactory;
import org.eclipse.emf.facet.widgets.celleditors.IModelCellEditHandler;
import org.eclipse.emf.facet.widgets.celleditors.IModelCellEditor;
import org.eclipse.emf.facet.widgets.celleditors.ModelCellEditor;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ColumnViewer;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

public class ModelCellsEditingSupport extends EditingSupport {

	private final EStructuralFeature feature;
	private IModelCellEditor cellEditor;
	private final EObject eObject;
	private final EditingDomain editingDomain;
	private final ColumnViewer columnViewer;
	private final Object newValuePlaceholder;

	public ModelCellsEditingSupport(final ColumnViewer columnViewer,
			final EStructuralFeature feature, final EObject eObject,
			final EditingDomain editingDomain, final Object newValuePlaceholder) {
		super(columnViewer);
		this.columnViewer = columnViewer;
		this.feature = feature;
		this.eObject = eObject;
		this.editingDomain = editingDomain;
		this.newValuePlaceholder = newValuePlaceholder;
		ModelCellEditor modelCellEditor = CellEditorsRegistry.getInstance().getCellEditorFor(
				this.feature.getEType(), false);
		Object cellEditorImplementation = modelCellEditor.getCellEditorImplementation();
		if (cellEditorImplementation instanceof IModelCellEditor) {
			this.cellEditor = (IModelCellEditor) cellEditorImplementation;
		} else {
			throw new IllegalStateException("cell editor " + modelCellEditor //$NON-NLS-1$
					+ " doesn't implement " + IModelCellEditor.class.getSimpleName()); //$NON-NLS-1$
		}
	}

	@Override
	protected CellEditor getCellEditor(final Object element) {
		return new CellEditor((Composite) this.columnViewer.getControl()) {

			private Control control;

			@Override
			protected void doSetValue(final Object value) {
				//
			}

			@Override
			protected void doSetFocus() {
				this.control.setFocus();
			}

			@Override
			protected Object doGetValue() {
				return null;
			}

			@Override
			protected Control createControl(final Composite parent) {
				IModelCellEditHandler editHandler = new IModelCellEditHandler() {
					public void commit() {
						Object value = ModelCellsEditingSupport.this.cellEditor.getValue();
						List<?> list = (List<?>) ModelCellsEditingSupport.this.eObject
								.eGet(ModelCellsEditingSupport.this.feature);
						int index = list.indexOf(element);
						if (index != -1
								|| element == ModelCellsEditingSupport.this.newValuePlaceholder) {
							changeValue(element, value, index);
						}
						ModelCellsEditingSupport.this.columnViewer.refresh();
						// dispose();
						close();
					}
				};

				Object originalValue = null;
				if (element != ModelCellsEditingSupport.this.newValuePlaceholder) {
					originalValue = element;
				}

				this.control = ModelCellsEditingSupport.this.cellEditor.activateCell(parent,
						originalValue, editHandler, ModelCellsEditingSupport.this.feature,
						ModelCellsEditingSupport.this.eObject);
				return this.control;
			}

			public void close() {
				deactivate();
				Control parentControl = ModelCellsEditingSupport.this.columnViewer.getControl();
				if (parentControl != null && !parentControl.isDisposed()) {
					parentControl.forceFocus();
				}
				dispose();
				// if (this.control != null && !this.control.isDisposed()) {
				// this.control.dispose();
				// }
			}
		};
		// return new TextCellEditor();
	}

	@Override
	protected boolean canEdit(final Object element) {
		return true;
	}

	@Override
	protected Object getValue(final Object element) {
		return element;
	}

	@Override
	protected void setValue(final Object element, final Object value) {
		// TODO Auto-generated method stub
	}

	private void changeValue(final Object oldValue, final Object newValue, final int index) {
		ICommandFactory commandFactory = CommandFactoriesRegistry.getInstance()
				.getCommandFactoryFor(this.editingDomain);
		if (oldValue == this.newValuePlaceholder) {
			Command addCommand = commandFactory.createAddCommand(this.editingDomain, this.eObject,
					this.feature, newValue);
			this.editingDomain.getCommandStack().execute(addCommand);
		} else {
			Command setCommand = commandFactory.createSetCommand(this.editingDomain, this.eObject,
					this.feature, newValue, index);
			this.editingDomain.getCommandStack().execute(setCommand);
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2010 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Nicolas Bros (Mia-Software) - initial API and implementation
 *******************************************************************************/
package org.eclipse.emf.facet.widgets.celleditors.core;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.facet.widgets.celleditors.INaryFeatureCellEditor;
import org.eclipse.emf.facet.widgets.celleditors.ui.NaryAttributeEditingDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

public class NaryAttributeCellEditor implements INaryFeatureCellEditor {

	public Control activateCell(final Composite parent, final EStructuralFeature feature,
			final EObject source, final EditingDomain editingDomain) {
		final Composite placeholderComposite = new Composite(parent, SWT.NONE);
		NaryAttributeEditingDialog naryAttributeEditingDialog = new NaryAttributeEditingDialog(
				parent.getShell(), feature, source, editingDomain) {
			@Override
			public boolean close() {
				placeholderComposite.dispose();
				return super.close();
			}
		};
		naryAttributeEditingDialog.open();

		return placeholderComposite;
	}

	public Object getValue() {
		throw new UnsupportedOperationException();
	}

}




/*******************************************************************************
 * Copyright (c) 2010 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Nicolas Bros (Mia-Software) - initial API and implementation
 *******************************************************************************/
package org.eclipse.emf.facet.widgets.celleditors.ui;

import java.util.Collection;
import java.util.List;

import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.facet.widgets.celleditors.ICommandFactory;

public final class EditingUtils {
	private EditingUtils() {
		//
	}

	public static void moveElementsUp(final EObject eObject, final EStructuralFeature feature,
			final Collection<Object> elements, final ICommandFactory commandFactory,
			final EditingDomain editingDomain) {
		CompoundCommand compoundCommand = new CompoundCommand();

		List<?> list = (List<?>) eObject.eGet(feature);

		int minIndex = 0;
		for (Object element : elements) {
			final int index = list.indexOf(element);

			Command moveCommand = commandFactory.createMoveCommand(editingDomain, eObject, feature,
					element, Math.max(index - 1, minIndex++));
			compoundCommand.append(moveCommand);
		}
		editingDomain.getCommandStack().execute(compoundCommand);
		// int[] selectionIndices;
		// Arrays.sort(selectionIndices);
		// CompoundCommand compoundCommand = new CompoundCommand();
		// int minIndex = 0;
		// for(int index : selectionIndices) {
		// Command moveCommand = MoveCommand.create(editingDomain,
		// eObject,feature, index, Math.max(index - 1,
		// minIndex++));
		// compoundCommand.append(moveCommand);
		// }
		// editingDomain.getCommandStack().execute(compoundCommand);
	}

	public static void moveElementsDown(final EObject eObject, final EStructuralFeature feature,
			final Collection<Object> elements, final ICommandFactory commandFactory,
			final EditingDomain editingDomain) {
		Object value = eObject.eGet(feature);
		List<?> list = (List<?>) value;

		CompoundCommand compoundCommand = new CompoundCommand();

		// prevent the last two elements from swapping
		boolean canMove = !elements.contains(list.get(list.size() - 1));
		for (int i = list.size() - 2; i >= 0; i--) {
			final Object selectedObject = list.get(i);
			if (elements.contains(selectedObject)) {
				if (canMove) {
					Command moveCommand = commandFactory.createMoveCommand(editingDomain, eObject,
							feature, selectedObject, i + 1);
					compoundCommand.append(moveCommand);
				}
			} else {
				canMove = true;
			}

		}
		editingDomain.getCommandStack().execute(compoundCommand);
	}

}




/*******************************************************************************
 * Copyright (c) 2010 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Nicolas Bros (Mia-Software) - initial API and implementation
 *******************************************************************************/
package org.eclipse.emf.facet.widgets.celleditors.ui;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;

public class AssignableValuesContentProvider implements ITreeContentProvider {
	public Object[] getElements(final Object inputElement) {
		if (inputElement instanceof FeatureValuesInput) {
			FeatureValuesInput assignableValuesInput = (FeatureValuesInput) inputElement;
			EStructuralFeature feature = assignableValuesInput.getFeature();
			EClassifier eType = feature.getEType();
			EObject source = assignableValuesInput.getSource();
			List<?> featureValues = (List<?>) source.eGet(feature);

			// build a list of EObjects assignable to the EReference
			List<EObject> list = new ArrayList<EObject>();
			Resource eResource = source.eResource();
			if (eResource == null) {
				return new Object[0];
			}
			ResourceSet resourceSet = eResource.getResourceSet();
			TreeIterator<Notifier> allContents = resourceSet.getAllContents();
			while (allContents.hasNext()) {
				Notifier notifier = allContents.next();
				if (notifier instanceof EObject) {
					EObject eObject = (EObject) notifier;
					if (eType.isInstance(eObject)
							&& (!feature.isUnique() || !featureValues.contains(eObject))) {
						list.add(eObject);
					}
				}
			}
			return list.toArray();
		}
		throw new IllegalArgumentException(FeatureValuesInput.class.getSimpleName() + " expected"); //$NON-NLS-1$
	}

	public void dispose() {
		//
	}

	public void inputChanged(final Viewer viewer, final Object oldInput, final Object newInput) {
		//
	}

	public Object[] getChildren(final Object parentElement) {
		return null;
	}

	public Object getParent(final Object element) {
		return null;
	}

	public boolean hasChildren(final Object element) {
		return false;
	}
}




 *******************************************************************************/
package org.eclipse.emf.facet.widgets.celleditors.ui;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.util.TreeIterator;
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.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.facet.widgets.CustomizableLabelProvider;
import org.eclipse.emf.facet.widgets.celleditors.CommandFactoriesRegistry;

import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.ListViewer;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.TreeViewer;

/** A dialog to edit a multiplicity-many {@link EReference} */
public class NaryReferenceEditingDialog extends Dialog {

	private static final int AVAILABLE_VALUES_TREE_WIDTH = 200;
	private static final int AVAILABLE_VALUES_TREE_HEIGHT = 250;
	private static final int NUM_COLUMNS = 4;
	// this is a *tree* viewer because PatternFilter only supports Trees
	private TreeViewer fAvailableValuesTreeViewer;

	private AssignableValuesContentProvider assignableValuesContentProvider;
	private final ICommandFactory commandFactory;

	private class FeatureValuesInput {
		private final EStructuralFeature feature;
		private final EObject source;

		public FeatureValuesInput(final EStructuralFeature feature, final EObject source) {
			this.feature = feature;
			this.source = source;
		}

		public EStructuralFeature getFeature() {
			return this.feature;
		}

		public EObject getSource() {
			return this.source;
		}
	}

	private class AssignableValuesContentProvider implements ITreeContentProvider {
		public Object[] getElements(final Object inputElement) {
			if (inputElement instanceof FeatureValuesInput) {
				FeatureValuesInput assignableValuesInput = (FeatureValuesInput) inputElement;
				EStructuralFeature feature = assignableValuesInput.getFeature();
				EClassifier eType = feature.getEType();
				EObject source = assignableValuesInput.getSource();
				List<?> featureValues = (List<?>) source.eGet(feature);

				// build a list of EObjects assignable to the EReference
				List<EObject> list = new ArrayList<EObject>();
				Resource eResource = source.eResource();
				if (eResource == null) {
					return new Object[0];
				}
				ResourceSet resourceSet = eResource.getResourceSet();
				TreeIterator<Notifier> allContents = resourceSet.getAllContents();
				while (allContents.hasNext()) {
					Notifier notifier = allContents.next();
					if (notifier instanceof EObject) {
						EObject eObject = (EObject) notifier;
						if (eType.isInstance(eObject)
								&& (!feature.isUnique() || !featureValues.contains(eObject))) {
							list.add(eObject);
						}
					}
				}
				return list.toArray();
			}
			throw new IllegalArgumentException(
					NaryReferenceEditingDialog.FeatureValuesInput.class.getSimpleName()
							+ " expected"); //$NON-NLS-1$
		}

		public void dispose() {
			//
		}

		public void inputChanged(final Viewer viewer, final Object oldInput, final Object newInput) {
			//
		}

		public Object[] getChildren(final Object parentElement) {
			return null;
		}

		public Object getParent(final Object element) {
			return null;
		}

		public boolean hasChildren(final Object element) {
			return false;
		}
	}

	private class AssignedValuesContentProvider implements IStructuredContentProvider {
		public Object[] getElements(final Object inputElement) {
			if (inputElement instanceof FeatureValuesInput) {

				List<?> list = (List<?>) source.eGet(feature);
				return list.toArray();
			}
			throw new IllegalArgumentException(FeatureValuesInput.class.getSimpleName()
					+ " expected"); //$NON-NLS-1$
							+ " expected"); //$NON-NLS-1$
		}

		public void dispose() {


	@SuppressWarnings("unchecked")
	private void upButtonClicked() {

		// int[] selectionIndices =
		// this.fFeatureValuesListViewer.getList().getSelectionIndices();
		// Arrays.sort(selectionIndices);
		//
		// CompoundCommand compoundCommand = new CompoundCommand();
		//
		// int minIndex = 0;
		// for(int index : selectionIndices) {
		// Command moveCommand = MoveCommand.create(this.editingDomain,
		// this.fEObject, this.fFeature, index, Math.max(index - 1,
		// minIndex++));
		// compoundCommand.append(moveCommand);
		// }
		// this.fFeatureValuesListViewer.refresh();
		// this.editingDomain.getCommandStack().execute(compoundCommand);

		final IStructuredSelection selection = (IStructuredSelection) this.fFeatureValuesListViewer
				.getSelection();
		EditingUtils.moveElementsUp(this.fEObject, this.fFeature, selection.toList(),
				this.commandFactory, this.editingDomain);

		List<?> list = (List<?>) this.fEObject.eGet(this.fFeature);

		int minIndex = 0;
		for (final Iterator<EObject> it = selection.iterator(); it.hasNext();) {
			final EObject element = it.next();

			final int index = list.indexOf(element);

			Command moveCommand = this.commandFactory.createMoveCommand(this.editingDomain,
					this.fEObject, this.fFeature, element, Math.max(index - 1, minIndex++));
			compoundCommand.append(moveCommand);
		}
		this.editingDomain.getCommandStack().execute(compoundCommand);
		this.fFeatureValuesListViewer.refresh();
	}

	private void downButtonClicked() {
		final IStructuredSelection selection = (IStructuredSelection) this.fFeatureValuesListViewer
				.getSelection();
		EditingUtils.moveElementsDown(this.fEObject, this.fFeature, selection.toList(),
				this.commandFactory, this.editingDomain);
		this.fFeatureValuesListViewer.refresh();
		}

		Object value = this.fEObject.eGet(this.fFeature);
		if (value instanceof List<?>) {
			List<?> list = (List<?>) value;

			CompoundCommand compoundCommand = new CompoundCommand();

			// prevent the last two elements from swapping
			boolean canMove = !selectedObjects.contains(list.get(list.size() - 1));
			for (int i = list.size() - 2; i >= 0; i--) {
				final Object selectedEObject = list.get(i);
				if (selectedObjects.contains(selectedEObject)) {
					if (canMove) {
						Command moveCommand = this.commandFactory.createMoveCommand(
								this.editingDomain, this.fEObject, this.fFeature, selectedEObject,
								i + 1);
						compoundCommand.append(moveCommand);
					}
				} else {
					canMove = true;
				}

			}
			this.editingDomain.getCommandStack().execute(compoundCommand);
			this.fFeatureValuesListViewer.refresh();
		}
	}

	@SuppressWarnings("unchecked")


		final Tree availableValuesTree = new Tree(choiceComposite, SWT.MULTI | SWT.BORDER);
		final GridData availableValuesGridData = new GridData();
		availableValuesGridData.widthHint = NaryReferenceEditingDialog.AVAILABLE_VALUES_TREE_WIDTH;
		availableValuesGridData.heightHint = NaryReferenceEditingDialog.AVAILABLE_VALUES_TREE_HEIGHT;
		availableValuesGridData.horizontalAlignment = SWT.FILL;
		availableValuesGridData.verticalAlignment = SWT.FILL;
		availableValuesGridData.grabExcessHorizontalSpace = true;

		valuesLabelGridData.verticalAlignment = SWT.FILL;
		featureLabel.setLayoutData(valuesLabelGridData);

		final org.eclipse.swt.widgets.List availableValuesList = new org.eclipse.swt.widgets.List(
				featureComposite, SWT.MULTI | SWT.BORDER);
		final GridData availableValuesGridData = new GridData();
		availableValuesGridData.widthHint = NaryReferenceEditingDialog.AVAILABLE_VALUES_TREE_WIDTH;
		availableValuesGridData.heightHint = NaryReferenceEditingDialog.AVAILABLE_VALUES_TREE_HEIGHT;
		availableValuesGridData.verticalAlignment = SWT.FILL;
		availableValuesGridData.horizontalAlignment = SWT.FILL;
		availableValuesGridData.grabExcessHorizontalSpace = true;
		availableValuesGridData.grabExcessVerticalSpace = true;
		availableValuesList.setLayoutData(availableValuesGridData);

		this.fFeatureValuesListViewer = new ListViewer(availableValuesList);
		this.fFeatureValuesListViewer.setContentProvider(new AssignedValuesContentProvider());
		this.fFeatureValuesListViewer.setLabelProvider(new CustomizableLabelProvider());
		this.fFeatureValuesListViewer

Lines 33-38 Link Here

(-)src/org/eclipse/emf/facet/widgets/celleditors/ICommandFactory.java (+7 lines)
33	Command createSetCommand(EditingDomain domain, final Object owner, Object feature, Object value);	33	Command createSetCommand(EditingDomain domain, final Object owner, Object feature, Object value);
34		34
35	/**	35	/**
		36	* This creates a {@link SetCommand} to set the owner's feature to the
		37	* specified value at the specified index.
		38	*/
		39	Command createSetCommand(EditingDomain domain, final Object owner, Object feature,
		40	Object value, int index);
		41
		42	/**
36	* This creates a {@link MoveCommand} to move a particular value to a	43	* This creates a {@link MoveCommand} to move a particular value to a
37	* particular index in the specified feature of the owner. The feature will	44	* particular index in the specified feature of the owner. The feature will
38	* often be <code>null</code> because the domain will deduce it.	45	* often be <code>null</code> because the domain will deduce it.

Lines 151-157 Link Here

(-)src/org/eclipse/emf/facet/widgets/celleditors/modelCellEditor/impl/BasicCellEditorImpl.java (-1 / +2 lines)
151	switch (featureID) {	151	switch (featureID) {
152	case ModelCellEditorPackage.BASIC_CELL_EDITOR__BASIC_CELL_EDITOR_IMPL:	152	case ModelCellEditorPackage.BASIC_CELL_EDITOR__BASIC_CELL_EDITOR_IMPL:
153	return BasicCellEditorImpl.BASIC_CELL_EDITOR_IMPL_EDEFAULT == null ? this.basicCellEditorImpl != null	153	return BasicCellEditorImpl.BASIC_CELL_EDITOR_IMPL_EDEFAULT == null ? this.basicCellEditorImpl != null
154	: !BasicCellEditorImpl.BASIC_CELL_EDITOR_IMPL_EDEFAULT.equals(this.basicCellEditorImpl);	154	: !BasicCellEditorImpl.BASIC_CELL_EDITOR_IMPL_EDEFAULT
		155	.equals(this.basicCellEditorImpl);
155	}	156	}
156	return super.eIsSet(featureID);	157	return super.eIsSet(featureID);
157	}	158	}

Lines 6-9 Link Here

(-)org.eclipse.emf.facet.widgets.celleditors.core.modelcelleditors (+3 lines)
6	<modelCellEditors xsi:type="modelCellEditor:NaryFeatureCellEditor" cellId="naryref_cell" naryFeatureCellEditorImpl="org.eclipse.emf.facet.widgets.celleditors.core.NaryReferenceCellEditor">	6	<modelCellEditors xsi:type="modelCellEditor:NaryFeatureCellEditor" cellId="naryref_cell" naryFeatureCellEditorImpl="org.eclipse.emf.facet.widgets.celleditors.core.NaryReferenceCellEditor">
7	<cellType xsi:type="ecore:EClass" href="http://www.eclipse.org/emf/2002/Ecore#//EObject"/>	7	<cellType xsi:type="ecore:EClass" href="http://www.eclipse.org/emf/2002/Ecore#//EObject"/>
8	</modelCellEditors>	8	</modelCellEditors>
		9	<modelCellEditors xsi:type="modelCellEditor:NaryFeatureCellEditor" cellId="naryattr_cell" naryFeatureCellEditorImpl="org.eclipse.emf.facet.widgets.celleditors.core.NaryAttributeCellEditor">
		10	<cellType xsi:type="ecore:EClass" href="http://www.eclipse.org/emf/2002/Ecore#//EDataType"/>
		11	</modelCellEditors>
9	</modelCellEditor:ModelCellEditorDeclarations>	12	</modelCellEditor:ModelCellEditorDeclarations>

Lines 15-20 Link Here

(-)src/org/eclipse/emf/facet/widgets/celleditors/Messages.java (+3 lines)
15		15
16	public final class Messages extends NLS {	16	public final class Messages extends NLS {
17	private static final String BUNDLE_NAME = "org.eclipse.emf.facet.widgets.celleditors.messages"; //$NON-NLS-1$	17	private static final String BUNDLE_NAME = "org.eclipse.emf.facet.widgets.celleditors.messages"; //$NON-NLS-1$
		18	public static String NaryAttributeEditingDialog_add;
		19	public static String NaryAttributeEditingDialog_delete;
		20	public static String NaryAttributeEditingDialog_enterNewValuePlaceholder;
18	public static String NaryReferenceEditingDialog_add;	21	public static String NaryReferenceEditingDialog_add;
19	public static String NaryReferenceEditingDialog_addAll;	22	public static String NaryReferenceEditingDialog_addAll;
20	public static String NaryReferenceEditingDialog_addAllTooltip;	23	public static String NaryReferenceEditingDialog_addAllTooltip;




		this.cellId = newCellId;
		if (eNotificationRequired()) {
			eNotify(new ENotificationImpl(this, Notification.SET,
					ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_ID, oldCellId,
					this.cellId));
		}
	}


		case ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_TYPE:
			return this.cellType != null;
		case ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_ID:
			return AbstractModelCellEditorImpl.CELL_ID_EDEFAULT == null ? this.cellId != null
					: !AbstractModelCellEditorImpl.CELL_ID_EDEFAULT.equals(this.cellId);
		}
		return super.eIsSet(featureID);
	}




/*******************************************************************************
 * Copyright (c) 2010 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Nicolas Bros (Mia-Software) - initial API and implementation
 *******************************************************************************/
package org.eclipse.emf.facet.widgets.celleditors.ui;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;

public class FeatureValuesInput {
	private final EStructuralFeature feature;
	private final EObject source;

	public FeatureValuesInput(final EStructuralFeature feature, final EObject source) {
		this.feature = feature;
		this.source = source;
	}

	public EStructuralFeature getFeature() {
		return this.feature;
	}

	public EObject getSource() {
		return this.source;
	}
}




NaryAttributeEditingDialog_delete=D&elete
NaryAttributeEditingDialog_enterNewValuePlaceholder=<enter new value>
###############################################################################
# Copyright (c) 2010 CEA
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Eclipse Public License v1.0
# which accompanies this distribution, and is available at
# http://www.eclipse.org/legal/epl-v10.html
#
# Contributors:
#   Nicolas Bros (Mia-Software) - initial API and implementation
###############################################################################
NaryAttributeEditingDialog_add=&Add
NaryReferenceEditingDialog_addAll=>>
NaryReferenceEditingDialog_addAllTooltip=Add all
NaryReferenceEditingDialog_addTooltip=Add
NaryReferenceEditingDialog_availableValues=Available values
NaryReferenceEditingDialog_deleteElements=Delete elements?
NaryReferenceEditingDialog_deleteElementsLong=Since the feature is composite, this will delete the selected element(s) from the model.
NaryReferenceEditingDialog_down=&Down
NaryReferenceEditingDialog_featureIsComposite=The feature is composite. 
NaryReferenceEditingDialog_moveElement=Move element?
NaryReferenceEditingDialog_remove=&<
NaryReferenceEditingDialog_removeAll=<<
NaryReferenceEditingDialog_removeAllTooltip=Remove all
NaryReferenceEditingDialog_removeTooltip=Remove
NaryReferenceEditingDialog_shellTitle=Edit {0} of {1}
NaryReferenceEditingDialog_typeFilterText=type filter text
NaryReferenceEditingDialog_up=&Up
NaryReferenceEditingDialog_values=Values
NaryReferenceEditingDialog_valueWillBeMoved=The selected value will be moved from its previous parent.
NaryReferenceEditingDialog_valueWillBeMovedAndPreviousLost=The selected value will be moved from its previous parent and the previous value will be lost.
NaryReferenceEditingDialog_add=&>
# Copyright (c) 2010 CEA
#
#   Contributors:
#     Nicolas Bros (Mia-Software) - initial API and implementation
###############################################################################
NaryReferenceEditingDialog_add=>
UnaryReferenceCellEditorComposite_0=Invalid selection
UnaryReferenceCellEditorComposite_1=Please select an EObject
UnaryReferenceCellEditorComposite_2=Select an EObject

Lines 269-282 Link Here

(-)src/org/eclipse/emf/facet/widgets/celleditors/modelCellEditor/impl/ModelCellEditorPackageImpl.java (-23 / +50 lines)
269	ModelCellEditorPackage.MODEL_CELL_EDITOR_DECLARATIONS__MODEL_CELL_EDITORS);	269	ModelCellEditorPackage.MODEL_CELL_EDITOR_DECLARATIONS__MODEL_CELL_EDITORS);
270		270
271	this.abstractModelCellEditorEClass = createEClass(ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR);	271	this.abstractModelCellEditorEClass = createEClass(ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR);
272	createEReference(this.abstractModelCellEditorEClass, ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_TYPE);	272	createEReference(this.abstractModelCellEditorEClass,
273	createEAttribute(this.abstractModelCellEditorEClass, ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_ID);	273	ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_TYPE);
		274	createEAttribute(this.abstractModelCellEditorEClass,
		275	ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_ID);
274		276
275	this.basicCellEditorEClass = createEClass(ModelCellEditorPackage.BASIC_CELL_EDITOR);	277	this.basicCellEditorEClass = createEClass(ModelCellEditorPackage.BASIC_CELL_EDITOR);
276	createEAttribute(this.basicCellEditorEClass, ModelCellEditorPackage.BASIC_CELL_EDITOR__BASIC_CELL_EDITOR_IMPL);	278	createEAttribute(this.basicCellEditorEClass,
		279	ModelCellEditorPackage.BASIC_CELL_EDITOR__BASIC_CELL_EDITOR_IMPL);
277		280
278	this.unaryReferenceCellEditorEClass = createEClass(ModelCellEditorPackage.UNARY_REFERENCE_CELL_EDITOR);	281	this.unaryReferenceCellEditorEClass = createEClass(ModelCellEditorPackage.UNARY_REFERENCE_CELL_EDITOR);
279	createEAttribute(this.unaryReferenceCellEditorEClass,	282	createEAttribute(
		283	this.unaryReferenceCellEditorEClass,
280	ModelCellEditorPackage.UNARY_REFERENCE_CELL_EDITOR__UNARY_REFERENCE_CELL_EDITOR_IMPL);	284	ModelCellEditorPackage.UNARY_REFERENCE_CELL_EDITOR__UNARY_REFERENCE_CELL_EDITOR_IMPL);
281		285
282	this.naryFeatureCellEditorEClass = createEClass(ModelCellEditorPackage.NARY_FEATURE_CELL_EDITOR);	286	this.naryFeatureCellEditorEClass = createEClass(ModelCellEditorPackage.NARY_FEATURE_CELL_EDITOR);
Lines 319-351 Link Here
319	this.naryFeatureCellEditorEClass.getESuperTypes().add(getAbstractModelCellEditor());	323	this.naryFeatureCellEditorEClass.getESuperTypes().add(getAbstractModelCellEditor());
320		324
321	// Initialize classes and features; add operations and parameters	325	// Initialize classes and features; add operations and parameters
322	initEClass(this.modelCellEditorDeclarationsEClass, ModelCellEditorDeclarations.class,	326	initEClass(
		327	this.modelCellEditorDeclarationsEClass,
		328	ModelCellEditorDeclarations.class,
323	"ModelCellEditorDeclarations", !EPackageImpl.IS_ABSTRACT, !EPackageImpl.IS_INTERFACE, //$NON-NLS-1$	329	"ModelCellEditorDeclarations", !EPackageImpl.IS_ABSTRACT, !EPackageImpl.IS_INTERFACE, //$NON-NLS-1$
324	EPackageImpl.IS_GENERATED_INSTANCE_CLASS);	330	EPackageImpl.IS_GENERATED_INSTANCE_CLASS);
325	initEReference(getModelCellEditorDeclarations_ModelCellEditors(),	331	initEReference(getModelCellEditorDeclarations_ModelCellEditors(),
326	getAbstractModelCellEditor(), null, "modelCellEditors", null, 0, -1, //$NON-NLS-1$	332	getAbstractModelCellEditor(), null, "modelCellEditors", null, 0, -1, //$NON-NLS-1$
327	ModelCellEditorDeclarations.class, !EPackageImpl.IS_TRANSIENT, !EPackageImpl.IS_VOLATILE, EPackageImpl.IS_CHANGEABLE,	333	ModelCellEditorDeclarations.class, !EPackageImpl.IS_TRANSIENT,
328	EPackageImpl.IS_COMPOSITE, !EPackageImpl.IS_RESOLVE_PROXIES, !EPackageImpl.IS_UNSETTABLE, EPackageImpl.IS_UNIQUE, !EPackageImpl.IS_DERIVED,	334	!EPackageImpl.IS_VOLATILE, EPackageImpl.IS_CHANGEABLE, EPackageImpl.IS_COMPOSITE,
329	EPackageImpl.IS_ORDERED);	335	!EPackageImpl.IS_RESOLVE_PROXIES, !EPackageImpl.IS_UNSETTABLE,
		336	EPackageImpl.IS_UNIQUE, !EPackageImpl.IS_DERIVED, EPackageImpl.IS_ORDERED);
330		337
331	initEClass(this.abstractModelCellEditorEClass, AbstractModelCellEditor.class,	338	initEClass(
		339	this.abstractModelCellEditorEClass,
		340	AbstractModelCellEditor.class,
332	"AbstractModelCellEditor", EPackageImpl.IS_ABSTRACT, !EPackageImpl.IS_INTERFACE, EPackageImpl.IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$	341	"AbstractModelCellEditor", EPackageImpl.IS_ABSTRACT, !EPackageImpl.IS_INTERFACE, EPackageImpl.IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
333	initEReference(getAbstractModelCellEditor_CellType(), this.ecorePackage.getEClassifier(), null,	342	initEReference(
		343	getAbstractModelCellEditor_CellType(),
		344	this.ecorePackage.getEClassifier(),
		345	null,
334	"cellType", null, 1, 1, AbstractModelCellEditor.class, !EPackageImpl.IS_TRANSIENT, !EPackageImpl.IS_VOLATILE, //$NON-NLS-1$	346	"cellType", null, 1, 1, AbstractModelCellEditor.class, !EPackageImpl.IS_TRANSIENT, !EPackageImpl.IS_VOLATILE, //$NON-NLS-1$
335	EPackageImpl.IS_CHANGEABLE, !EPackageImpl.IS_COMPOSITE, EPackageImpl.IS_RESOLVE_PROXIES, !EPackageImpl.IS_UNSETTABLE, EPackageImpl.IS_UNIQUE,	347	EPackageImpl.IS_CHANGEABLE, !EPackageImpl.IS_COMPOSITE,
336	!EPackageImpl.IS_DERIVED, EPackageImpl.IS_ORDERED);	348	EPackageImpl.IS_RESOLVE_PROXIES, !EPackageImpl.IS_UNSETTABLE,
337	initEAttribute(getAbstractModelCellEditor_CellId(), this.ecorePackage.getEString(), "cellId", //$NON-NLS-1$	349	EPackageImpl.IS_UNIQUE, !EPackageImpl.IS_DERIVED, EPackageImpl.IS_ORDERED);
338	null, 1, 1, AbstractModelCellEditor.class, !EPackageImpl.IS_TRANSIENT, !EPackageImpl.IS_VOLATILE,	350	initEAttribute(
339	EPackageImpl.IS_CHANGEABLE, !EPackageImpl.IS_UNSETTABLE, !EPackageImpl.IS_ID, EPackageImpl.IS_UNIQUE, !EPackageImpl.IS_DERIVED, EPackageImpl.IS_ORDERED);	351	getAbstractModelCellEditor_CellId(),
		352	this.ecorePackage.getEString(),
		353	"cellId", //$NON-NLS-1$
		354	null, 1, 1, AbstractModelCellEditor.class, !EPackageImpl.IS_TRANSIENT,
		355	!EPackageImpl.IS_VOLATILE, EPackageImpl.IS_CHANGEABLE, !EPackageImpl.IS_UNSETTABLE,
		356	!EPackageImpl.IS_ID, EPackageImpl.IS_UNIQUE, !EPackageImpl.IS_DERIVED,
		357	EPackageImpl.IS_ORDERED);
340		358
341	addEOperation(this.abstractModelCellEditorEClass, this.ecorePackage.getEString(),	359	addEOperation(this.abstractModelCellEditorEClass, this.ecorePackage.getEString(),
342	"getModelCellEditorImpl", 1, 1, EPackageImpl.IS_UNIQUE, EPackageImpl.IS_ORDERED); //$NON-NLS-1$	360	"getModelCellEditorImpl", 1, 1, EPackageImpl.IS_UNIQUE, EPackageImpl.IS_ORDERED); //$NON-NLS-1$
343		361
344	initEClass(this.basicCellEditorEClass, BasicCellEditor.class, "BasicCellEditor", !EPackageImpl.IS_ABSTRACT, //$NON-NLS-1$	362	initEClass(this.basicCellEditorEClass, BasicCellEditor.class,
		363	"BasicCellEditor", !EPackageImpl.IS_ABSTRACT, //$NON-NLS-1$
345	!EPackageImpl.IS_INTERFACE, EPackageImpl.IS_GENERATED_INSTANCE_CLASS);	364	!EPackageImpl.IS_INTERFACE, EPackageImpl.IS_GENERATED_INSTANCE_CLASS);
346	initEAttribute(getBasicCellEditor_BasicCellEditorImpl(), this.ecorePackage.getEString(),	365	initEAttribute(
		366	getBasicCellEditor_BasicCellEditorImpl(),
		367	this.ecorePackage.getEString(),
347	"basicCellEditorImpl", null, 1, 1, BasicCellEditor.class, !EPackageImpl.IS_TRANSIENT, //$NON-NLS-1$	368	"basicCellEditorImpl", null, 1, 1, BasicCellEditor.class, !EPackageImpl.IS_TRANSIENT, //$NON-NLS-1$
348	!EPackageImpl.IS_VOLATILE, EPackageImpl.IS_CHANGEABLE, !EPackageImpl.IS_UNSETTABLE, !EPackageImpl.IS_ID, EPackageImpl.IS_UNIQUE, !EPackageImpl.IS_DERIVED,	369	!EPackageImpl.IS_VOLATILE, EPackageImpl.IS_CHANGEABLE, !EPackageImpl.IS_UNSETTABLE,
		370	!EPackageImpl.IS_ID, EPackageImpl.IS_UNIQUE, !EPackageImpl.IS_DERIVED,
349	EPackageImpl.IS_ORDERED);	371	EPackageImpl.IS_ORDERED);
350		372
351	initEClass(this.unaryReferenceCellEditorEClass, UnaryReferenceCellEditor.class,	373	initEClass(this.unaryReferenceCellEditorEClass, UnaryReferenceCellEditor.class,
Lines 353-367 Link Here
353	EPackageImpl.IS_GENERATED_INSTANCE_CLASS);	375	EPackageImpl.IS_GENERATED_INSTANCE_CLASS);
354	initEAttribute(getUnaryReferenceCellEditor_UnaryReferenceCellEditorImpl(),	376	initEAttribute(getUnaryReferenceCellEditor_UnaryReferenceCellEditorImpl(),
355	this.ecorePackage.getEString(), "unaryReferenceCellEditorImpl", null, 1, 1, //$NON-NLS-1$	377	this.ecorePackage.getEString(), "unaryReferenceCellEditorImpl", null, 1, 1, //$NON-NLS-1$
356	UnaryReferenceCellEditor.class, !EPackageImpl.IS_TRANSIENT, !EPackageImpl.IS_VOLATILE, EPackageImpl.IS_CHANGEABLE,	378	UnaryReferenceCellEditor.class, !EPackageImpl.IS_TRANSIENT,
357	!EPackageImpl.IS_UNSETTABLE, !EPackageImpl.IS_ID, EPackageImpl.IS_UNIQUE, !EPackageImpl.IS_DERIVED, EPackageImpl.IS_ORDERED);	379	!EPackageImpl.IS_VOLATILE, EPackageImpl.IS_CHANGEABLE, !EPackageImpl.IS_UNSETTABLE,
		380	!EPackageImpl.IS_ID, EPackageImpl.IS_UNIQUE, !EPackageImpl.IS_DERIVED,
		381	EPackageImpl.IS_ORDERED);
358		382
359	initEClass(this.naryFeatureCellEditorEClass, NaryFeatureCellEditor.class,	383	initEClass(
		384	this.naryFeatureCellEditorEClass,
		385	NaryFeatureCellEditor.class,
360	"NaryFeatureCellEditor", !EPackageImpl.IS_ABSTRACT, !EPackageImpl.IS_INTERFACE, EPackageImpl.IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$	386	"NaryFeatureCellEditor", !EPackageImpl.IS_ABSTRACT, !EPackageImpl.IS_INTERFACE, EPackageImpl.IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
361	initEAttribute(getNaryFeatureCellEditor_NaryFeatureCellEditorImpl(),	387	initEAttribute(getNaryFeatureCellEditor_NaryFeatureCellEditorImpl(),
362	this.ecorePackage.getEString(), "naryFeatureCellEditorImpl", null, 1, 1, //$NON-NLS-1$	388	this.ecorePackage.getEString(), "naryFeatureCellEditorImpl", null, 1, 1, //$NON-NLS-1$
363	NaryFeatureCellEditor.class, !EPackageImpl.IS_TRANSIENT, !EPackageImpl.IS_VOLATILE, EPackageImpl.IS_CHANGEABLE,	389	NaryFeatureCellEditor.class, !EPackageImpl.IS_TRANSIENT, !EPackageImpl.IS_VOLATILE,
364	!EPackageImpl.IS_UNSETTABLE, !EPackageImpl.IS_ID, EPackageImpl.IS_UNIQUE, !EPackageImpl.IS_DERIVED, EPackageImpl.IS_ORDERED);	390	EPackageImpl.IS_CHANGEABLE, !EPackageImpl.IS_UNSETTABLE, !EPackageImpl.IS_ID,
		391	EPackageImpl.IS_UNIQUE, !EPackageImpl.IS_DERIVED, EPackageImpl.IS_ORDERED);
365		392
366	// Create resource	393	// Create resource
367	createResource(ModelCellEditorPackage.eNS_URI);	394	createResource(ModelCellEditorPackage.eNS_URI);




		 * @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getModelCellEditorDeclarations()
		 * @generated
		 */
		EClass MODEL_CELL_EDITOR_DECLARATIONS = ModelCellEditorPackage.eINSTANCE
				.getModelCellEditorDeclarations();

		/**
		 * The meta object literal for the '<em><b>Model Cell Editors</b></em>'

		 * @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getAbstractModelCellEditor()
		 * @generated
		 */
		EClass ABSTRACT_MODEL_CELL_EDITOR = ModelCellEditorPackage.eINSTANCE
				.getAbstractModelCellEditor();

		/**
		 * The meta object literal for the '<em><b>Cell Type</b></em>' reference

		 * @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getUnaryReferenceCellEditor()
		 * @generated
		 */
		EClass UNARY_REFERENCE_CELL_EDITOR = ModelCellEditorPackage.eINSTANCE
				.getUnaryReferenceCellEditor();

		/**
		 * The meta object literal for the '

		 * @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getNaryFeatureCellEditor()
		 * @generated
		 */
		EClass NARY_FEATURE_CELL_EDITOR = ModelCellEditorPackage.eINSTANCE
				.getNaryFeatureCellEditor();

		/**
		 * The meta object literal for the '




/*******************************************************************************
 * Copyright (c) 2010 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Nicolas Bros (Mia-Software) - initial API and implementation
 *******************************************************************************/
package org.eclipse.emf.facet.widgets.celleditors.ui;

import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EDataType;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.facet.widgets.CustomizableLabelProvider;
import org.eclipse.emf.facet.widgets.celleditors.CommandFactoriesRegistry;
import org.eclipse.emf.facet.widgets.celleditors.ICommandFactory;
import org.eclipse.emf.facet.widgets.celleditors.Messages;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TableViewerColumn;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;

/** A dialog to edit a multiplicity-many {@link EAttribute} */
public class NaryAttributeEditingDialog extends Dialog {

	private static final int LIST_WIDTH = 200;
	private static final int LIST_HEIGHT = 250;
	private static final int NUM_COLUMNS = 2;
	private TableViewer fFeatureValuesTableViewer;
	private Button fAddButton;
	private Button fRemoveButton;
	private Button fUpButton;
	private Button fDownButton;
	private final EStructuralFeature fFeature;
	private final EObject fEObject;
	private final EditingDomain editingDomain;
	private final ICommandFactory commandFactory;

	private boolean bAddingValue = false;

	public boolean isAddingValue() {
		return this.bAddingValue;
	}

	private final Object newValuePlaceholder = new Object();

	private class AssignedValuesContentProvider implements IStructuredContentProvider {
		public Object[] getElements(final Object inputElement) {
			if (inputElement instanceof FeatureValuesInput) {
				FeatureValuesInput valuesInput = (FeatureValuesInput) inputElement;
				EStructuralFeature feature = valuesInput.getFeature();
				EObject source = valuesInput.getSource();
				List<?> list = (List<?>) source.eGet(feature);
				// add a temporary cell when editing
				if (isAddingValue()) {
					Object[] result = new Object[list.size() + 1];
					int i = 0;
					for (Object object : list) {
						result[i++] = object;
					}
					result[i] = NaryAttributeEditingDialog.this.newValuePlaceholder;
					return result;
				}
				return list.toArray();
			}
			throw new IllegalArgumentException(FeatureValuesInput.class.getSimpleName()
					+ " expected"); //$NON-NLS-1$
		}

		public void dispose() {
			//
		}

		public void inputChanged(final Viewer viewer, final Object oldInput, final Object newInput) {
			//
		}
	}

	private final ColumnLabelProvider labelProvider = new ColumnLabelProvider() {
		private final LabelProvider delegateLabelProvider = new CustomizableLabelProvider();

		@Override
		public Image getImage(final Object element) {
			return this.delegateLabelProvider.getImage(element);
		}

		@Override
		public String getText(final Object element) {
			if (element == NaryAttributeEditingDialog.this.newValuePlaceholder) {
				return Messages.NaryAttributeEditingDialog_enterNewValuePlaceholder;
			}
			return this.delegateLabelProvider.getText(element);
		}

		@Override
		public Color getForeground(final Object element) {
			if (element == NaryAttributeEditingDialog.this.newValuePlaceholder) {
				return Display.getDefault().getSystemColor(SWT.COLOR_DARK_GRAY);
			}
			return null;
		}
	};

	/**
	 * @param parent
	 *            the parent {@link Shell}
	 * @param feature
	 *            the feature to edit
	 * @param eObject
	 *            the {@link EObject} on which the feature must be edited
	 * @param editingDomain
	 *            the {@link EditingDomain} through which all editing is done
	 */
	public NaryAttributeEditingDialog(final Shell parent, final EStructuralFeature feature,
			final EObject eObject, final EditingDomain editingDomain) {
		super(parent);
		if (!(feature.getEType() instanceof EDataType)) {
			throw new IllegalArgumentException("feature type must be EDataType"); //$NON-NLS-1$
		}

		this.fFeature = feature;
		this.fEObject = eObject;
		this.editingDomain = editingDomain;
		this.commandFactory = CommandFactoriesRegistry.getInstance().getCommandFactoryFor(
				this.editingDomain);
	}

	@Override
	protected void configureShell(final Shell shell) {
		super.configureShell(shell);
		shell.setText(NLS.bind(Messages.NaryReferenceEditingDialog_shellTitle,
				this.fFeature.getName(), this.fEObject.eClass().getName()));
		// prevent Escape or Enter from closing the dialog
		// when a cell editor is active
		shell.addListener(SWT.Traverse, new Listener() {
			public void handleEvent(final Event e) {
				if ((e.detail == SWT.TRAVERSE_ESCAPE || e.detail == SWT.TRAVERSE_RETURN)
						&& NaryAttributeEditingDialog.this.fFeatureValuesTableViewer
								.isCellEditorActive()) {
					e.doit = false;
				}
			}
		});
	}

	@Override
	protected Control createDialogArea(final Composite parent) {
		final Composite contents = (Composite) super.createDialogArea(parent);

		final GridLayout contentsGridLayout = (GridLayout) contents.getLayout();
		contentsGridLayout.numColumns = NaryAttributeEditingDialog.NUM_COLUMNS;

		final GridData contentsGridData = (GridData) contents.getLayoutData();
		contentsGridData.horizontalAlignment = SWT.FILL;
		contentsGridData.verticalAlignment = SWT.FILL;

		createValuesPane(contents);
		createButtonsPane(contents);

		// this.fFeatureValuesTableViewer.addOpenListener(new IOpenListener() {
		// public void open(final OpenEvent event) {
		// editSelectedElement();
		// }
		// });

		this.fUpButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(final SelectionEvent event) {
				upButtonClicked();
			}
		});

		this.fDownButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(final SelectionEvent event) {
				downButtonClicked();
			}
		});

		this.fAddButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(final SelectionEvent event) {
				addButtonClicked();
			}
		});

		this.fRemoveButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(final SelectionEvent event) {
				removeButtonClicked();
			}
		});

		return contents;
	}

	@SuppressWarnings("unchecked")
	private void upButtonClicked() {
		final IStructuredSelection selection = (IStructuredSelection) this.fFeatureValuesTableViewer
				.getSelection();

		EditingUtils.moveElementsUp(this.fEObject, this.fFeature, selection.toList(),
				this.commandFactory, this.editingDomain);

		this.fFeatureValuesTableViewer.refresh();
	}

	@SuppressWarnings("unchecked")
	private void downButtonClicked() {
		final IStructuredSelection selection = (IStructuredSelection) this.fFeatureValuesTableViewer
				.getSelection();

		EditingUtils.moveElementsDown(this.fEObject, this.fFeature, selection.toList(),
				this.commandFactory, this.editingDomain);

		this.fFeatureValuesTableViewer.refresh();
	}

	private void addButtonClicked() {
		this.bAddingValue = true;
		// EDataType dataType = (EDataType) this.fFeature.getEType();
		// Object defaultValue = dataType.getDefaultValue();
		// if (dataType == EcorePackage.eINSTANCE.getEString()) {
		// defaultValue = "";
		// }
		// Command addCommand =
		// this.commandFactory.createAddCommand(this.editingDomain,
		// this.fEObject, this.fFeature, defaultValue);
		// this.editingDomain.getCommandStack().execute(addCommand);
		refresh();
		// this.fFeatureValuesTableViewer.setSelection(new
		// StructuredSelection(this.tempCellForNewValue),
		// true);
		this.fFeatureValuesTableViewer.editElement(this.newValuePlaceholder, 0);
	}

	@SuppressWarnings("unchecked")
	private void removeButtonClicked() {
		final IStructuredSelection selection = (IStructuredSelection) this.fFeatureValuesTableViewer
				.getSelection();

		CompoundCommand compoundCommand = new CompoundCommand();

		List<?> list = (List<?>) this.fEObject.eGet(this.fFeature);

		for (final Iterator<Object> it = selection.iterator(); it.hasNext();) {
			final Object element = it.next();

			if (list.contains(element)) {
				Command removeCommand = this.commandFactory.createRemoveCommand(this.editingDomain,
						this.fEObject, this.fFeature, element);
				compoundCommand.append(removeCommand);
			}
		}
		this.editingDomain.getCommandStack().execute(compoundCommand);
		refresh();
	}

	private void spacer(final Composite parent) {
		@SuppressWarnings("unused")
		Label label = new Label(parent, SWT.NONE);
	}

	private void createButtonsPane(final Composite contents) {
		final Composite buttonsComposite = new Composite(contents, SWT.NONE);
		final GridData buttonsCompositeGridData = new GridData();
		buttonsCompositeGridData.verticalAlignment = SWT.FILL;
		buttonsCompositeGridData.horizontalAlignment = SWT.FILL;
		buttonsComposite.setLayoutData(buttonsCompositeGridData);
		buttonsComposite.setLayout(new GridLayout());

		// spacer
		spacer(buttonsComposite);

		this.fAddButton = new Button(buttonsComposite, SWT.PUSH);
		this.fAddButton.setText(Messages.NaryAttributeEditingDialog_add);
		final GridData addButtonGridData = new GridData();
		addButtonGridData.verticalAlignment = SWT.FILL;
		addButtonGridData.horizontalAlignment = SWT.FILL;
		// addButtonGridData.widthHint = 70;
		this.fAddButton.setLayoutData(addButtonGridData);

		this.fRemoveButton = new Button(buttonsComposite, SWT.PUSH);
		this.fRemoveButton.setText(Messages.NaryAttributeEditingDialog_delete);
		final GridData removeButtonGridData = new GridData();
		removeButtonGridData.verticalAlignment = SWT.FILL;
		removeButtonGridData.horizontalAlignment = SWT.FILL;
		this.fRemoveButton.setLayoutData(removeButtonGridData);

		spacer(buttonsComposite);

		this.fUpButton = new Button(buttonsComposite, SWT.PUSH);
		this.fUpButton.setText(Messages.NaryReferenceEditingDialog_up);
		final GridData upButtonGridData = new GridData();
		upButtonGridData.verticalAlignment = SWT.FILL;
		upButtonGridData.horizontalAlignment = SWT.FILL;
		this.fUpButton.setLayoutData(upButtonGridData);

		this.fDownButton = new Button(buttonsComposite, SWT.PUSH);
		this.fDownButton.setText(Messages.NaryReferenceEditingDialog_down);
		final GridData downButtonGridData = new GridData();
		downButtonGridData.verticalAlignment = SWT.FILL;
		downButtonGridData.horizontalAlignment = SWT.FILL;
		this.fDownButton.setLayoutData(downButtonGridData);
	}

	private void createValuesPane(final Composite contents) {
		final Composite featureComposite = new Composite(contents, SWT.NONE);
		final GridData featureCompositeData = new GridData(SWT.FILL, SWT.FILL, true, true);
		featureCompositeData.horizontalAlignment = SWT.END;
		featureComposite.setLayoutData(featureCompositeData);

		final GridLayout featureCompositeLayout = new GridLayout();
		featureCompositeData.horizontalAlignment = SWT.FILL;
		featureCompositeLayout.marginHeight = 0;
		featureCompositeLayout.marginWidth = 0;
		featureCompositeLayout.numColumns = 1;
		featureComposite.setLayout(featureCompositeLayout);

		final Label featureLabel = new Label(featureComposite, SWT.NONE);
		featureLabel.setText(Messages.NaryReferenceEditingDialog_values);
		final GridData valuesLabelGridData = new GridData();
		valuesLabelGridData.horizontalSpan = 2;
		valuesLabelGridData.horizontalAlignment = SWT.FILL;
		valuesLabelGridData.verticalAlignment = SWT.FILL;
		featureLabel.setLayoutData(valuesLabelGridData);

		final Table table = new Table(featureComposite, SWT.MULTI | SWT.BORDER | SWT.FULL_SELECTION);
		final GridData tableGridData = new GridData();
		tableGridData.widthHint = NaryAttributeEditingDialog.LIST_WIDTH;
		tableGridData.heightHint = NaryAttributeEditingDialog.LIST_HEIGHT;
		tableGridData.verticalAlignment = SWT.FILL;
		tableGridData.horizontalAlignment = SWT.FILL;
		tableGridData.grabExcessHorizontalSpace = true;
		tableGridData.grabExcessVerticalSpace = true;
		table.setLayoutData(tableGridData);
		final TableColumn tableColumn = new TableColumn(table, SWT.CENTER);

		// full-width column
		table.addControlListener(new ControlListener() {
			public void controlResized(final ControlEvent e) {
				tableColumn.setWidth(table.getClientArea().width);
			}

			public void controlMoved(final ControlEvent e) {
				//
			}
		});

		this.fFeatureValuesTableViewer = new TableViewer(table);
		this.fFeatureValuesTableViewer.setContentProvider(new AssignedValuesContentProvider());
		// this.fFeatureValuesTableViewer.setLabelProvider(this.labelProvider);
		this.fFeatureValuesTableViewer
				.setInput(new FeatureValuesInput(this.fFeature, this.fEObject));

		final TableViewerColumn tableViewerColumn = new TableViewerColumn(
				this.fFeatureValuesTableViewer, tableColumn);
		tableViewerColumn.setLabelProvider(this.labelProvider);

		tableViewerColumn.setEditingSupport(new ModelCellsEditingSupport(
				this.fFeatureValuesTableViewer, this.fFeature, this.fEObject, this.editingDomain,
				this.newValuePlaceholder));

		// keyboard accessibility
		table.addKeyListener(new KeyAdapter() {
			@Override
			public void keyPressed(final KeyEvent e) {
				if (e.keyCode == SWT.F2) {
					editSelectedElement();
				}
				if (e.keyCode == SWT.DEL) {
					if (NaryAttributeEditingDialog.this.fRemoveButton.isEnabled()) {
						NaryAttributeEditingDialog.this.fRemoveButton.notifyListeners(
								SWT.Selection, null);
					}
				}
				if (e.keyCode == SWT.ARROW_UP
						&& ((e.stateMask & SWT.COMMAND) != 0 || (e.stateMask & SWT.CONTROL) != 0)) {
					if (NaryAttributeEditingDialog.this.fUpButton.isEnabled()) {
						NaryAttributeEditingDialog.this.fUpButton.notifyListeners(SWT.Selection,
								null);
					}
				}
				if (e.keyCode == SWT.ARROW_DOWN
						&& ((e.stateMask & SWT.COMMAND) != 0 || (e.stateMask & SWT.CONTROL) != 0)) {
					if (NaryAttributeEditingDialog.this.fDownButton.isEnabled()) {
						NaryAttributeEditingDialog.this.fDownButton.notifyListeners(SWT.Selection,
								null);
					}
				}
			}
		});

	}

	private void editSelectedElement() {
		ISelection selection = NaryAttributeEditingDialog.this.fFeatureValuesTableViewer
				.getSelection();
		if (selection instanceof IStructuredSelection) {
			IStructuredSelection structuredSelection = (IStructuredSelection) selection;
			if (structuredSelection.getFirstElement() != null) {
				NaryAttributeEditingDialog.this.fFeatureValuesTableViewer.editElement(
						structuredSelection.getFirstElement(), 0);
			}
		}
	}

	@Override
	protected void okPressed() {
		super.okPressed();
	}

	private void refresh() {
		this.fFeatureValuesTableViewer.refresh();
	}

	@Override
	protected boolean isResizable() {
		return true;
	}

	@Override
	protected void createButtonsForButtonBar(final Composite parent) {
		createButton(parent, IDialogConstants.OK_ID, IDialogConstants.OK_LABEL, true);
	}
}

Lines 106-114 Link Here

(-)src/org/eclipse/emf/facet/widgets/nattable/workbench/editor/NatTableEditorFactory.java (-2 / +4 lines)
106	} else {	106	} else {
107	int nElements = tableElements.size();	107	int nElements = tableElements.size();
108	if (nElements > 1) {	108	if (nElements > 1) {
109	description = NLS.bind(Messages.NatTableEditorFactory_queryResults, new Integer(nElements));	109	description = NLS.bind(Messages.NatTableEditorFactory_queryResults, new Integer(
		110	nElements));
110	} else {	111	} else {
111	description = NLS.bind(Messages.NatTableEditorFactory_queryResult, new Integer(nElements));	112	description = NLS.bind(Messages.NatTableEditorFactory_queryResult, new Integer(
		113	nElements));
112	}	114	}
113	queryName = Messages.NatTableEditorFactory_aQuery;	115	queryName = Messages.NatTableEditorFactory_aQuery;
114	}	116	}




		List<TableElement> tableElements = new ArrayList<TableElement>();
		for (ModelQueryResult modelQueryResult : result) {
			Object value = modelQueryResult.getValue();
			TableElementWithContext.flattenToList(value, tableElements,
					modelQueryResult.getSource());
		}
		openOn(new TableInput(tableElements, editingDomain));
	}

		manager.add(this.actionSortColumnsByType);
		manager.add(this.actionHideEmptyColumns);
		manager.add(this.actionOnlyShowCommonColumns);

	}

	private void fillContextMenu(final IMenuManager manager) {

			}
		};

		this.actionRemoveLine = new Action(Messages.NatTableView_removeSelectedLines,
				IAction.AS_PUSH_BUTTON) {
			{
				setToolTipText(Messages.NatTableView_removeSelectedLines);
				setImageDescriptor(ImageProvider.getInstance().getRemoveLineIconDescriptor());

Return to bug 331633

Lines 450-456 Link Here

(-)src/org/eclipse/emf/facet/widgets/celleditors/modelCellEditor/ModelCellEditorPackage.java (-4 / +8 lines)
450	* @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getModelCellEditorDeclarations()	450	* @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getModelCellEditorDeclarations()
451	* @generated	451	* @generated
452	*/	452	*/
453	EClass MODEL_CELL_EDITOR_DECLARATIONS = ModelCellEditorPackage.eINSTANCE.getModelCellEditorDeclarations();	453	EClass MODEL_CELL_EDITOR_DECLARATIONS = ModelCellEditorPackage.eINSTANCE
		454	.getModelCellEditorDeclarations();
454		455
455	/**	456	/**
456	* The meta object literal for the '<em><b>Model Cell Editors</b></em>'	457	* The meta object literal for the '<em><b>Model Cell Editors</b></em>'
Lines 472-478 Link Here
472	* @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getAbstractModelCellEditor()	473	* @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getAbstractModelCellEditor()
473	* @generated	474	* @generated
474	*/	475	*/
475	EClass ABSTRACT_MODEL_CELL_EDITOR = ModelCellEditorPackage.eINSTANCE.getAbstractModelCellEditor();	476	EClass ABSTRACT_MODEL_CELL_EDITOR = ModelCellEditorPackage.eINSTANCE
		477	.getAbstractModelCellEditor();
476		478
477	/**	479	/**
478	* The meta object literal for the '<em><b>Cell Type</b></em>' reference	480	* The meta object literal for the '<em><b>Cell Type</b></em>' reference
Lines 524-530 Link Here
524	* @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getUnaryReferenceCellEditor()	526	* @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getUnaryReferenceCellEditor()
525	* @generated	527	* @generated
526	*/	528	*/
527	EClass UNARY_REFERENCE_CELL_EDITOR = ModelCellEditorPackage.eINSTANCE.getUnaryReferenceCellEditor();	529	EClass UNARY_REFERENCE_CELL_EDITOR = ModelCellEditorPackage.eINSTANCE
		530	.getUnaryReferenceCellEditor();
528		531
529	/**	532	/**
530	* The meta object literal for the '	533	* The meta object literal for the '
Lines 546-552 Link Here
546	* @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getNaryFeatureCellEditor()	549	* @see org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.impl.ModelCellEditorPackageImpl#getNaryFeatureCellEditor()
547	* @generated	550	* @generated
548	*/	551	*/
549	EClass NARY_FEATURE_CELL_EDITOR = ModelCellEditorPackage.eINSTANCE.getNaryFeatureCellEditor();	552	EClass NARY_FEATURE_CELL_EDITOR = ModelCellEditorPackage.eINSTANCE
		553	.getNaryFeatureCellEditor();
550		554
551	/**	555	/**
552	* The meta object literal for the '	556	* The meta object literal for the '

Lines 79-85 Link Here

(-)src/org/eclipse/emf/facet/widgets/nattable/StyledColumnHeaderConfiguration.java (-3 / +6 lines)
79		79
80	private void addSelectedModeStyling(final IConfigRegistry configRegistry) {	80	private void addSelectedModeStyling(final IConfigRegistry configRegistry) {
81	ICellPainter selectedCellPainter = new BackgroundImagePainter(createCellPainter(),	81	ICellPainter selectedCellPainter = new BackgroundImagePainter(createCellPainter(),
82	StyledColumnHeaderConfiguration.SELECTED_BG_IMAGE, StyledColumnHeaderConfiguration.COLOR_GRAY);	82	StyledColumnHeaderConfiguration.SELECTED_BG_IMAGE,
		83	StyledColumnHeaderConfiguration.COLOR_GRAY);
83		84
84	// If sorting is enabled we still want the sort icon to be drawn.	85	// If sorting is enabled we still want the sort icon to be drawn.
85	SortableHeaderTextPainter selectedHeaderPainter = new SortableHeaderTextPainter(	86	SortableHeaderTextPainter selectedHeaderPainter = new SortableHeaderTextPainter(
Lines 100-106 Link Here
100	private void addNormalModeStyling(final IConfigRegistry configurationRegistry) {	101	private void addNormalModeStyling(final IConfigRegistry configurationRegistry) {
101		102
102	ICellPainter normalCellPainter = new BackgroundImagePainter(createCellPainter(),	103	ICellPainter normalCellPainter = new BackgroundImagePainter(createCellPainter(),
103	StyledColumnHeaderConfiguration.BG_IMAGE, StyledColumnHeaderConfiguration.COLOR_GRAY);	104	StyledColumnHeaderConfiguration.BG_IMAGE,
		105	StyledColumnHeaderConfiguration.COLOR_GRAY);
104		106
105	SortableHeaderTextPainter headerPainter = new SortableHeaderTextPainter(normalCellPainter,	107	SortableHeaderTextPainter headerPainter = new SortableHeaderTextPainter(normalCellPainter,
106	false);	108	false);
Lines 116-122 Link Here
116	private void addCornerStyling(final IConfigRegistry configurationRegistry) {	118	private void addCornerStyling(final IConfigRegistry configurationRegistry) {
117	// adds painting of the the gray triangle in the upper left corner	119	// adds painting of the the gray triangle in the upper left corner
118	ICellPainter cornerPainter = new BackgroundImagePainter(createCellPainter(),	120	ICellPainter cornerPainter = new BackgroundImagePainter(createCellPainter(),
119	StyledColumnHeaderConfiguration.BG_IMAGE, StyledColumnHeaderConfiguration.COLOR_GRAY) {	121	StyledColumnHeaderConfiguration.BG_IMAGE,
		122	StyledColumnHeaderConfiguration.COLOR_GRAY) {
120	@Override	123	@Override
121	public void paintCell(final LayerCell cell, final GC gc, final Rectangle rectangle,	124	public void paintCell(final LayerCell cell, final GC gc, final Rectangle rectangle,
122	final IConfigRegistry configRegistry) {	125	final IConfigRegistry configRegistry) {

Lines 56-75 Link Here

(-)src/org/eclipse/emf/facet/widgets/nattable/NatTableWidget.java (-142 / +32 lines)
56	import net.sourceforge.nattable.util.GUIHelper;	56	import net.sourceforge.nattable.util.GUIHelper;
57	import net.sourceforge.nattable.viewport.ViewportLayer;	57	import net.sourceforge.nattable.viewport.ViewportLayer;
58		58
59	import org.eclipse.core.runtime.Platform;
60	import org.eclipse.emf.common.notify.Adapter;	59	import org.eclipse.emf.common.notify.Adapter;
61	import org.eclipse.emf.common.notify.Notification;	60	import org.eclipse.emf.common.notify.Notification;
62	import org.eclipse.emf.common.notify.impl.AdapterImpl;	61	import org.eclipse.emf.common.notify.impl.AdapterImpl;
63	import org.eclipse.emf.common.util.EList;	62	import org.eclipse.emf.common.util.EList;
64	import org.eclipse.emf.ecore.EAttribute;	63	import org.eclipse.emf.ecore.EAttribute;
65	import org.eclipse.emf.ecore.EClass;	64	import org.eclipse.emf.ecore.EClass;
66	import org.eclipse.emf.ecore.EClassifier;
67	import org.eclipse.emf.ecore.EDataType;
68	import org.eclipse.emf.ecore.EEnum;	65	import org.eclipse.emf.ecore.EEnum;
69	import org.eclipse.emf.ecore.EObject;	66	import org.eclipse.emf.ecore.EObject;
70	import org.eclipse.emf.ecore.EReference;	67	import org.eclipse.emf.ecore.EReference;
71	import org.eclipse.emf.ecore.EStructuralFeature;	68	import org.eclipse.emf.ecore.EStructuralFeature;
72	import org.eclipse.emf.ecore.EcorePackage;
73	import org.eclipse.emf.ecore.resource.Resource;	69	import org.eclipse.emf.ecore.resource.Resource;
74	import org.eclipse.emf.ecore.util.EcoreUtil;	70	import org.eclipse.emf.ecore.util.EcoreUtil;
75	import org.eclipse.emf.edit.ui.dnd.LocalTransfer;	71	import org.eclipse.emf.edit.ui.dnd.LocalTransfer;
Lines 80-88 Link Here
80	import org.eclipse.emf.facet.widgets.celleditors.IModelCellEditor;	76	import org.eclipse.emf.facet.widgets.celleditors.IModelCellEditor;
81	import org.eclipse.emf.facet.widgets.celleditors.IModelCellEditorValidator;	77	import org.eclipse.emf.facet.widgets.celleditors.IModelCellEditorValidator;
82	import org.eclipse.emf.facet.widgets.celleditors.INaryFeatureCellEditor;	78	import org.eclipse.emf.facet.widgets.celleditors.INaryFeatureCellEditor;
		79	import org.eclipse.emf.facet.widgets.celleditors.ModelCellEditor;
83	import org.eclipse.emf.facet.widgets.celleditors.core.EEnumCellEditor;	80	import org.eclipse.emf.facet.widgets.celleditors.core.EEnumCellEditor;
84	import org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.AbstractModelCellEditor;	81	import org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.AbstractModelCellEditor;
85	import org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.NaryFeatureCellEditor;
86	import org.eclipse.emf.facet.widgets.nattable.ColumnDescription.Type;	82	import org.eclipse.emf.facet.widgets.nattable.ColumnDescription.Type;
87	import org.eclipse.emf.facet.widgets.nattable.TableInput.ElementsDescription;	83	import org.eclipse.emf.facet.widgets.nattable.TableInput.ElementsDescription;
88	import org.eclipse.jface.action.MenuManager;	84	import org.eclipse.jface.action.MenuManager;
Lines 493-500 Link Here
493	// not editable if no editing domain was provided	489	// not editable if no editing domain was provided
494	public void configureRegistry(final IConfigRegistry configRegistry) {	490	public void configureRegistry(final IConfigRegistry configRegistry) {
495	if (NatTableWidget.this.fTableInput.getEditingDomain() != null) {	491	if (NatTableWidget.this.fTableInput.getEditingDomain() != null) {
496	List<ModelCellEditorContainer<? extends AbstractModelCellEditor>> allCellEditorContainers = CellEditorsRegistry
497	.getInstance().getAllCellEditors();
498	for (int nColumn = 0; nColumn < NatTableWidget.this.fColumnDescriptions.size(); nColumn++) {	492	for (int nColumn = 0; nColumn < NatTableWidget.this.fColumnDescriptions.size(); nColumn++) {
499	ColumnDescription columnDescription = NatTableWidget.this.fColumnDescriptions	493	ColumnDescription columnDescription = NatTableWidget.this.fColumnDescriptions
500	.get(nColumn);	494	.get(nColumn);
Lines 502-515 Link Here
502	if (columnDescription.getType() == Type.ATTRIBUTE	496	if (columnDescription.getType() == Type.ATTRIBUTE
503	&& columnDescription.getAttribute().getEType() instanceof EEnum) {	497	&& columnDescription.getAttribute().getEType() instanceof EEnum) {
504	registerEnumCellEditor(configRegistry, (EEnum) columnDescription	498	registerEnumCellEditor(configRegistry, (EEnum) columnDescription
505	.getFeature().getEType(), columnLabelAccumulator,	499	.getFeature().getEType(), columnLabelAccumulator, nColumn,
506	allCellEditorContainers, nColumn, columnDescription);	500	columnDescription);
507	} else {	501	} else {
508	registerCellEditorForColumn(columnLabelAccumulator,	502	registerCellEditorForColumn(columnLabelAccumulator, nColumn,
509	allCellEditorContainers, nColumn, columnDescription);	503	columnDescription);
510	}	504	}
511	}	505	}
512		506
		507	List<ModelCellEditorContainer<? extends AbstractModelCellEditor>> allCellEditorContainers = CellEditorsRegistry
		508	.getInstance().getAllCellEditors();
513	for (ModelCellEditorContainer<? extends AbstractModelCellEditor> modelCellEditorContainer : allCellEditorContainers) {	509	for (ModelCellEditorContainer<? extends AbstractModelCellEditor> modelCellEditorContainer : allCellEditorContainers) {
514	registerCellEditor(modelCellEditorContainer, configRegistry);	510	registerCellEditor(modelCellEditorContainer, configRegistry);
515	}	511	}
Lines 519-597 Link Here
519	}	515	}
520		516
521	private void registerCellEditorForColumn(	517	private void registerCellEditorForColumn(
522	final ColumnOverrideLabelAccumulator columnLabelAccumulator,	518	final ColumnOverrideLabelAccumulator columnLabelAccumulator, final int nColumn,
523	final List<ModelCellEditorContainer<? extends AbstractModelCellEditor>> allCellEditorContainers,	519	final ColumnDescription columnDescription) {
524	final int nColumn, final ColumnDescription columnDescription) {
525	if (columnDescription.getType() == ColumnDescription.Type.ATTRIBUTE	520	if (columnDescription.getType() == ColumnDescription.Type.ATTRIBUTE
526	\|\| columnDescription.getType() == ColumnDescription.Type.REFERENCE) {	521	\|\| columnDescription.getType() == ColumnDescription.Type.REFERENCE) {
527	EStructuralFeature feature = columnDescription.getFeature();	522	EStructuralFeature feature = columnDescription.getFeature();
		523
528	if (!feature.isChangeable()) {	524	if (!feature.isChangeable()) {
529	return;	525	return;
530	}	526	}
531		527	ModelCellEditor selectedCellEditor = CellEditorsRegistry.getInstance()
532	EClassifier eType = feature.getEType();	528	.getCellEditorFor(feature.getEType(), feature.isMany());
533
534	class CellEditor {
535	private final String bundleName;
536	private final String cellID;
537
538	public CellEditor(final String bundleName, final String cellID) {
539	this.bundleName = bundleName;
540	this.cellID = cellID;
541	}
542
543	public String getBundleName() {
544	return this.bundleName;
545	}
546
547	public String getCellID() {
548	return this.cellID;
549	}
550	}
551	List<CellEditor> cellEditors = new ArrayList<CellEditor>();
552
553	for (ModelCellEditorContainer<? extends AbstractModelCellEditor> modelCellEditorContainer : allCellEditorContainers) {
554	AbstractModelCellEditor modelCellEditor = modelCellEditorContainer
555	.getModelCellEditor();
556
557	if (feature.isMany() != (modelCellEditor instanceof NaryFeatureCellEditor)) {
558	continue;
559	}
560
561	if (isSuperType(modelCellEditor.getCellType(), eType)) {
562	cellEditors.add(new CellEditor(modelCellEditorContainer.getBundleName(),
563	modelCellEditor.getCellId()));
564	}
565	}
566
567	CellEditor selectedCellEditor = null;
568	if (cellEditors.size() == 1) {
569	selectedCellEditor = cellEditors.get(0);
570	} else if (cellEditors.size() > 1) {
571	boolean skippedDefault = false;
572	for (CellEditor cellEditor : cellEditors) {
573	// lower priority for
574	// org.eclipse.emf.facet.widgets.celleditors.*
575	if (cellEditor.getBundleName().startsWith(
576	"org.eclipse.emf.facet.widgets.celleditors")) { //$NON-NLS-1$
577	if (skippedDefault) {
578	Logger.logError(
579	"Several default cell editors are defined in EMF Facet for type: " //$NON-NLS-1$
580	+ eType.getName(), Activator.getDefault());
581	selectedCellEditor = cellEditor;
582	break;
583	}
584	skippedDefault = true;
585	continue;
586	}
587	if (selectedCellEditor != null) {
588	Logger.logWarning("Several cell editors are defined for type: " //$NON-NLS-1$
589	+ eType.getName(), Activator.getDefault());
590	break;
591	}
592	selectedCellEditor = cellEditor;
593	}
594	}
595		529
596	if (selectedCellEditor != null) {	530	if (selectedCellEditor != null) {
597	// register cell editor for this column	531	// register cell editor for this column
Lines 599-634 Link Here
599	selectedCellEditor.getCellID());	533	selectedCellEditor.getCellID());
600	} else {	534	} else {
601	Logger.logWarning(	535	Logger.logWarning(
602	"No cell editor defined for type: " + EcoreUtil.getURI(eType) + " (column " + nColumn + ")", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$	536	"No cell editor defined for type: " + EcoreUtil.getURI(feature.getEType()) + " (column " + nColumn + ")", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
603	Activator.getDefault());	537	Activator.getDefault());
604	}	538	}
605	}	539	}
606	}	540	}
607		541
608	private boolean isSuperType(final EClassifier superType, final EClassifier subType) {
609	if (superType == subType) {
610	return true;
611	}
612
613	if (superType instanceof EClass && subType instanceof EClass) {
614	// special case because isSuperTypeOf doesn't handle it
615	if (superType == EcorePackage.eINSTANCE.getEObject()) {
616	return true;
617	}
618
619	EClass superTypeEClass = (EClass) superType;
620	EClass subTypeEClass = (EClass) subType;
621	return superTypeEClass.isSuperTypeOf(subTypeEClass);
622	}
623
624	if (superType == EcorePackage.eINSTANCE.getEDataType() && subType instanceof EDataType) {
625	// cf Bug 331539 - cell editor registered for type "EDataType"
626	return true;
627	}
628
629	return false;
630	}
631
632	/**	542	/**
633	* Registers a cell editor in the config registry	543	* Registers a cell editor in the config registry
634	*	544	*
Lines 639-650 Link Here
639	* @param nColumn	549	* @param nColumn
640	* @param columnDescription	550	* @param columnDescription
641	*/	551	*/
642	private void registerEnumCellEditor(	552	private void registerEnumCellEditor(final IConfigRegistry configRegistry, final EEnum eType,
643	final IConfigRegistry configRegistry,	553	final ColumnOverrideLabelAccumulator columnLabelAccumulator, final int nColumn,
644	final EEnum eType,	554	final ColumnDescription columnDescription) {
645	final ColumnOverrideLabelAccumulator columnLabelAccumulator,
646	final List<ModelCellEditorContainer<? extends AbstractModelCellEditor>> allCellEditorContainers,
647	final int nColumn, final ColumnDescription columnDescription) {
648	columnLabelAccumulator.registerColumnOverrides(nColumn,	555	columnLabelAccumulator.registerColumnOverrides(nColumn,
649	NatTableWidget.ENUM_CELLEDITOR_LABEL);	556	NatTableWidget.ENUM_CELLEDITOR_LABEL);
650	configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR,	557	configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR,
Lines 659-709 Link Here
659	private void registerCellEditor(	566	private void registerCellEditor(
660	final ModelCellEditorContainer<? extends AbstractModelCellEditor> modelCellEditorContainer,	567	final ModelCellEditorContainer<? extends AbstractModelCellEditor> modelCellEditorContainer,
661	final IConfigRegistry configRegistry) {	568	final IConfigRegistry configRegistry) {
662	AbstractModelCellEditor modelCellEditor = modelCellEditorContainer.getModelCellEditor();
663	String className = modelCellEditor.getModelCellEditorImpl();
664
665	Class<?> classInstance = null;
666	try {
667	classInstance = Platform.getBundle(modelCellEditorContainer.getBundleName()).loadClass(
668	className);
669	} catch (Exception e) {
670	Logger.logError("Could not find class: " + className, //$NON-NLS-1$
671	Activator.getDefault());
672	return;
673	}
674		569
675	Object instance = null;	570	ModelCellEditor cellEditor = new ModelCellEditor(modelCellEditorContainer.getBundleName(),
676	try {	571	modelCellEditorContainer.getModelCellEditor());
677	instance = classInstance.newInstance();	572	Object cellEditorImplementation = cellEditor.getCellEditorImplementation();
678	} catch (Exception e) {
679	Logger.logError("Could not instantiate class: " + className, //$NON-NLS-1$
680	Activator.getDefault());
681	return;
682	}
683		573
684	if (instance instanceof IModelCellEditor) {	574	if (cellEditorImplementation instanceof IModelCellEditor) {
685	IModelCellEditor modelCellEditorImpl = (IModelCellEditor) instance;	575	IModelCellEditor modelCellEditorImpl = (IModelCellEditor) cellEditorImplementation;
686		576
687	configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR,	577	configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR,
688	new NatTableCellEditorAdapter(modelCellEditorImpl,	578	new NatTableCellEditorAdapter(modelCellEditorImpl,
689	NatTableWidget.this.fColumnDescriptions), DisplayMode.NORMAL,	579	NatTableWidget.this.fColumnDescriptions), DisplayMode.NORMAL,
690	modelCellEditor.getCellId());	580	cellEditor.getCellID());
691	configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITABLE_RULE,	581	configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITABLE_RULE,
692	IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, modelCellEditor.getCellId());	582	IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, cellEditor.getCellID());
693	} else if (instance instanceof INaryFeatureCellEditor) {	583	} else if (cellEditorImplementation instanceof INaryFeatureCellEditor) {
694	INaryFeatureCellEditor modelCellEditorImpl = (INaryFeatureCellEditor) instance;	584	INaryFeatureCellEditor modelCellEditorImpl = (INaryFeatureCellEditor) cellEditorImplementation;
695		585
696	configRegistry.registerConfigAttribute(	586	configRegistry.registerConfigAttribute(
697	EditConfigAttributes.CELL_EDITOR,	587	EditConfigAttributes.CELL_EDITOR,
698	new NatTableNaryReferenceCellEditorAdapter(modelCellEditorImpl,	588	new NatTableNaryReferenceCellEditorAdapter(modelCellEditorImpl,
699	NatTableWidget.this.fColumnDescriptions, this.fTableInput	589	NatTableWidget.this.fColumnDescriptions, this.fTableInput
700	.getEditingDomain()), DisplayMode.NORMAL, modelCellEditor	590	.getEditingDomain()), DisplayMode.NORMAL, cellEditor
701	.getCellId());	591	.getCellID());
702	configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITABLE_RULE,	592	configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITABLE_RULE,
703	IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, modelCellEditor.getCellId());	593	IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, cellEditor.getCellID());
704	// disable automatic commit for INaryReferenceCellEditor	594	// disable automatic commit for INaryReferenceCellEditor
705	configRegistry.registerConfigAttribute(EditConfigAttributes.DATA_VALIDATOR,	595	configRegistry.registerConfigAttribute(EditConfigAttributes.DATA_VALIDATOR,
706	IDataValidator.NEVER_VALID, DisplayMode.EDIT, modelCellEditor.getCellId());	596	IDataValidator.NEVER_VALID, DisplayMode.EDIT, cellEditor.getCellID());
707	} else {	597	} else {
708	Logger.logError("Model cell editor implementation must be an instance of " //$NON-NLS-1$	598	Logger.logError("Model cell editor implementation must be an instance of " //$NON-NLS-1$
709	+ IModelCellEditor.class.getSimpleName() + " or " //$NON-NLS-1$	599	+ IModelCellEditor.class.getSimpleName() + " or " //$NON-NLS-1$
Lines 711-721 Link Here
711	return;	601	return;
712	}	602	}
713		603
714	if (instance instanceof IModelCellEditorValidator) {	604	if (cellEditorImplementation instanceof IModelCellEditorValidator) {
715	IModelCellEditorValidator modelCellEditorValidator = (IModelCellEditorValidator) instance;	605	IModelCellEditorValidator modelCellEditorValidator = (IModelCellEditorValidator) cellEditorImplementation;
716	configRegistry.registerConfigAttribute(EditConfigAttributes.DATA_VALIDATOR,	606	configRegistry.registerConfigAttribute(EditConfigAttributes.DATA_VALIDATOR,
717	new DataValidatorAdapter(modelCellEditorValidator), DisplayMode.EDIT,	607	new DataValidatorAdapter(modelCellEditorValidator), DisplayMode.EDIT,
718	modelCellEditor.getCellId());	608	cellEditor.getCellID());
719	}	609	}
720	}	610	}
721		611

Line 0 Link Here

(-)src/org/eclipse/emf/facet/widgets/celleditors/ModelCellEditor.java (+80 lines)
		1	/*******************************************************************************
		2	* Copyright (c) 2010 CEA LIST.
		3	*
		4	* All rights reserved. This program and the accompanying materials
		5	* are made available under the terms of the Eclipse Public License v1.0
		6	* which accompanies this distribution, and is available at
		7	* http://www.eclipse.org/legal/epl-v10.html
		8	*
		9	* Contributors:
		10	* Nicolas Bros (Mia-Software) - initial API and implementation
		11	*******************************************************************************/
		12	package org.eclipse.emf.facet.widgets.celleditors;
		13
		14	import org.eclipse.core.runtime.Platform;
		15	import org.eclipse.emf.facet.infra.common.core.logging.Logger;
		16	import org.eclipse.emf.facet.widgets.celleditors.modelCellEditor.AbstractModelCellEditor;
		17
		18	public class ModelCellEditor {
		19	private final String bundleName;
		20	private final AbstractModelCellEditor modelCellEditor;
		21
		22	public ModelCellEditor(final String bundleName, final AbstractModelCellEditor modelCellEditor) {
		23	this.bundleName = bundleName;
		24	this.modelCellEditor = modelCellEditor;
		25	}
		26
		27	public String getBundleName() {
		28	return this.bundleName;
		29	}
		30
		31	public String getCellID() {
		32	return this.modelCellEditor.getCellId();
		33	}
		34
		35	public AbstractModelCellEditor getModelCellEditor() {
		36	return this.modelCellEditor;
		37	}
		38
		39	public Object getCellEditorImplementation() {
		40	String className = this.modelCellEditor.getModelCellEditorImpl();
		41
		42	Class<?> classInstance = null;
		43	try {
		44	classInstance = Platform.getBundle(this.bundleName).loadClass(className);
		45	} catch (Exception e) {
		46	Logger.logError("Could not find class: " + className, //$NON-NLS-1$
		47	Activator.getDefault());
		48	return null;
		49	}
		50
		51	Object instance = null;
		52	try {
		53	instance = classInstance.newInstance();
		54	} catch (Exception e) {
		55	Logger.logError("Could not instantiate class: " + className, //$NON-NLS-1$
		56	Activator.getDefault());
		57	return null;
		58	}
		59	return instance;
		60	}
		61
		62	@Override
		63	public boolean equals(final Object obj) {
		64	if (obj instanceof ModelCellEditor) {
65	ModelCellEditor other = (ModelCellEditor) obj;
66	return other.getCellID().equals(getCellID());
67	}
68	return false;
69	}
70
71	@Override
72	public int hashCode() {
73	return getCellID().hashCode();
74	}
75
76	@Override
77	public String toString() {
78	return getBundleName() + "#" + getCellID(); //$NON-NLS-1$
79	}
80	}

Lines 151-157 Link Here

(-)src/org/eclipse/emf/facet/widgets/celleditors/modelCellEditor/impl/AbstractModelCellEditorImpl.java (-2 / +4 lines)
151	this.cellId = newCellId;	151	this.cellId = newCellId;
152	if (eNotificationRequired()) {	152	if (eNotificationRequired()) {
153	eNotify(new ENotificationImpl(this, Notification.SET,	153	eNotify(new ENotificationImpl(this, Notification.SET,
154	ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_ID, oldCellId, this.cellId));	154	ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_ID, oldCellId,
		155	this.cellId));
155	}	156	}
156	}	157	}
157		158
Lines 232-238 Link Here
232	case ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_TYPE:	233	case ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_TYPE:
233	return this.cellType != null;	234	return this.cellType != null;
234	case ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_ID:	235	case ModelCellEditorPackage.ABSTRACT_MODEL_CELL_EDITOR__CELL_ID:
235	return AbstractModelCellEditorImpl.CELL_ID_EDEFAULT == null ? this.cellId != null : !AbstractModelCellEditorImpl.CELL_ID_EDEFAULT.equals(this.cellId);	236	return AbstractModelCellEditorImpl.CELL_ID_EDEFAULT == null ? this.cellId != null
		237	: !AbstractModelCellEditorImpl.CELL_ID_EDEFAULT.equals(this.cellId);
236	}	238	}
237	return super.eIsSet(featureID);	239	return super.eIsSet(featureID);
238	}	240	}

Lines 1-29 Link Here

(-)src/org/eclipse/emf/facet/widgets/celleditors/messages.properties (-10 / +18 lines)
		1	NaryAttributeEditingDialog_delete=D&elete
		2	NaryAttributeEditingDialog_enterNewValuePlaceholder=<enter new value>
		3	###############################################################################
		4	# Copyright (c) 2010 CEA
		5	#
		6	# All rights reserved. This program and the accompanying materials
		7	# are made available under the terms of the Eclipse Public License v1.0
		8	# which accompanies this distribution, and is available at
		9	# http://www.eclipse.org/legal/epl-v10.html
		10	#
		11	# Contributors:
		12	# Nicolas Bros (Mia-Software) - initial API and implementation
		13	###############################################################################
		14	NaryAttributeEditingDialog_add=&Add
1	NaryReferenceEditingDialog_addAll=>>	15	NaryReferenceEditingDialog_addAll=>>
2	NaryReferenceEditingDialog_addAllTooltip=Add all	16	NaryReferenceEditingDialog_addAllTooltip=Add all
3	NaryReferenceEditingDialog_addTooltip=Add	17	NaryReferenceEditingDialog_addTooltip=Add
4	NaryReferenceEditingDialog_availableValues=Available values	18	NaryReferenceEditingDialog_availableValues=Available values
5	NaryReferenceEditingDialog_deleteElements=Delete elements?	19	NaryReferenceEditingDialog_deleteElements=Delete elements?
6	NaryReferenceEditingDialog_deleteElementsLong=Since the feature is composite, this will delete the selected element(s) from the model.	20	NaryReferenceEditingDialog_deleteElementsLong=Since the feature is composite, this will delete the selected element(s) from the model.
7	NaryReferenceEditingDialog_down=Down	21	NaryReferenceEditingDialog_down=&Down
8	NaryReferenceEditingDialog_featureIsComposite=The feature is composite.	22	NaryReferenceEditingDialog_featureIsComposite=The feature is composite.
9	NaryReferenceEditingDialog_moveElement=Move element?	23	NaryReferenceEditingDialog_moveElement=Move element?
10	NaryReferenceEditingDialog_remove=<	24	NaryReferenceEditingDialog_remove=&<
11	NaryReferenceEditingDialog_removeAll=<<	25	NaryReferenceEditingDialog_removeAll=<<
12	NaryReferenceEditingDialog_removeAllTooltip=Remove all	26	NaryReferenceEditingDialog_removeAllTooltip=Remove all
13	NaryReferenceEditingDialog_removeTooltip=Remove	27	NaryReferenceEditingDialog_removeTooltip=Remove
14	NaryReferenceEditingDialog_shellTitle=Edit {0} of {1}	28	NaryReferenceEditingDialog_shellTitle=Edit {0} of {1}
15	NaryReferenceEditingDialog_typeFilterText=type filter text	29	NaryReferenceEditingDialog_typeFilterText=type filter text
16	NaryReferenceEditingDialog_up=Up	30	NaryReferenceEditingDialog_up=&Up
17	NaryReferenceEditingDialog_values=Values	31	NaryReferenceEditingDialog_values=Values
18	NaryReferenceEditingDialog_valueWillBeMoved=The selected value will be moved from its previous parent.	32	NaryReferenceEditingDialog_valueWillBeMoved=The selected value will be moved from its previous parent.
19	NaryReferenceEditingDialog_valueWillBeMovedAndPreviousLost=The selected value will be moved from its previous parent and the previous value will be lost.	33	NaryReferenceEditingDialog_valueWillBeMovedAndPreviousLost=The selected value will be moved from its previous parent and the previous value will be lost.
20	###############################################################################	34	NaryReferenceEditingDialog_add=&>
21	# Copyright (c) 2010 CEA
22	#
23	# Contributors:
24	# Nicolas Bros (Mia-Software) - initial API and implementation
25	###############################################################################
26	NaryReferenceEditingDialog_add=>
27	UnaryReferenceCellEditorComposite_0=Invalid selection	35	UnaryReferenceCellEditorComposite_0=Invalid selection
28	UnaryReferenceCellEditorComposite_1=Please select an EObject	36	UnaryReferenceCellEditorComposite_1=Please select an EObject
29	UnaryReferenceCellEditorComposite_2=Select an EObject	37	UnaryReferenceCellEditorComposite_2=Select an EObject

Lines 73-79 Link Here

(-)src/org/eclipse/emf/facet/widgets/nattable/workbench/view/NatTableView.java (-3 / +5 lines)
73	List<TableElement> tableElements = new ArrayList<TableElement>();	73	List<TableElement> tableElements = new ArrayList<TableElement>();
74	for (ModelQueryResult modelQueryResult : result) {	74	for (ModelQueryResult modelQueryResult : result) {
75	Object value = modelQueryResult.getValue();	75	Object value = modelQueryResult.getValue();
76	TableElementWithContext.flattenToList(value, tableElements, modelQueryResult.getSource());	76	TableElementWithContext.flattenToList(value, tableElements,
		77	modelQueryResult.getSource());
77	}	78	}
78	openOn(new TableInput(tableElements, editingDomain));	79	openOn(new TableInput(tableElements, editingDomain));
79	}	80	}
Lines 150-156 Link Here
150	manager.add(this.actionSortColumnsByType);	151	manager.add(this.actionSortColumnsByType);
151	manager.add(this.actionHideEmptyColumns);	152	manager.add(this.actionHideEmptyColumns);
152	manager.add(this.actionOnlyShowCommonColumns);	153	manager.add(this.actionOnlyShowCommonColumns);
153		154
154	}	155	}
155		156
156	private void fillContextMenu(final IMenuManager manager) {	157	private void fillContextMenu(final IMenuManager manager) {
Lines 220-226 Link Here
220	}	221	}
221	};	222	};
222		223
223	this.actionRemoveLine = new Action(Messages.NatTableView_removeSelectedLines, IAction.AS_PUSH_BUTTON) {	224	this.actionRemoveLine = new Action(Messages.NatTableView_removeSelectedLines,
		225	IAction.AS_PUSH_BUTTON) {
224	{	226	{
225	setToolTipText(Messages.NatTableView_removeSelectedLines);	227	setToolTipText(Messages.NatTableView_removeSelectedLines);
226	setImageDescriptor(ImageProvider.getInstance().getRemoveLineIconDescriptor());	228	setImageDescriptor(ImageProvider.getInstance().getRemoveLineIconDescriptor());