/*******************************************************************************
* Copyright (c) 2007, 2013 Borland Software Corporation and others.
*
* 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:
* Borland Software Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.m2m.internal.qvt.oml.runtime.ui;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EEnum;
import org.eclipse.emf.ecore.EEnumLiteral;
import org.eclipse.jface.action.ContributionItem;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.ComboBoxCellEditor;
import org.eclipse.jface.viewers.ICellModifier;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TableLayout;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.m2m.internal.qvt.oml.common.MdaException;
import org.eclipse.m2m.internal.qvt.oml.common.launch.ISetMessage;
import org.eclipse.m2m.internal.qvt.oml.runtime.project.QvtTransformation;
import org.eclipse.m2m.internal.qvt.oml.runtime.project.config.QvtConfigurationProperty;
import org.eclipse.m2m.internal.qvt.oml.runtime.project.config.QvtConfigurationPropertyType;
import org.eclipse.m2m.internal.qvt.oml.runtime.ui.wizards.ApplyTransformationData;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
public class QvtTransformationConfigurationUI {
public QvtTransformationConfigurationUI(ApplyTransformationData data, ISetMessage sm) {
mySetMessage = sm;
myData = data;
}
public void createControl(Composite parent) {
int style = SWT.SINGLE | SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL |
SWT.FULL_SELECTION | SWT.HIDE_SELECTION;
myTableViewer = new TableViewer(parent, style);
GridData gridData = new GridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL);
myTableViewer.getControl().setLayoutData(gridData);
myTableViewer.setContentProvider(CONTENT_PROVIDER);
myTableViewer.setLabelProvider(LABEL_PROVIDER);
Table table = myTableViewer.getTable();
TableLayout layout = new TableLayout();
table.setLayout(layout);
table.setHeaderVisible(true);
table.setLinesVisible(true);
hookContextMenu();
createColumn(table, layout, Messages.QvtTransformationConfigurationUI_PropertyColumn);
createColumn(table, layout, Messages.QvtTransformationConfigurationUI_TypeColumn);
createColumn(table, layout, Messages.QvtTransformationConfigurationUI_ValueColumn);
myEditors = new CellEditor[3];
myTextCellEditor = new TextCellEditor(myTableViewer.getTable());
myComboBoxCellEditor = new ComboBoxCellEditor(myTableViewer.getTable(), BOOLEAN_ITEMS, SWT.READ_ONLY | SWT.DROP_DOWN);
myEditors[2] = myTextCellEditor;
myTableViewer.setCellEditors(myEditors);
myTableViewer.setColumnProperties(new String[] {"0", "1", "2"}); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
myTableViewer.setInput(myProperties);
myTableViewer.setCellModifier(CELL_MODIFIER);
}
protected void hookContextMenu() {
MenuManager menuManager = new MenuManager("#PopupMenu"); //$NON-NLS-1$
menuManager.setRemoveAllWhenShown(true);
menuManager.addMenuListener(new IMenuListener() {
public void menuAboutToShow(IMenuManager manager) {
manager.add(new ContributionItem() {
@Override
public void fill(Menu menu, int index) {
if (myUnsetMenuItem == null) {
createUnsetMenuItem(menu);
}
myUnsetMenuItem.setEnabled(!myTableViewer.getSelection().isEmpty());
}
private void createUnsetMenuItem(Menu menu) {
myUnsetMenuItem = new MenuItem(menu, SWT.PUSH);
myUnsetMenuItem.setText(Messages.QvtTransformationConfigurationUI_UnsetMenuItem);
myUnsetMenuItem.addSelectionListener( new SelectionListener() {
public void widgetSelected(SelectionEvent e) {
ISelection selection = myTableViewer.getSelection();
if (selection instanceof IStructuredSelection) {
IStructuredSelection sel = (IStructuredSelection) selection;
ConfigurationPropertyValue firstElement = (ConfigurationPropertyValue) sel.getFirstElement();
if (firstElement != null) {
firstElement.setValue(QvtConfigurationPropertyType.NOT_SET);
myTableViewer.update(firstElement, COLUMNS_TO_UPDATE);
notifyListeners(firstElement.getProperty());
}
}
}
public void widgetDefaultSelected(SelectionEvent e) {
widgetSelected(e);
}
});
}
private MenuItem myUnsetMenuItem;
});
}
});
Menu menu = menuManager.createContextMenu(myTableViewer.getControl());
myTableViewer.getControl().setMenu(menu);
}
private void createColumn(Table table, TableLayout layout, String name) {
TableColumn nameColumn = new TableColumn(table, SWT.NONE);
layout.addColumnData(new ColumnWeightData(3, true));
nameColumn.setText(name);
}
public void loadValues() {
myTransformation = myData.getTransformation();
Map<String, String> valueMap = myData.getConfiguration();
myProperties.clear();
if (myTransformation != null) {
Set<QvtConfigurationProperty> configurationProperties;
try {
configurationProperties = myTransformation.getConfigurationProperties();
for (QvtConfigurationProperty property : configurationProperties) {
myProperties.addProperty(property, valueMap.get(property.getName()));
}
} catch (MdaException e) {
// Error is already reported in UI, no need for duplication in log
//QvtRuntimeUIPlugin.getDefault().getLog().log(MiscUtil.makeErrorStatus(e));
}
}
myTableViewer.refresh();
}
public void performApply() {
myData.getConfiguration().clear();
myProperties.fillMap(myData.getConfiguration());
}
public void validate() {
mySetMessage.setMessage(null);
ConfigurationPropertyValue error = myProperties.getFirstError();
if (error != null) {
mySetMessage.setErrorMessage(NLS.bind(Messages.QvtTransformationConfigurationUI_InvalidProperyValue, String.valueOf(error.getValue()), error.getProperty().getName()));
myValid = false;
return;
}
mySetMessage.setErrorMessage(null);
myValid = true;
}
public boolean isValid() {
return myValid;
}
public void addPropertyChangeListener(PropertyChangeListener listener) {
myListeners.add(listener);
}
public void removePropertyChangeListener(PropertyChangeListener listener) {
myListeners.remove(listener);
}
private void notifyListeners(QvtConfigurationProperty property) {
for (PropertyChangeListener listener : myListeners) {
listener.changePerformed(property);
}
}
private static class ConfigurationPropertyValueList {
public void addProperty(QvtConfigurationProperty property, String value) {
myValues.add(new ConfigurationPropertyValue(property, property.getType().valueOf(value)));
}
public void clear() {
myValues.clear();
}
public ConfigurationPropertyValue[] getAll() {
return myValues.toArray(new ConfigurationPropertyValue[] {});
}
public void fillMap(Map<String, String> valueMap) {
for (ConfigurationPropertyValue value : myValues) {
if (value.getValue() != QvtConfigurationPropertyType.NOT_SET) {
valueMap.put(
value.getProperty().getName(),
value.getProperty().getType().stringValueOf(value.getValue())
);
}
}
}
public ConfigurationPropertyValue getFirstError() {
for (ConfigurationPropertyValue value: myValues) {
if (value.getValue() instanceof QvtConfigurationPropertyType.ErrorValue) {
return value;
}
}
return null;
}
private List<ConfigurationPropertyValue> myValues = new ArrayList<ConfigurationPropertyValue>();
}
private static class ConfigurationPropertyValue {
public ConfigurationPropertyValue(QvtConfigurationProperty prop) {
myProperty = prop;
}
public ConfigurationPropertyValue(QvtConfigurationProperty prop, Object value) {
this(prop);
myValue = value;
}
public Object getValue() {
return myValue;
}
public void setValue(Object value) {
myValue = value;
}
public QvtConfigurationProperty getProperty() {
return myProperty;
}
@Override
public String toString() {
return myValue.toString();
}
private final QvtConfigurationProperty myProperty;
private Object myValue;
}
protected static final IStructuredContentProvider CONTENT_PROVIDER = new IStructuredContentProvider() {
public Object[] getElements(Object inputElement) {
if (inputElement instanceof ConfigurationPropertyValueList == false) {
return null;
}
return ((ConfigurationPropertyValueList) inputElement).getAll();
}
public void dispose() {
}
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
}
};
private class MyLabelProvider extends LabelProvider implements ITableLabelProvider {
public Image getColumnImage(Object element, int columnIndex) {
if (columnIndex == 2) {
ConfigurationPropertyValue value = (ConfigurationPropertyValue) element;
if (value.getValue() == QvtConfigurationPropertyType.NOT_SET) {
return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJS_WARN_TSK);
} else if (value.getValue() instanceof QvtConfigurationPropertyType.ErrorValue) {
return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJS_ERROR_TSK);
}
return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_FILE);
}
return null;
}
public String getColumnText(Object element, int columnIndex) {
if (element instanceof String) {
return element.toString();
}
ConfigurationPropertyValue value = (ConfigurationPropertyValue) element;
switch (columnIndex) {
case 0:
return value.getProperty().getName();
case 1:
return value.getProperty().getType().getName();
case 2:
return value.toString();
default:
return null;
}
}
}
protected final MyLabelProvider LABEL_PROVIDER = new MyLabelProvider();
private ComboBoxCellEditor getBooleanComboBox() {
myComboBoxCellEditor.setItems(BOOLEAN_ITEMS);
return myComboBoxCellEditor;
}
private void setCellEditor(CellEditor e) {
myEditors[2] = e;
myTableViewer.setCellEditors(myEditors);
}
private boolean isBooleanValue(ConfigurationPropertyValue value) {
return (value.getProperty().getType().getImplementation() == Boolean.class) ||
(value.getProperty().getType().getImplementation() == Boolean.TYPE);
}
private boolean isEnumValue(ConfigurationPropertyValue value) {
return (value.getProperty().getType().getImplementation() instanceof EEnum);
}
private CellEditor getEnumComboBox(EEnum eEnum) {
EList<?> literals = eEnum.getELiterals();
String[] items = new String[literals.size()];
int i = 0;
for (Iterator<?> iter = literals.iterator(); iter.hasNext(); i++) {
EEnumLiteral literal = (EEnumLiteral) iter.next();
items[i] = literal.getLiteral();
}
myComboBoxCellEditor.setItems(items);
return myComboBoxCellEditor;
}
protected final ICellModifier CELL_MODIFIER = new ICellModifier() {
public boolean canModify(Object element, String property) {
boolean result = "2".equals(property); //$NON-NLS-1$
if (result) {
ConfigurationPropertyValue value = (ConfigurationPropertyValue) element;
if (isBooleanValue(value)) {
setCellEditor(getBooleanComboBox());
} else if (isEnumValue(value)) {
setCellEditor(getEnumComboBox((EEnum) value.getProperty().getType().getImplementation()));
} else {
setCellEditor(myTextCellEditor);
}
}
return result;
}
public Object getValue(Object element, String property) {
ConfigurationPropertyValue value = (ConfigurationPropertyValue) element;
if (isBooleanValue(value)) {
return (value.getValue() == Boolean.TRUE) ? Integer.valueOf(1) : Integer.valueOf(0);
}
if (isEnumValue(value)) {
EEnum eEnum = (EEnum) value.getProperty().getType().getImplementation();
return eEnum.getELiterals().indexOf(value.getValue());
}
if (value.getValue() == QvtConfigurationPropertyType.NOT_SET) {
return ""; //$NON-NLS-1$
} else {
return value.getProperty().getType().stringValueOf(value.getValue());
}
}
public void modify(Object element, String property, Object value) {
if (element instanceof Item) {
element = ((Item) element).getData();
}
ConfigurationPropertyValue cpValue = (ConfigurationPropertyValue) element;
Object valueToBeSet;
if (isBooleanValue(cpValue)) {
valueToBeSet = Boolean.valueOf(((Integer) value).intValue() == 1);
} else if (isEnumValue(cpValue)) {
EEnum eEnum = (EEnum) cpValue.getProperty().getType().getImplementation();
valueToBeSet = eEnum.getEEnumLiteral(myComboBoxCellEditor.getItems()[(Integer) value]);
} else {
valueToBeSet = cpValue.getProperty().getType().valueOf(value.toString());
}
cpValue.setValue(valueToBeSet);
myTableViewer.refresh();
notifyListeners(cpValue.getProperty());
}
};
public interface PropertyChangeListener {
void changePerformed(QvtConfigurationProperty property);
}
private ISetMessage mySetMessage;
private final ConfigurationPropertyValueList myProperties = new ConfigurationPropertyValueList();
private TableViewer myTableViewer;
private QvtTransformation myTransformation;
private final ApplyTransformationData myData;
private final Set<PropertyChangeListener> myListeners = new HashSet<PropertyChangeListener>();
private boolean myValid;
private CellEditor[] myEditors;
private TextCellEditor myTextCellEditor;
private ComboBoxCellEditor myComboBoxCellEditor;
private static final String[] BOOLEAN_ITEMS = new String[] {Boolean.FALSE.toString(), Boolean.TRUE.toString()};
private static final String[] COLUMNS_TO_UPDATE = new String[] {"2"}; //$NON-NLS-1$
}