bundles/core/org.eclipse.apogy.core.invocator.ui/src/org/eclipse/apogy/core/invocator/ui/composites/TypeMembersListComposite.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,
 *     Olivier L. Larouche - initial API and implementation
 *
 * SPDX-License-Identifier: EPL-1.0
 *     
 *******************************************************************************/
package org.eclipse.apogy.core.invocator.ui.composites;

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.ApogyCommonEMFUIFactory;
import org.eclipse.apogy.common.emf.ui.MapBasedEClassSettings;
import org.eclipse.apogy.common.emf.ui.wizards.ApogyEObjectWizard;
import org.eclipse.apogy.core.invocator.ApogyCoreInvocatorPackage;
import org.eclipse.apogy.core.invocator.Type;
import org.eclipse.apogy.core.invocator.TypeMember;
import org.eclipse.apogy.core.invocator.ui.ApogyCoreInvocatorUIRCPConstants;
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.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.Listener;
import org.eclipse.swt.widgets.Tree;

public class TypeMembersListComposite extends Composite {
	private Type type;

	private final Tree tree;
	private final TreeViewer treeViewer;

	private final Button btnNew;
	private final Button btnDelete;

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

	public TypeMembersListComposite(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, true, true, 1, 1);
		gd_tree.widthHint = 200;
		gd_tree.minimumWidth = 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) {
				TypeMember selectedTypeMember = (TypeMember) ((IStructuredSelection) event.getSelection())
						.getFirstElement();
				newTypeMemberSelected(selectedTypeMember);
			}
		});

		// 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.setToolTipText("Create a new Type Member.");
		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) {
					MapBasedEClassSettings settings = ApogyCommonEMFUIFactory.eINSTANCE.createMapBasedEClassSettings();
					String name = ApogyCommonEMFFacade.INSTANCE.getDefaultName(getType(), null,
							ApogyCoreInvocatorPackage.Literals.TYPE__MEMBERS);

					settings.getUserDataMap().put(ApogyCoreInvocatorUIRCPConstants.NAME_ID, name);
					settings.getUserDataMap().put(ApogyCoreInvocatorUIRCPConstants.TYPE_ID, getType());

					Wizard wizard = new ApogyEObjectWizard(ApogyCoreInvocatorPackage.Literals.TYPE__MEMBERS, getType(),
							settings, ApogyCoreInvocatorPackage.Literals.TYPE_MEMBER);
					WizardDialog dialog = new WizardDialog(getShell(), wizard);
					dialog.open();

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

		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.setToolTipText("Deletes the selected Type Member(s).");
		this.btnDelete.setEnabled(false);
		this.btnDelete.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent event) {
				String deleteMessage = "";

				Iterator<TypeMember> bindingsIterator = getSelectedBindings().iterator();
				while (bindingsIterator.hasNext()) {
					TypeMember binding = bindingsIterator.next();
					deleteMessage = deleteMessage + binding.getName();

					if (bindingsIterator.hasNext()) {
						deleteMessage = deleteMessage + ", ";
					}
				}

				MessageDialog dialog = new MessageDialog(null, "Delete the selected Type Member(s)", null,
						"Are you sure to delete these Type Member(s) : " + deleteMessage, MessageDialog.QUESTION,
						new String[] { "Yes", "No" }, 1);
				int result = dialog.open();
				if (result == 0) {
					List<TypeMember> toRemove = getSelectedBindings();
					ApogyCommonTransactionFacade.INSTANCE.basicRemove(getType(),
							ApogyCoreInvocatorPackage.Literals.TYPE__MEMBERS, toRemove);
				}

				// Forces the viewer to refresh its input.
				if (!TypeMembersListComposite.this.treeViewer.isBusy()) {
					TypeMembersListComposite.this.treeViewer.setSelection(new StructuredSelection());
					TypeMembersListComposite.this.treeViewer.refresh();
				}
			}
		});

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

	public Type getType() {
		return this.type;
	}

	public void setType(Type newType) {
		if (this.m_bindingContext != null)
			this.m_bindingContext.dispose();

		this.type = newType;

		if (newType != null) {
			this.m_bindingContext = initDataBindingsCustom();
		}

		this.treeViewer.setInput(newType);
	}

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

	protected void newTypeMemberSelected(TypeMember selectedTypeMember) {
	}

	private DataBindingContext initDataBindingsCustom() {
		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;
							}
						}));

		return bindingContext;
	}

	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 Type) {
				Type type = (Type) inputElement;
				return type.getMembers().toArray();
			}

			return null;
		}

		@Override
		public Object[] getChildren(Object parentElement) {
			if (parentElement instanceof Type) {
				Type type = (Type) parentElement;
				return type.getMembers().toArray();
			}

			return null;
		}

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

		@Override
		public boolean hasChildren(Object element) {
			if (element instanceof Type) {
				Type type = (Type) element;
				return type.getMembers().isEmpty();
			} else {
				return false;
			}
		}
	}
}