bundles/core/org.eclipse.apogy.core.ui/src/org/eclipse/apogy/core/ui/composites/PositionedResultSearchComposite.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.ui.composites;

import java.util.Collection;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;

import org.eclipse.apogy.common.emf.ApogyCommonEMFFactory;
import org.eclipse.apogy.common.emf.CompositeComparator;
import org.eclipse.apogy.common.emf.CompositeFilter;
import org.eclipse.apogy.common.emf.EComparator;
import org.eclipse.apogy.common.emf.IFilter;
import org.eclipse.apogy.common.emf.ui.composites.ComparatorDetailsComposite;
import org.eclipse.apogy.common.emf.ui.composites.CompositeComparatorComposite;
import org.eclipse.apogy.common.emf.ui.composites.CompositeFilterComposite;
import org.eclipse.apogy.common.emf.ui.composites.FilterDetailsComposite;
import org.eclipse.apogy.core.PositionedResult;
import org.eclipse.swt.SWT;
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.Group;

public class PositionedResultSearchComposite extends Composite {
	// Filters.
	private CompositeFilter<PositionedResult> compositeFilter = ApogyCommonEMFFactory.eINSTANCE.createCompositeFilter();
	private final CompositeFilterComposite<PositionedResult> compositeFilterComposite;
	private final FilterDetailsComposite<PositionedResult> filterDetailsComposite;
	private final Button btnApplyFilters;

	// Sorters
	private CompositeComparator<PositionedResult> compositeComparator = ApogyCommonEMFFactory.eINSTANCE
			.createCompositeComparator();
	private final CompositeComparatorComposite<PositionedResult> compositeComparatorComposite;
	private final ComparatorDetailsComposite<PositionedResult> comparatorDetailsComposite;
	private final Button btnSort;

	public PositionedResultSearchComposite(Composite parent, int style) {
		super(parent, style);

		setLayout(new GridLayout(1, false));

		Composite top = new Composite(this, SWT.NONE);
		top.setLayout(new GridLayout(2, true));
		top.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false, 1, 1));

		// Filters
		Group grpFilters = new Group(top, SWT.NONE);
		grpFilters.setLayout(new GridLayout(1, false));
		grpFilters.setLayoutData(new GridData(SWT.FILL, SWT.TOP, false, false, 1, 1));
		grpFilters.setText("Filters");

		// Composite Filter
		this.compositeFilterComposite = new CompositeFilterComposite<PositionedResult>(grpFilters, SWT.NONE) {
			@Override
			protected void newSelection(IFilter<PositionedResult> filter) {
				PositionedResultSearchComposite.this.filterDetailsComposite.setFilter(filter);
			}
		};
		this.compositeFilterComposite.setCompositeFilter(this.compositeFilter);
		GridData gd_compositeFilterComposite = new GridData(SWT.FILL, SWT.TOP, true, false, 1, 1);
		gd_compositeFilterComposite.heightHint = 150;
		gd_compositeFilterComposite.minimumHeight = 150;
		this.compositeFilterComposite.setLayoutData(gd_compositeFilterComposite);

		// Filter Details.
		this.filterDetailsComposite = new FilterDetailsComposite<PositionedResult>(grpFilters, SWT.NONE);
		GridData gd_filterDetailsComposite = new GridData(SWT.FILL, SWT.TOP, true, false, 1, 1);
		gd_filterDetailsComposite.heightHint = 100;
		gd_filterDetailsComposite.minimumWidth = 300;
		gd_filterDetailsComposite.widthHint = 300;
		gd_filterDetailsComposite.minimumHeight = 100;
		this.filterDetailsComposite.setLayoutData(gd_filterDetailsComposite);

		this.btnApplyFilters = new Button(grpFilters, SWT.PUSH);
		this.btnApplyFilters.setText("Apply Filters");
		this.btnApplyFilters.addSelectionListener(new SelectionListener() {

			@Override
			public void widgetSelected(SelectionEvent e) {
				applyFilter();
			}

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

		// Sorters
		Group grpSorters = new Group(top, SWT.NONE);
		grpSorters.setLayout(new GridLayout(1, false));
		grpSorters.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false, 1, 1));
		grpSorters.setText("Sorters");

		// Composite Comparator
		this.compositeComparatorComposite = new CompositeComparatorComposite<PositionedResult>(grpSorters, SWT.NONE) {
			@Override
			protected void newSelection(EComparator<PositionedResult> filter) {
				PositionedResultSearchComposite.this.comparatorDetailsComposite.setComparator(filter);
			}
		};
		this.compositeComparatorComposite.setCompositeComparator(this.compositeComparator);
		GridData gd_compositeComparatorComposite = new GridData(SWT.FILL, SWT.TOP, true, false, 1, 1);
		gd_compositeComparatorComposite.heightHint = 150;
		gd_compositeComparatorComposite.minimumHeight = 150;
		this.compositeComparatorComposite.setLayoutData(gd_compositeComparatorComposite);

		this.comparatorDetailsComposite = new ComparatorDetailsComposite<PositionedResult>(grpSorters, SWT.NONE);
		GridData gd_comparatorDetailsComposite = new GridData(SWT.FILL, SWT.FILL, true, false, 1, 1);
		gd_comparatorDetailsComposite.heightHint = 100;
		gd_comparatorDetailsComposite.minimumHeight = 100;
		gd_comparatorDetailsComposite.widthHint = 300;
		gd_comparatorDetailsComposite.minimumWidth = 300;
		this.comparatorDetailsComposite.setLayoutData(gd_comparatorDetailsComposite);

		this.btnSort = new Button(grpSorters, SWT.PUSH);
		this.btnSort.setText("Sort");
		this.btnSort.addSelectionListener(new SelectionListener() {

			@Override
			public void widgetSelected(SelectionEvent e) {
				applySorter();
			}

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

	public Collection<PositionedResult> applyFilter(List<PositionedResult> input) {
		return this.compositeFilter.filter(input);
	}

	public SortedSet<PositionedResult> sort(Collection<PositionedResult> input) {
		SortedSet<PositionedResult> sorted = new TreeSet<PositionedResult>(this.compositeComparator);
		sorted.addAll(input);
		return sorted;
	}

	public CompositeFilter<PositionedResult> getCompositeFilter() {
		return this.compositeFilter;
	}

	public void setCompositeFilter(CompositeFilter<PositionedResult> compositeFilter) {
		this.compositeFilter = compositeFilter;
		this.compositeFilterComposite.setCompositeFilter(compositeFilter);
	}

	public CompositeComparator<PositionedResult> getCompositeComparator() {
		return this.compositeComparator;
	}

	public void setCompositeComparator(CompositeComparator<PositionedResult> compositeComparator) {
		this.compositeComparator = compositeComparator;
		this.compositeComparatorComposite.setCompositeComparator(compositeComparator);
	}

	protected void applyFilter() {
	}

	protected void applySorter() {
	}
}