bundles/core/org.eclipse.apogy.core.environment.surface.ui/src/org/eclipse/apogy/core/environment/surface/ui/composites/FeaturesOfInterestMapLayersListComposite.java

/*******************************************************************************
 * Copyright (c) 2018 Agence spatiale canadienne / Canadian Space Agency 
 * 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:
 *     Pierre Allard,
 *     Regent L'Archeveque - initial API and implementation
 *
 * SPDX-License-Identifier: EPL-1.0
 *     
 *******************************************************************************/
package org.eclipse.apogy.core.environment.surface.ui.composites;

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

import org.eclipse.apogy.common.emf.ApogyCommonEMFFacade;
import org.eclipse.apogy.common.emf.transaction.ApogyCommonTransactionFacade;
import org.eclipse.apogy.common.emf.ui.wizards.ApogyEObjectWizard;
import org.eclipse.apogy.core.ApogyCoreFacade;
import org.eclipse.apogy.core.ApogyCoreFactory;
import org.eclipse.apogy.core.FeatureOfInterest;
import org.eclipse.apogy.core.environment.surface.AbstractMapLayer;
import org.eclipse.apogy.core.environment.surface.ApogySurfaceEnvironmentFacade;
import org.eclipse.apogy.core.environment.surface.ApogySurfaceEnvironmentFactory;
import org.eclipse.apogy.core.environment.surface.ApogySurfaceEnvironmentPackage;
import org.eclipse.apogy.core.environment.surface.FeaturesOfInterestMapLayer;
import org.eclipse.apogy.core.environment.surface.Map;
import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.UpdateValueStrategy;
import org.eclipse.core.databinding.conversion.Converter;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
import org.eclipse.jface.databinding.swt.WidgetProperties;
import org.eclipse.jface.databinding.viewers.ViewerProperties;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
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.Event;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Tree;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class FeaturesOfInterestMapLayersListComposite extends Composite {
	private static final Logger Logger = LoggerFactory.getLogger(FeaturesOfInterestMapLayersListComposite.class);

	public static String path = System.getProperty("user.home");

	private Map map;

	private final Tree tree;
	private final TreeViewer treeViewer;
	private final Button btnNew;
	private final Button btnDelete;
	private final Button btnImport;
	private final Button btnExport;

	private final AdapterFactory adapterFactory = new ComposedAdapterFactory(
			ComposedAdapterFactory.Descriptor.Registry.INSTANCE);
	private DataBindingContext m_bindingContext;

	public FeaturesOfInterestMapLayersListComposite(Composite parent, int style) {
		super(parent, style);
		setLayout(new GridLayout(2, false));

		this.treeViewer = new TreeViewer(this,
				SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
		this.tree = this.treeViewer.getTree();
		GridData gd_tree = new GridData(SWT.FILL, SWT.FILL, false, true, 1, 1);
		gd_tree.minimumWidth = 200;
		gd_tree.widthHint = 200;
		this.tree.setLayoutData(gd_tree);
		this.tree.setLinesVisible(true);

		this.treeViewer.setContentProvider(new CustomContentProvider());
		this.treeViewer.setLabelProvider(new AdapterFactoryLabelProvider(this.adapterFactory));
		this.treeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
			@Override
			public void selectionChanged(SelectionChangedEvent event) {
				newFeaturesOfInterestMapLayerSelected(
						(FeaturesOfInterestMapLayer) ((IStructuredSelection) event.getSelection()).getFirstElement());
			}
		});

		// Buttons.
		Composite composite = new Composite(this, SWT.NONE);
		composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1));
		composite.setLayout(new GridLayout(1, false));

		this.btnNew = new Button(composite, SWT.NONE);
		this.btnNew.setSize(74, 29);
		this.btnNew.setText("New");
		this.btnNew.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
		this.btnNew.setEnabled(true);
		this.btnNew.addListener(SWT.Selection, new Listener() {
			@Override
			public void handleEvent(Event event) {
				if (event.type == SWT.Selection) {
					Wizard wizard = new ApogyEObjectWizard(ApogySurfaceEnvironmentPackage.Literals.MAP__LAYERS,
							getMap(), null, ApogySurfaceEnvironmentPackage.Literals.FEATURES_OF_INTEREST_MAP_LAYER);
					WizardDialog dialog = new WizardDialog(getShell(), wizard);
					dialog.open();

					// Forces the viewer to refresh its input.
					if (!FeaturesOfInterestMapLayersListComposite.this.treeViewer.isBusy()) {
						FeaturesOfInterestMapLayersListComposite.this.treeViewer.setInput(getMap());
					}
				}
			}
		});

		this.btnDelete = new Button(composite, SWT.NONE);
		this.btnDelete.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
		this.btnDelete.setSize(74, 29);
		this.btnDelete.setText("Delete");
		this.btnDelete.setEnabled(false);
		this.btnDelete.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent event) {
				String foiMapLayersToDeleteMessage = "";

				Iterator<FeaturesOfInterestMapLayer> foiMapsLayers = getSelectedFeatureOfInterestMapLayers().iterator();
				while (foiMapsLayers.hasNext()) {
					FeaturesOfInterestMapLayer foiMapLayer = foiMapsLayers.next();
					foiMapLayersToDeleteMessage = foiMapLayersToDeleteMessage + foiMapLayer.getName();

					if (foiMapsLayers.hasNext()) {
						foiMapLayersToDeleteMessage = foiMapLayersToDeleteMessage + ", ";
					}
				}

				MessageDialog dialog = new MessageDialog(null, "Delete the selected FOI Map Layers", null,
						"Are you sure to delete these FOI Map Layers: " + foiMapLayersToDeleteMessage,
						MessageDialog.QUESTION, new String[] { "Yes", "No" }, 1);
				int result = dialog.open();
				if (result == 0) {
					for (FeaturesOfInterestMapLayer layer : getSelectedFeatureOfInterestMapLayers()) {
						try {
							ApogySurfaceEnvironmentFacade.INSTANCE.deleteLayerFromMap(layer.getMap(), layer);
						} catch (Exception e) {
							Logger.error("Unable to delete the FOI Map Layer <" + layer.getName() + ">.", e);
						}
					}
				}

				// Forces the viewer to refresh its input.
				if (!FeaturesOfInterestMapLayersListComposite.this.treeViewer.isBusy()) {
					FeaturesOfInterestMapLayersListComposite.this.treeViewer.setInput(getMap());
				}
			}
		});

		// Spacer
		new Label(composite, SWT.NONE);

		this.btnImport = new Button(composite, SWT.NONE);
		this.btnImport.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
		this.btnImport.setSize(74, 29);
		this.btnImport.setText("Import");
		this.btnImport.setToolTipText("Import a list of Feature Of Interest from file.");
		this.btnImport.setEnabled(true);
		this.btnImport.addSelectionListener(new SelectionListener() {

			@Override
			public void widgetSelected(SelectionEvent e) {
				FileDialog fd = new FileDialog(getShell(), SWT.OPEN);
				fd.setFilterPath(path);
				fd.setFilterExtensions(new String[] { "*.csv" });
				fd.setOverwrite(true);

				String filePath = fd.open();

				if (filePath != null) {
					String urlString = "file://localhost/" + filePath.replace("\\", "/");

					try {
						List<FeatureOfInterest> foiList = ApogyCoreFacade.INSTANCE
								.loadFeatureOfInterestFromFile(urlString);

						if (foiList.size() > 0) {
							Logger.info("Loaded <" + foiList.size() + "> Feature of Interest from file<" + urlString
									+ ">.");

							FeaturesOfInterestMapLayer layer = ApogySurfaceEnvironmentFactory.eINSTANCE
									.createFeaturesOfInterestMapLayer();
							layer.setFeatures(ApogyCoreFactory.eINSTANCE.createFeatureOfInterestList());
							layer.getFeatures().getFeaturesOfInterest().addAll(foiList);
							layer.setName(ApogyCommonEMFFacade.INSTANCE.getDefaultName(getMap(), layer,
									ApogySurfaceEnvironmentPackage.Literals.MAP__LAYERS));
							layer.setDescription("Feature Of Interest imported from file <" + filePath + ">.");

							ApogyCommonTransactionFacade.INSTANCE.basicAdd(getMap(),
									ApogySurfaceEnvironmentPackage.Literals.MAP__LAYERS, layer);

							// Forces the viewer to refresh its input.
							if (!FeaturesOfInterestMapLayersListComposite.this.treeViewer.isBusy()) {
								FeaturesOfInterestMapLayersListComposite.this.treeViewer.setInput(getMap());
							}
						} else {
							Logger.error("Could not load any Feature of Interest from file<" + urlString + ">.");
						}

					} catch (Exception ex) {
						Logger.error("Failed to import Feature of Interests from file<" + urlString + ">.", ex);
					}
				}
			}

			@Override
			public void widgetDefaultSelected(SelectionEvent e) {
			}
		});

		this.btnExport = new Button(composite, SWT.NONE);
		this.btnExport.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
		this.btnExport.setSize(74, 29);
		this.btnExport.setText("Export");
		this.btnExport.setToolTipText("Export the selected list of Feature Of Interest to file.");
		this.btnExport.setEnabled(false);
		this.btnExport.addSelectionListener(new SelectionListener() {

			@Override
			public void widgetSelected(SelectionEvent e) {

				Iterator<FeaturesOfInterestMapLayer> foiMapsLayers = getSelectedFeatureOfInterestMapLayers().iterator();
				while (foiMapsLayers.hasNext()) {
					FeaturesOfInterestMapLayer foiMapLayer = foiMapsLayers.next();

					FileDialog fd = new FileDialog(getShell(), SWT.SAVE);
					fd.setText("Save Features Of Interest Map Layer named <" + foiMapLayer.getName() + ">.");
					fd.setFilterPath(path);
					fd.setFilterExtensions(new String[] { "*.csv" });
					fd.setFileName("unnamed.csv");
					fd.setOverwrite(true);

					String filePath = fd.open();

					if (filePath != null) {
						String urlString = "file://localhost/" + filePath.replace("\\", "/");

						try {
							ApogyCoreFacade.INSTANCE.saveFeatureOfInterestToFile(filePath,
									foiMapLayer.getFeatures().getFeaturesOfInterest());
						} catch (Exception ex) {
							Logger.error("Failed to export Feature of Interests from file<" + urlString + ">.", ex);
						}
					}
				}
			}

			@Override
			public void widgetDefaultSelected(SelectionEvent e) {
			}
		});

		// Dispose
		addDisposeListener(new DisposeListener() {
			@Override
			public void widgetDisposed(DisposeEvent e) {
				if (FeaturesOfInterestMapLayersListComposite.this.m_bindingContext != null) {
					FeaturesOfInterestMapLayersListComposite.this.m_bindingContext.dispose();
				}
			}
		});
	}

	public Map getMap() {
		return this.map;
	}

	public void setMap(Map newMap) {
		if (this.m_bindingContext != null) {
			this.m_bindingContext.dispose();
		}

		this.map = newMap;

		if (newMap != null) {
			this.m_bindingContext = customInitDataBindings();
			this.treeViewer.setInput(newMap);

			List<FeaturesOfInterestMapLayer> layers = filterMap(newMap);
			if (!layers.isEmpty()) {
				this.treeViewer.setSelection(new StructuredSelection(layers.get(0)), true);
			} else {
				this.treeViewer.setSelection(null, true);
			}
		}
	}

	@SuppressWarnings("unchecked")
	public List<FeaturesOfInterestMapLayer> getSelectedFeatureOfInterestMapLayers() {
		return ((IStructuredSelection) this.treeViewer.getSelection()).toList();
	}

	protected void newFeaturesOfInterestMapLayerSelected(FeaturesOfInterestMapLayer newFeaturesOfInterestMapLayer) {
	}

	protected DataBindingContext customInitDataBindings() {
		DataBindingContext bindingContext = new DataBindingContext();

		IObservableValue<?> observeSingleSelectionViewer = ViewerProperties.singleSelection().observe(this.treeViewer);

		/* Delete Button Enabled Binding. */
		IObservableValue<?> observeEnabledBtnDeleteObserveWidget = WidgetProperties.enabled().observe(this.btnDelete);
		bindingContext.bindValue(observeEnabledBtnDeleteObserveWidget, observeSingleSelectionViewer, null,
				new UpdateValueStrategy(UpdateValueStrategy.POLICY_UPDATE)
						.setConverter(new Converter(Object.class, Boolean.class) {
							@Override
							public Object convert(Object fromObject) {
								return fromObject != null;
							}
						}));

		/* Export Button Enabled Binding. */
		IObservableValue<?> observeEnabledBtnExportObserveWidget = WidgetProperties.enabled().observe(this.btnExport);
		bindingContext.bindValue(observeEnabledBtnExportObserveWidget, observeSingleSelectionViewer, null,
				new UpdateValueStrategy(UpdateValueStrategy.POLICY_UPDATE)
						.setConverter(new Converter(Object.class, Boolean.class) {
							@Override
							public Object convert(Object fromObject) {
								return fromObject != null;
							}
						}));

		return bindingContext;
	}

	protected List<FeaturesOfInterestMapLayer> filterMap(Map map) {
		List<FeaturesOfInterestMapLayer> layers = new ArrayList<FeaturesOfInterestMapLayer>();
		for (AbstractMapLayer layer : map.getLayers()) {
			if (layer instanceof FeaturesOfInterestMapLayer) {
				layers.add(((FeaturesOfInterestMapLayer) layer));
			}
		}

		return layers;
	}

	private class CustomContentProvider implements ITreeContentProvider {
		@Override
		public void dispose() {
		}

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

		@Override
		public Object[] getElements(Object inputElement) {
			if (inputElement instanceof Map) {
				Map map = (Map) inputElement;

				// Keeps only FeaturesOfInterestMapLayer.
				return filterMap(map).toArray();
			}

			return null;
		}

		@Override
		public Object[] getChildren(Object parentElement) {
			if (parentElement instanceof Map) {
				Map map = (Map) parentElement;

				// Keeps only FeaturesOfInterestMapLayer.
				return filterMap(map).toArray();
			}

			return null;
		}

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

		@Override
		public boolean hasChildren(Object element) {
			if (element instanceof Map) {
				Map map = (Map) element;
				return !filterMap(map).isEmpty();
			} else {
				return false;
			}
		}
	}
}