path: root/extraplugins/robotml/org.eclipse.papyrus.robotml.deployment/src/org/eclipse/papyrus/robotml/deployment/dialog/ConfigureInstanceDialog.java

/*****************************************************************************
 * Copyright (c) 2013 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:
 *  Saadia Dhouib (CEA LIST) saadia.dhouib@cea.fr - Initial API and implementation
 *****************************************************************************/
package org.eclipse.papyrus.robotml.deployment.dialog;

import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.papyrus.robotml.deployment.DepCreation;
import org.eclipse.papyrus.robotml.deployment.DepPlanSync;
import org.eclipse.papyrus.robotml.deployment.DepPlanUtils;
import org.eclipse.papyrus.robotml.deployment.DepUtils;
import org.eclipse.papyrus.robotml.deployment.DialogUtils;
import org.eclipse.papyrus.robotml.deployment.Utils;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.dialogs.SelectionStatusDialog;
import org.eclipse.uml2.uml.Class;
import org.eclipse.uml2.uml.Classifier;
import org.eclipse.uml2.uml.Connector;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.Feature;
import org.eclipse.uml2.uml.InstanceSpecification;
import org.eclipse.uml2.uml.LiteralBoolean;
import org.eclipse.uml2.uml.LiteralInteger;
import org.eclipse.uml2.uml.LiteralString;
import org.eclipse.uml2.uml.Package;
import org.eclipse.uml2.uml.PackageableElement;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.Slot;
import org.eclipse.uml2.uml.Type;
import org.eclipse.uml2.uml.ValueSpecification;

/**
 * Select container rules, either from a list of globally defined rules or from
 * local rules which may be created "on the fly" by this dialog.
 *
 * TODO: extend rule application to instances (problematic, since rules
 * transformation is done on type level)
 *
 * @author ansgar
 */
public class ConfigureInstanceDialog extends SelectionStatusDialog {

	protected Class m_component;

	protected Label fDescriptionLabel;

	protected Text fDescription;

	protected TreeViewer fInstanceList;

	protected TableViewer fPropertyList;

	protected Property m_currentAttribute;

	protected final String valueLabelPrefix = "Value:";

	protected Label fValueLabel;

	protected Text fValue;

	protected Package m_model;

	protected Feature m_feature;

	protected EList<Package> visitedPackages;

	protected boolean m_rulePropertiesOnly;

	protected InstanceSpecification m_instance;

	EList<InstanceSpecification> m_instanceList;

	public ConfigureInstanceDialog(Shell parent) {
		super(parent);
	}

	public boolean init(Class component) {
		// visitedPackages = new BasicEList<Package> ();
		DepPlanSync.syncAllDepPlans(component);
		m_component = component;
		m_instance = null;
		m_feature = null;
		m_model = Utils.getUserModel();
		return checkAndGetInstances();
	}

	public boolean init(InstanceSpecification instance) {
		// visitedPackages = new BasicEList<Package> ();
		DepPlanSync.syncDepPlan(instance.getNearestPackage());
		m_component = DepUtils.getImplementation(instance);
		m_instance = instance;
		m_feature = null;
		m_model = Utils.getUserModel();
		return checkAndGetInstances();
	}

	public boolean init(Feature feature) {
		// visitedPackages = new BasicEList<Package> ();
		m_feature = feature;
		m_model = Utils.getUserModel();
		m_instance = null;
		if (feature instanceof Property) {
			Type type = ((Property) feature).getType();
			if (type instanceof Class) {
				m_component = (Class) type;
				return checkAndGetInstances();
			}
		}
		return false;
	}


	/**
	 * retrieve the instance list. Returns false, if no deploymentplan could be found.
	 *
	 * @return
	 */
	public boolean checkAndGetInstances() {
		visitedPackages = new BasicEList<Package>();
		m_instanceList = new BasicEList<InstanceSpecification>();

		getInstances(m_instanceList);
		if (m_instanceList.size() == 0) {
			Shell shell = new Shell();
			if (DepPlanUtils.getAllDepPlans(m_model).size() == 0) {
				MessageDialog.openInformation(shell, "Instance configuration",
						"No deployment plans are defined. Create a deployment plan before configuring instances");
				return false;
			}
			else if (MessageDialog.openConfirm(shell, "Instance configuration",
					"The list of available instances is empty. Synchronize deployment plans?")) {
				DepPlanSync.syncAllDepPlans(m_model);
				visitedPackages = new BasicEList<Package>();
				getInstances(m_instanceList);
				if (m_instanceList.size() == 0) {
					MessageDialog.openInformation(shell, "Instance configuration",
							"There are still no instances available\n" +
									"Check whether you created already a deployment plan for your system." +
									"Check as well, if the parts in your a composite use \"composite\" as aggregation kind\n." +
									"(Results of deployment plan synchronizations will be unrolled)");
					return false;
				}
			}
		}
		return true;
	}

	/**
	 * @see SelectionStatusDialog#computeResult()
	 */
	@Override
	protected void computeResult() {
		// nothing to do
	}

	@Override
	public Control createDialogArea(Composite parent) {
		Composite contents = (Composite) super.createDialogArea(parent);
		// (parent, "Container rules", "Avail. extensions/interceptors");

		createInstanceSelectionGroup(contents);
		createInstanceConfigurationGroup(contents);
		return contents;
	}

	protected void createInstanceSelectionGroup(Composite parent) {
		Composite instanceSelection = new Composite(parent, SWT.NONE);
		GridLayout grid = new GridLayout(1, true);
		GridData groupGridData = new GridData();

		groupGridData.grabExcessVerticalSpace = true;
		groupGridData.grabExcessHorizontalSpace = true;
		groupGridData.horizontalAlignment = GridData.FILL;
		groupGridData.verticalAlignment = GridData.FILL;
		instanceSelection.setLayout(grid);
		instanceSelection.setLayoutData(groupGridData);

		/*
		 * fRules = DialogUtils.createFilteredList (ruleSelGroup, new
		 * RuleLabelProvider(), 200, 200, SWT.BORDER | SWT.V_SCROLL |
		 * SWT.H_SCROLL);
		 */

		//
		// --------------- instance selection -------------------
		//
		Group instanceSelGroup = new Group(instanceSelection, SWT.BORDER);
		instanceSelGroup.setText(" associated instance specifications ");
		// ruleGroup.setLayout(new RowLayout (SWT.VERTICAL));
		instanceSelGroup.setLayout(new GridLayout(1, false));
		instanceSelGroup.setLayoutData(groupGridData);

		fInstanceList = new TreeViewer(instanceSelGroup, SWT.BORDER);

		GridData data = new GridData(GridData.FILL_BOTH);
		data.heightHint = 100;
		data.widthHint = 350;

		fInstanceList.getTree().setLayoutData(data);
		fInstanceList.setLabelProvider(new InstanceLabelProvider());
		fInstanceList.setContentProvider(new ITreeContentProvider() {

			@Override
			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			}

			@Override
			public void dispose() {
			}

			@Override
			public boolean hasChildren(Object element) {
				return getChildren(element).length > 0;
			}

			@Override
			public Object getParent(Object element) {
				return null;
			}

			@Override
			public Object[] getElements(Object inputElement) {
				return (Object[]) inputElement;
			}

			@Override
			public Object[] getChildren(Object parentElement) {
				if (parentElement instanceof InstanceSpecification) {
					return DepUtils.getContainedInstances((InstanceSpecification) parentElement).toArray();
				}
				return new Object[0];
			}
		});

		fInstanceList.setInput(m_instanceList.toArray());
		fInstanceList.addSelectionChangedListener(new ISelectionChangedListener() {

			@Override
			public void selectionChanged(SelectionChangedEvent event) {
				ISelection selection = fInstanceList.getSelection();
				if (selection instanceof StructuredSelection) {
					Object[] selected = ((StructuredSelection) selection)
							.toArray();
					if ((selected.length == 1)
							&& (selected[0] instanceof InstanceSpecification)) {
						m_instance = (InstanceSpecification) selected[0];
						Classifier cl = DepUtils.getClassifier(m_instance);
						fPropertyList.setInput(getConfigAttributes(cl).toArray());
						selectProperty(m_currentAttribute);
					}
				}
			}
		});
		if (m_instance != null) {
			int index = m_instanceList.indexOf(m_instance);
			if (index != -1) {
				TreeItem treeItem = fInstanceList.getTree().getItem(index);
				fInstanceList.getTree().setSelection(treeItem);
			}
		}
	}

	// create instance configuration group
	protected void createInstanceConfigurationGroup(Composite parent) {
		GridData groupGridData = DialogUtils.createFillGridData();

		Group instanceConfigurationGroup = new Group(parent, SWT.BORDER);
		instanceConfigurationGroup.setText(" Configuration ");
		instanceConfigurationGroup.setLayout(new RowLayout(SWT.VERTICAL));
		instanceConfigurationGroup.setLayout(new GridLayout(1, false));
		instanceConfigurationGroup.setLayoutData(groupGridData);

		// fRuleName = new Text (ruleInfoGroup, SWT.NONE);
		Label configL = new Label(instanceConfigurationGroup, SWT.NONE);
		configL.setText("Available properties:");

		fPropertyList = new TableViewer(instanceConfigurationGroup, SWT.BORDER);
		fPropertyList.setLabelProvider(new AttributeLabelProvider());
		fPropertyList.setContentProvider(new ArrayContentProvider());
		fPropertyList.setInput(getConfigAttributes(m_component).toArray());
		fPropertyList
				.addSelectionChangedListener(new ISelectionChangedListener() {

					@Override
					public void selectionChanged(SelectionChangedEvent event) {
						ISelection selection = fPropertyList.getSelection();
						if (selection instanceof StructuredSelection) {
							Object[] selected = ((StructuredSelection) selection)
									.toArray();
							if ((selected.length == 1)
									&& (selected[0] instanceof Property)) {
								selectProperty((Property) selected[0]);
							}
						}
					}
				});

		fValueLabel = new Label(instanceConfigurationGroup, SWT.NONE);

		GridData span2 = new GridData();
		span2.horizontalAlignment = GridData.FILL;
		span2.grabExcessHorizontalSpace = true;
		span2.heightHint = 70;
		fPropertyList.getTable().setLayoutData(span2);

		fValue = new Text(instanceConfigurationGroup, SWT.WRAP);
		span2 = new GridData();
		span2.horizontalAlignment = GridData.FILL;
		span2.grabExcessHorizontalSpace = true;
		fValue.setLayoutData(span2);
		fValue.addFocusListener(new FocusListener() {

			@Override
			public void focusLost(FocusEvent e) {
				// store value, once focus is lost (different element is
				// selected)
				String valueStr = fValue.getText();
				Slot valueSlot = null;
				if (m_instance == null) {
					// no instance has been selected
					// (field should be inactive, if not selected)
					return;
				}
				for (Slot slot : m_instance.getSlots()) {
					if (slot.getDefiningFeature() == m_currentAttribute) {
						valueSlot = slot;
					}
				}
				if (valueSlot == null) {
					// slot does not exist yet, create
					valueSlot = DepCreation.createSlotForConfigProp(m_instance,
							m_currentAttribute);
				}
				for (ValueSpecification value : valueSlot.getValues()) {
					if (value instanceof LiteralString) {
						((LiteralString) value).setValue(valueStr);
					} else if (value instanceof LiteralInteger) {
						((LiteralInteger) value).setValue(Integer
								.parseInt(valueStr));
					} else if (value instanceof LiteralBoolean) {
						((LiteralBoolean) value).setValue(Boolean
								.parseBoolean(valueStr));
					}
				}
			}

			@Override
			public void focusGained(FocusEvent e) {
			}
		});

		fDescriptionLabel = new Label(instanceConfigurationGroup, SWT.NONE);
		fDescriptionLabel.setText("Description:");
		fDescriptionLabel.setLayoutData(span2);

		span2 = new GridData();
		span2.horizontalAlignment = GridData.FILL;
		span2.grabExcessHorizontalSpace = true;
		span2.grabExcessVerticalSpace = true;
		span2.verticalAlignment = GridData.FILL;
		span2.heightHint = 80;

		fDescription = new Text(instanceConfigurationGroup, SWT.NONE | SWT.WRAP
				| SWT.V_SCROLL | SWT.READ_ONLY);
		fDescription.setLayoutData(span2);
		// createMessageArea (ruleInfoGroup);
		instanceConfigurationGroup.pack();
		setEnabled(false);
	}

	/**
	 * Select a rule, i.e. update the visual representation from the rule
	 *
	 * @param rule
	 */
	protected void selectProperty(Property attribute) {
		m_currentAttribute = attribute;
		if ((attribute == null) || (fValue == null)) {
			setEnabled(false);
			return;
		}
		setEnabled(true);
		fDescription.setText(Description.getDescription(attribute, "not available"));
		fValueLabel.setText(getValueLabel(attribute));
		for (Slot slot : m_instance.getSlots()) {
			if (slot.getDefiningFeature() == m_currentAttribute) {
				for (ValueSpecification value : slot.getValues()) {
					if (value instanceof LiteralInteger) {
						Integer intVal = ((LiteralInteger) value).getValue();
						fValue.setText(intVal.toString());
						return;
					}
					else if (value instanceof LiteralBoolean) {
						Boolean boolVal = ((LiteralBoolean) value).booleanValue();
						fValue.setText(boolVal.toString());
						return;
					}
					else if (value instanceof LiteralString) {
						fValue.setText(((LiteralString) value).getValue());
						return;
					}
				}
			}
		}
		fValue.setText("");
	}

	private void setEnabled(boolean enabled) {
		fDescriptionLabel.setEnabled(enabled);
		fDescription.setEnabled(enabled);
		fValueLabel.setEnabled(enabled);
		fValue.setEnabled(enabled);
		if (!enabled) {
			fValue.setText("");
			fDescription.setText("");
			fValueLabel.setText(valueLabelPrefix);
		}
	}

	private String getValueLabel(Property attribute) {
		String label = valueLabelPrefix;
		if (attribute.getDefault() != null) {
			return label + " (Default = " + attribute.getDefault() + ")";
		}
		return label;
	}

	// TODO(?): need a generic utility function for getting all elements obeying a
	// certain criteria from a model
	void getInstances(EList<InstanceSpecification> instanceList) {
		Package deploymentPlans = Utils.getRoot(m_model, "DeploymentPlans");
		String featureCandidateName = null;
		for (PackageableElement deploymentPlan : deploymentPlans
				.getPackagedElements()) {
			if (deploymentPlan instanceof Package) {
				for (PackageableElement instance : ((Package) deploymentPlan).getPackagedElements()) {
					if (instance instanceof InstanceSpecification) {
						InstanceSpecification candidate = (InstanceSpecification) instance;
						if (m_feature instanceof Property) {
							for (Slot slot : candidate.getSlots()) {
								if (slot.getDefiningFeature() == m_feature) {
									instanceList
											.add(DepUtils.getInstance(slot));
								}
							}
						} else if (m_feature instanceof Connector) {
							// Connector cannot be found directly, since there is no slot in containing composite (defining
							// feature is a structural-feature, not a feature): find via name.
							Element owner = m_feature.getOwner();
							if (DepUtils.getImplementation(candidate) == owner) {
								// instance is for owner of feature: examine name
								featureCandidateName = candidate.getName() + "." + m_feature.getName();
							}
							else if (featureCandidateName != null) {
								if (featureCandidateName.equals(candidate.getName())) {
									instanceList.add(candidate);
								}
							}
						} else if (DepUtils.getImplementation(candidate) == m_component) {
							instanceList.add(candidate);
						}
					}
				}
			}
		}
	}

	private EList<Property> getConfigAttributes(Classifier component) {
		EList<Property> list = new BasicEList<Property>();
		// // add properties of component
		// list.addAll(ConfigUtils.getConfigAttributes(component));
		// // now add properties of container rules
		// // TODO: is it possible that multiple container extensions of the same
		// // type exist, and if yes, how do we configure these?
		// if(component instanceof Class) {
		// EList<ContainerRule> rules = Utils.getRules((Class)component);
		// if(rules != null) {
		// for(ContainerRule aRule : rules) {
		// // (many, in case of a composite rule)
		// try {
		// list.addAll(ConfigUtils.getConfigAttributes(aRule));
		// } catch (TransformationException e) {
		// }
		// }
		// }
		// }
		return list;
	}

}