| /******************************************************************************* |
| * Copyright (c) 2006, 2009 Markus Herrmannsdoerfer. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Markus Herrmannsdoerfer - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.emf.edapt.history.instantiation.ui; |
| |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.emf.common.ui.celleditor.ExtendedComboBoxCellEditor; |
| import org.eclipse.emf.common.ui.celleditor.ExtendedDialogCellEditor; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EDataType; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.EcorePackage; |
| import org.eclipse.emf.ecore.provider.EcoreItemProviderAdapterFactory; |
| import org.eclipse.emf.edapt.common.ui.AutoColumnSizeTableViewer; |
| import org.eclipse.emf.edapt.common.ui.MultiValueSelectionDialog; |
| import org.eclipse.emf.edapt.common.ui.SingleValueSelectionDialog; |
| import org.eclipse.emf.edapt.declaration.Parameter; |
| import org.eclipse.emf.edapt.spi.history.OperationInstance; |
| import org.eclipse.emf.edapt.spi.history.ParameterInstance; |
| import org.eclipse.emf.edapt.spi.history.provider.HistoryEditPlugin; |
| import org.eclipse.emf.edapt.spi.history.provider.HistoryItemProviderAdapterFactory; |
| import org.eclipse.emf.edit.provider.ComposedAdapterFactory; |
| import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory; |
| import org.eclipse.emf.edit.provider.resource.ResourceItemProviderAdapterFactory; |
| import org.eclipse.emf.edit.ui.celleditor.FeatureEditorDialog; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider; |
| import org.eclipse.emf.edit.ui.provider.PropertyDescriptor; |
| import org.eclipse.jface.dialogs.PopupDialog; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.viewers.CellEditor; |
| import org.eclipse.jface.viewers.DoubleClickEvent; |
| import org.eclipse.jface.viewers.ICellModifier; |
| import org.eclipse.jface.viewers.IDoubleClickListener; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.ILabelProviderListener; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.ITableLabelProvider; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.viewers.TextCellEditor; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.HelpEvent; |
| import org.eclipse.swt.events.HelpListener; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Table; |
| import org.eclipse.swt.widgets.TableColumn; |
| import org.eclipse.swt.widgets.TableItem; |
| |
| /** |
| * Table viewer to display and edit parameter instances of an operation (An |
| * operation instance is exected as input) |
| * |
| * @author herrmama |
| * @author $Author$ |
| * @version $Rev$ |
| * @levd.rating RED Rev: |
| */ |
| public class ParameterViewer extends AutoColumnSizeTableViewer { |
| |
| /** |
| * Label of name column |
| */ |
| private static final String NAME_COLUMN_PROPERTY = "Name"; //$NON-NLS-1$ |
| |
| /** |
| * Label of value column |
| */ |
| private static final String VALUE_COLUMN_PROPERTY = "Value"; //$NON-NLS-1$ |
| |
| /** |
| * Operation browser |
| */ |
| private final OperationSash operationSash; |
| |
| /** |
| * Parameter icon |
| */ |
| private Image parameterImage; |
| |
| /** |
| * Label provider for cell |
| */ |
| private ILabelProvider cellLabelProvider; |
| |
| /** |
| * Label provider used in viewer label provider |
| */ |
| private AdapterFactoryLabelProvider dialogLabelProvider; |
| |
| /** |
| * Default constructor |
| * |
| * @param parent |
| * Parent composite |
| * @param operationSash |
| */ |
| public ParameterViewer(Composite parent, OperationSash operationSash) { |
| super(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER |
| | SWT.FULL_SELECTION); |
| |
| this.operationSash = operationSash; |
| |
| init(); |
| } |
| |
| /** |
| * Initialize table viewer |
| * |
| */ |
| private void init() { |
| final ComposedAdapterFactory adapterFactory = new ComposedAdapterFactory(); |
| adapterFactory |
| .addAdapterFactory(new ResourceItemProviderAdapterFactory()); |
| adapterFactory.addAdapterFactory(new EcoreItemProviderAdapterFactory()); |
| adapterFactory |
| .addAdapterFactory(new ReflectiveItemProviderAdapterFactory()); |
| adapterFactory |
| .addAdapterFactory(new HistoryItemProviderAdapterFactory()); |
| |
| dialogLabelProvider = new AdapterFactoryLabelProvider(adapterFactory); |
| cellLabelProvider = new LabelProvider() { |
| |
| @Override |
| public Image getImage(Object element) { |
| if (element instanceof Collection) { |
| final Collection collection = (Collection) element; |
| if (!collection.isEmpty()) { |
| return dialogLabelProvider.getImage(collection |
| .iterator().next()); |
| } |
| } else { |
| if (element != null) { |
| return dialogLabelProvider.getImage(element); |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public String getText(Object element) { |
| if (element instanceof Collection) { |
| String label = ""; //$NON-NLS-1$ |
| final Collection c = (Collection) element; |
| for (final Iterator i = c.iterator(); i.hasNext();) { |
| label += dialogLabelProvider.getText(i.next()); |
| if (i.hasNext()) { |
| label += ", "; //$NON-NLS-1$ |
| } |
| } |
| return label; |
| } |
| return dialogLabelProvider.getText(element); |
| } |
| }; |
| |
| final URL url = (URL) HistoryEditPlugin.INSTANCE |
| .getImage("full/obj16/ParameterInstance"); //$NON-NLS-1$ |
| final ImageDescriptor imageDescriptor = ImageDescriptor.createFromURL(url); |
| parameterImage = imageDescriptor.createImage(); |
| |
| // columns |
| final Table parameterTable = getTable(); |
| parameterTable.setHeaderVisible(true); |
| |
| final TableColumn parameterNameColumn = new TableColumn(parameterTable, |
| SWT.None); |
| parameterNameColumn.setWidth(100); |
| parameterNameColumn.setText(NAME_COLUMN_PROPERTY); |
| parameterNameColumn.setResizable(false); |
| |
| final TableColumn parameterValueColumn = new TableColumn(parameterTable, |
| SWT.None); |
| parameterValueColumn.setWidth(100); |
| parameterValueColumn.setText(VALUE_COLUMN_PROPERTY); |
| parameterValueColumn.setResizable(false); |
| |
| // content provider |
| setContentProvider(new IStructuredContentProvider() { |
| |
| @Override |
| public Object[] getElements(Object inputElement) { |
| final OperationInstance operationInstance = (OperationInstance) inputElement; |
| return operationInstance.getParameters().toArray(); |
| } |
| |
| @Override |
| public void dispose() { |
| // not required |
| } |
| |
| @Override |
| public void inputChanged(Viewer viewer, Object oldInput, |
| Object newInput) { |
| // not required |
| } |
| |
| }); |
| |
| // label provider |
| setLabelProvider(new ITableLabelProvider() { |
| |
| @Override |
| public Image getColumnImage(Object element, int columnIndex) { |
| final ParameterInstance parameterInstance = (ParameterInstance) element; |
| switch (columnIndex) { |
| case 0: |
| return parameterImage; |
| case 1: |
| return cellLabelProvider.getImage(parameterInstance |
| .getValue()); |
| default: |
| return null; |
| } |
| } |
| |
| @Override |
| public String getColumnText(Object element, int columnIndex) { |
| final ParameterInstance parameterInstance = (ParameterInstance) element; |
| switch (columnIndex) { |
| case 0: |
| return parameterInstance.getName(); |
| case 1: { |
| final Object value = parameterInstance.getValue(); |
| return cellLabelProvider.getText(value); |
| } |
| default: |
| return ""; //$NON-NLS-1$ |
| } |
| } |
| |
| @Override |
| public void addListener(ILabelProviderListener listener) { |
| // not required |
| } |
| |
| @Override |
| public void dispose() { |
| // not required |
| } |
| |
| @Override |
| public boolean isLabelProperty(Object element, String property) { |
| return false; |
| } |
| |
| @Override |
| public void removeListener(ILabelProviderListener listener) { |
| // not required |
| } |
| }); |
| |
| // cell editors |
| setColumnProperties(new String[] { NAME_COLUMN_PROPERTY, |
| VALUE_COLUMN_PROPERTY }); |
| |
| final CellEditor[] cellEditors = new CellEditor[2]; |
| cellEditors[1] = new TextCellEditor(getTable()); |
| setCellEditors(cellEditors); |
| |
| setCellModifier(new ICellModifier() { |
| |
| @Override |
| public boolean canModify(Object element, String property) { |
| if (NAME_COLUMN_PROPERTY.equals(property)) { |
| return false; |
| } |
| final ParameterInstance parameterInstance = (ParameterInstance) element; |
| final Parameter parameter = parameterInstance.getParameter(); |
| if (parameter.isMain()) { |
| return false; |
| } |
| cellEditors[1] = getCellEditor(parameterInstance); |
| return true; |
| } |
| |
| @Override |
| public Object getValue(Object element, String property) { |
| final ParameterInstance parameterInstance = (ParameterInstance) element; |
| return parameterInstance.getValue(); |
| } |
| |
| @Override |
| public void modify(Object element, String property, |
| final Object value) { |
| element = ((TableItem) element).getData(); |
| final ParameterInstance parameterInstance = (ParameterInstance) element; |
| final Parameter parameter = parameterInstance.getParameter(); |
| |
| if (parameter.isMany()) { |
| if (parameter.getClassifier() instanceof EClass) { |
| if (!(value instanceof Object[])) { |
| return; |
| } |
| final Object[] values = (Object[]) value; |
| parameterInstance.setValue(Arrays.asList(values)); |
| } else { |
| parameterInstance.setValue(value); |
| } |
| } else { |
| if (parameter.getClassifier() instanceof EClass) { |
| if (!(value instanceof Object[])) { |
| return; |
| } |
| final Object[] values = (Object[]) value; |
| if (values.length == 0) { |
| parameterInstance.setValue(null); |
| } else { |
| parameterInstance.setValue(values[0]); |
| } |
| } else { |
| parameterInstance.setValue(value); |
| } |
| } |
| |
| refresh(true); |
| operationSash |
| .updateConstraints((OperationInstance) parameterInstance |
| .eContainer()); |
| } |
| |
| }); |
| |
| // show parameter description upon double click |
| parameterTable.addHelpListener(new HelpListener() { |
| |
| @Override |
| public void helpRequested(HelpEvent e) { |
| |
| if (parameterTable.getSelectionCount() > 0) { |
| final TableItem tableItem = parameterTable.getSelection()[0]; |
| showDescription(tableItem); |
| } |
| } |
| |
| }); |
| |
| addDoubleClickListener(new IDoubleClickListener() { |
| |
| @Override |
| public void doubleClick(DoubleClickEvent event) { |
| |
| if (parameterTable.getSelectionCount() > 0) { |
| final TableItem tableItem = parameterTable.getSelection()[0]; |
| showDescription(tableItem); |
| } |
| } |
| |
| }); |
| } |
| |
| /** |
| * Show the description of a parameter which is associated to a table item |
| * |
| * @param tableItem |
| * Table item |
| */ |
| private void showDescription(TableItem tableItem) { |
| final ParameterInstance parameterInstance = (ParameterInstance) tableItem |
| .getData(); |
| final Parameter parameter = parameterInstance.getParameter(); |
| final PopupDialog dialog = new TableItemPopupDialog(tableItem, |
| parameter.getName(), parameter.getDescription()); |
| dialog.open(); |
| } |
| |
| /** |
| * Get cell editor for a parameter instance based on the type of parameter |
| * |
| * @param parameterInstance |
| * Parameter instance |
| * @return Cell editor |
| */ |
| protected CellEditor getCellEditor(final ParameterInstance parameterInstance) { |
| final Parameter parameter = parameterInstance.getParameter(); |
| |
| if (parameter.isMany()) { |
| if (parameter.getClassifier() instanceof EClass) { |
| return new ExtendedDialogCellEditor(getTable(), |
| cellLabelProvider) { |
| |
| @Override |
| protected Object openDialogBox(Control cellEditorWindow) { |
| |
| final ParameterValueValidator selection = new ParameterValueValidator( |
| parameterInstance, operationSash.getHelper() |
| .getExtent()); |
| |
| final List values = (List) parameterInstance.getValue(); |
| final MultiValueSelectionDialog dialog = new MultiValueSelectionDialog( |
| cellEditorWindow.getShell(), parameterImage, |
| getEditorTitle(parameter), values, |
| getRootPackages(), dialogLabelProvider, |
| selection); |
| |
| dialog.open(); |
| return dialog.getResult(); |
| } |
| |
| }; |
| } else if (parameter.getClassifier() instanceof EDataType) { |
| return new ExtendedDialogCellEditor(getTable(), |
| cellLabelProvider) { |
| |
| @Override |
| protected Object openDialogBox(Control cellEditorWindow) { |
| |
| final EDataType type = (EDataType) parameter.getClassifier(); |
| final List values = (List) parameterInstance.getValue(); |
| |
| @SuppressWarnings("deprecation") |
| final FeatureEditorDialog dialog = new FeatureEditorDialog( |
| cellEditorWindow.getShell(), |
| dialogLabelProvider, parameterInstance, type, |
| values, getEditorTitle(parameterInstance |
| .getParameter()), |
| null); |
| |
| dialog.open(); |
| return dialog.getResult(); |
| } |
| |
| }; |
| } |
| } else { |
| if (parameter.getClassifier() instanceof EClass) { |
| return new ExtendedDialogCellEditor(getTable(), |
| cellLabelProvider) { |
| |
| @Override |
| protected Object openDialogBox(Control cellEditorWindow) { |
| |
| final ParameterValueValidator selection = new ParameterValueValidator( |
| parameterInstance, operationSash.getHelper() |
| .getExtent()); |
| |
| final SingleValueSelectionDialog dialog = new SingleValueSelectionDialog( |
| cellEditorWindow.getShell(), parameterImage, |
| getEditorTitle(parameter), parameterInstance |
| .getValue(), |
| getRootPackages(), |
| dialogLabelProvider, selection); |
| |
| dialog.open(); |
| return dialog.getResult(); |
| } |
| |
| }; |
| } else if (parameter.getClassifier() instanceof EDataType) { |
| final EDataType dataType = (EDataType) parameter.getClassifier(); |
| if (dataType.getInstanceClass() == Boolean.class |
| || dataType.getInstanceClass() == Boolean.TYPE) { |
| |
| final List<Object> values = Arrays.asList(new Object[] { Boolean.FALSE, |
| Boolean.TRUE }); |
| |
| return new ExtendedComboBoxCellEditor(getTable(), |
| values, dialogLabelProvider, false); |
| } |
| return new PropertyDescriptor.EDataTypeCellEditor( |
| (EDataType) parameter.getClassifier(), getTable()); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Helper method to access root packages |
| */ |
| private Collection<EPackage> getRootPackages() { |
| final Collection<EPackage> rootPackages = new ArrayList<EPackage>(); |
| rootPackages.addAll(operationSash.getHelper().getExtent() |
| .getRootPackages()); |
| rootPackages.add(EcorePackage.eINSTANCE); |
| return rootPackages; |
| } |
| |
| /** |
| * Get table of cell editor dialog |
| * |
| * @param parameter |
| * Parameter |
| * @return Title |
| */ |
| public static String getEditorTitle(Parameter parameter) { |
| String result = "Parameter "; //$NON-NLS-1$ |
| result += parameter.getName(); |
| result += " : "; //$NON-NLS-1$ |
| if (parameter.isMany()) { |
| result += "List<" + parameter.getClassifierName() + ">"; //$NON-NLS-1$ //$NON-NLS-2$ |
| } else { |
| result += parameter.getClassifierName(); |
| } |
| return result; |
| } |
| } |
