plugins/org.eclipse.emf.eef.runtime/src/org/eclipse/emf/eef/runtime/ui/widgets/ElementSelectionDialog.java

/*******************************************************************************
 * Copyright (c) 2008, 2011 Obeo.
 * 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:
 *     Obeo - initial API and implementation
 *******************************************************************************/
package org.eclipse.emf.eef.runtime.ui.widgets;

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

import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
import org.eclipse.emf.eef.runtime.impl.utils.ModelViewerHelper;
import org.eclipse.emf.eef.runtime.ui.utils.EEFLabelProvider;
import org.eclipse.emf.eef.runtime.ui.utils.EEFRuntimeUIMessages;
import org.eclipse.emf.eef.runtime.ui.widgets.referencestable.ReferencesTableSettings;
import org.eclipse.emf.eef.runtime.ui.widgets.settings.AdvancedEEFEditorContentProvider;
import org.eclipse.emf.eef.runtime.ui.widgets.settings.EEFEditorSettings;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
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.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
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.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.ui.dialogs.FilteredTree;
import org.eclipse.ui.dialogs.PatternFilter;

/**
 * This dialog shows the tree of all owned element by taking in account a filter
 * 
 * @author Patrick Tessier
 * @author <a href="mailto:jerome.benois@obeo.fr">Jerome Benois</a>
 * @author <a href="mailto:stephane.bouchet@obeo.fr">Stephane Bouchet</a>
 * @author <a href="mailto:stephane.thibaudeau@obeo.fr">Stephane Thibaudeau</a>
 */
public abstract class ElementSelectionDialog extends Dialog implements IPropertiesFilteredWidget {

	/**
	 * the label
	 */
	protected Label label;

	/**
	 * The selection tree.
	 */
	protected Tree tree;

	/** title of the window */
	protected String title = EEFRuntimeUIMessages.TabElementTreeSelectionDialog_title;

	/**
	 * filters
	 */
	private List<ViewerFilter> viewerFilters;

	/**
	 * business rules filters
	 */
	private List<ViewerFilter> brFilters;

	/**
	 * The adapter factory.
	 */
	protected AdapterFactory adapterFactory;

	private Composite parent;

	private Object input;

	private IStructuredSelection selection;

	/**
	 * Constructor with parent shell and Element.
	 * 
	 * @param parentElement
	 *            the element where we look for a children
	 * @param filters
	 *            this is an array of filter see {@link ViewerFilter} or an example {@link OperationFilter}
	 * @param title
	 *            title of the window
	 * @param createElement
	 *            this is the listener to create an element
	 * @param abstractElement
	 *            it used to inform about if the element is abstract in this case the creation button does not
	 *            appear
	 * @param mainResource
	 *            the main resource.
	 */
	public ElementSelectionDialog(Object input, List<ViewerFilter> filters,
			List<ViewerFilter> brFilters, String title, AdapterFactory adapterFactory) {
		super(Display.getDefault().getActiveShell());
		// add the resize ability to the window
		setShellStyle(SWT.RESIZE | super.getShellStyle());
		this.input = input;
		this.viewerFilters = filters;
		this.brFilters = brFilters;
		this.title = title;
		this.adapterFactory = adapterFactory;
	}

	/**
	 * Creates the dialog area.
	 * 
	 * @param parent
	 *            composite.
	 * @return control Control.
	 */
	protected Control createDialogArea(Composite parent) {
		this.parent = parent;

		return fillModelpage(parent);
	}

	/**
	 * Used to display a page
	 * 
	 * @param parent
	 *            composite which contains the tree
	 * @return the composite of this page
	 */
	public Control fillModelpage(Composite parent) {
		Composite composite = new Composite(parent, SWT.None);
		GridLayout layout = new GridLayout();
		layout.marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
		layout.marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
		layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
		layout.horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
		composite.setLayout(layout);

		// use pattern filter
		PatternFilter patternFilter = new TreeSelectionPatternFilter();
		patternFilter.setIncludeLeadingWildcard(true);

		FilteredTree filteredTree = new FilteredTree(composite, SWT.SINGLE | SWT.BORDER | SWT.V_SCROLL
				| SWT.RESIZE, patternFilter, true);
		// use of EMF facilities
		final TreeViewer treeViewer = filteredTree.getViewer();
		treeViewer.setFilters(new ViewerFilter[0]);
		treeViewer.setUseHashlookup(true);
		if (input instanceof EEFEditorSettings)
			treeViewer.setContentProvider(new HideResourcesContentProvider(new AdvancedEEFEditorContentProvider(adapterFactory)));
		else
			treeViewer.setContentProvider(new HideResourcesContentProvider(new AdapterFactoryContentProvider(adapterFactory)));

		ArrayList<ViewerFilter> filters = new ArrayList<ViewerFilter>();
		if (viewerFilters != null && !viewerFilters.isEmpty()) {
			for (ViewerFilter filter : viewerFilters) {
				filters.add(filter);
			}
		}
		// for now, add the businessRuleFilters to the 'normal' filters
		if (brFilters != null && !brFilters.isEmpty()) {
			for (ViewerFilter filter : brFilters) {
				filters.add(filter);
			}
		}
		filters.add(patternFilter);
		ViewerFilter[] v = filters.toArray(new ViewerFilter[filters.size()]);
		treeViewer.setFilters(v);
		treeViewer.setLabelProvider(new EEFLabelProvider() {
			
			@Override
			public Color getForeground(Object element) {
				if (input instanceof ReferencesTableSettings && element instanceof EObject && ((ReferencesTableSettings) input).contains((EObject) element)) {
					return getShell().getDisplay()
							.getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW);
				}
				
				return super.getForeground(element);
			}

		});

		filteredTree.setLayoutData(new GridData(550, 300));
		// handle selection change
		if (input instanceof EEFEditorSettings) {
			treeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
				public void selectionChanged(SelectionChangedEvent event) {
					if (event.getSelection() instanceof IStructuredSelection) {
						// Check selection
						IStructuredSelection structuredSelection = (IStructuredSelection)event.getSelection();
						if (structuredSelection != null && !structuredSelection.isEmpty()) {
							Object o = structuredSelection.getFirstElement();
							// Check type matching
							Button okButton = getButton(IDialogConstants.OK_ID);
							if (((List<?>)((EEFEditorSettings)input).choiceOfValues(adapterFactory)).contains(o)) {
								if (input instanceof ReferencesTableSettings) {
									if (o instanceof EObject && !((ReferencesTableSettings) input).contains((EObject) o)) {
										selection = structuredSelection;
										if (okButton != null) {
											okButton.setEnabled(true);
										}
									} else {
										// Reject selection
										if (okButton != null) {
											okButton.setEnabled(false);
										}
									}
								} else {
									selection = structuredSelection;
									if (okButton != null) {
										okButton.setEnabled(true);
									}
								}
							} else {
								// Reject selection
								if (okButton != null) {
									okButton.setEnabled(false);
								}
							}
						}

					}
				}
			});

			// handle double click to validate
			treeViewer.addDoubleClickListener(new IDoubleClickListener() {
				public void doubleClick(DoubleClickEvent event) {
					if (selection != null && !selection.isEmpty()) {
						Object o = selection.getFirstElement();
						if (((List<?>)((EEFEditorSettings)input).choiceOfValues(adapterFactory)).contains(o) && input instanceof ReferencesTableSettings && o instanceof EObject && !((ReferencesTableSettings) input).contains((EObject) o)) {
							okPressed();
						}
					}
				}
			});
		}
		treeViewer.setInput(input);

		// Init selected element
		if (selection != null) {
			treeViewer.setSelection(selection);
		}

		return composite;

	}
	
	/**
	 * ContentProvider which delegates almost everything to another ContentProvider.
	 * The purpose is to hide the Resource and display only their contents
	 *
	 */
	private class HideResourcesContentProvider implements ITreeContentProvider {
		private ITreeContentProvider delegateContentProvider;

		public HideResourcesContentProvider(ITreeContentProvider delegateContentProvider) {
			this.delegateContentProvider = delegateContentProvider;
		}
		
		public Object[] getElements(Object inputElement) {
			// Retrieve elements provided by the delegate content provider
			Object[] elements = delegateContentProvider.getElements(inputElement);
			List<Object> newElements = new ArrayList<Object>();
			for (Object element : elements) {
				// When an element is a resource, return its contents instead of the resource itself
				if (element instanceof Resource) {
					newElements.addAll(((Resource)element).getContents());
				} else {
					newElements.add(element);
				}
			}
			return newElements.toArray();
		}
		
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			delegateContentProvider.inputChanged(viewer, oldInput, newInput);
		}
		
		public Object[] getChildren(Object parentElement) {
			return delegateContentProvider.getChildren(parentElement);
		}
		
		public Object getParent(Object element) {
			return delegateContentProvider.getParent(element);
		}
		
		public boolean hasChildren(Object element) {
			return delegateContentProvider.hasChildren(element);
		}

		public void dispose() {
			delegateContentProvider.dispose();
		}
	}

	private class TreeSelectionPatternFilter extends PatternFilter {
		@Override
		protected boolean isParentMatch(Viewer viewer, Object element) {
			Object[] children = ((ITreeContentProvider)((AbstractTreeViewer)viewer).getContentProvider())
					.getChildren(element);
			// apply all filters
			if (viewerFilters != null && !viewerFilters.isEmpty() && children != null) {
				// if one child match, show the parent in tree
				for (ViewerFilter viewerFilter : viewerFilters) {
					for (Object child : children) {
						if (viewerFilter.select(viewer, null, child)) {
							return super.isParentMatch(viewer, element);
						}
					}
				}
				return false;
			} else {
				return super.isParentMatch(viewer, element);
			}
		}

		@Override
		protected boolean isLeafMatch(Viewer viewer, Object element) {
			if (element instanceof EObject) {
				String labelText = ((EObject)element).toString();
				if (labelText != null) {
					return wordMatches(labelText);
				}
			}
			return false;
		}
	}

	/**
	 * Sets or clears the input for this dialog.
	 */
	public void setInput(Object input) {
		this.input = input;
		this.refresh();
	}

	public void refresh() {
		parent.pack();
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected void configureShell(Shell shell) {
		super.configureShell(shell);
		shell.setText(EEFRuntimeUIMessages.TabElementTreeSelectionDialog_shell_title + this.title);
	}

	/**
	 * @see org.eclipse.jface.dialogs.Dialog#okPressed()
	 */
	@Override
	protected void okPressed() {
		if (selection != null && !selection.isEmpty()) {
			process(selection);
			ModelViewerHelper.setLastSelection(selection);
		}
		super.okPressed();
	}

	public void setSelection(IStructuredSelection selection) {
		this.selection = selection;
	}

	public abstract void process(IStructuredSelection selection);

	public void addBusinessRuleFilter(ViewerFilter filter) {
		this.brFilters.add(filter);
	}

	public void addFilter(ViewerFilter filter) {
		this.viewerFilters.add(filter);
	}

	public void removeBusinessRuleFilter(ViewerFilter filter) {
		this.brFilters.remove(filter);
	}

	public void removeFilter(ViewerFilter filter) {
		this.viewerFilters.remove(filter);
	}

}