EDIT

    <elements xsi:type="basic:PartDescriptor" xmi:id="_namYwB7xEemDKJyLc5CJfQ" elementId="eu.etaxonomy.taxeditor.store.partdescriptor.termsearch" label="Term Search" closeable="true" contributionURI="bundleclass://eu.etaxonomy.taxeditor.store/eu.etaxonomy.taxeditor.view.search.facet.term.TermSearch"/>

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.view.search.facet;

/**

 * @author pplitzner

 * @since Jan 24, 2019

 *

 */

public class Facet {

    private String category;

    private String facet;

    public Facet(String facet) {

        this(facet, null);

    }

    public Facet(String facet, String category) {

        this.category = category;

        this.facet = facet;

    }

    public String getCategory() {

        return category;

    }

    public String getFacet() {

        return facet;

    }

    @Override

    public int hashCode() {

        final int prime = 31;

        int result = 1;

        result = prime * result + ((category == null) ? 0 : category.hashCode());

        result = prime * result + ((facet == null) ? 0 : facet.hashCode());

        return result;

    }

    @Override

    public boolean equals(Object obj) {

        if (this == obj) {

            return true;

        }

        if (obj == null) {

            return false;

        }

        if (getClass() != obj.getClass()) {

            return false;

        }

        Facet other = (Facet) obj;

        if (category == null) {

            if (other.category != null) {

                return false;

            }

        } else if (!category.equals(other.category)) {

            return false;

        }

        if (facet == null) {

            if (other.facet != null) {

                return false;

            }

        } else if (!facet.equals(other.facet)) {

            return false;

        }

        return true;

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.view.search.facet;

import org.eclipse.jface.layout.GridDataFactory;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Label;

/**

 * @author pplitzner

 * @since Jan 23, 2019

 *

 */

public class FilterComposite extends Composite{

    private Button btnCheck;

    private Facet facet;

    public FilterComposite(Facet facet, SearchController controller, Composite parent, int style) {

        super(parent, style);

        this.facet = facet;

        GridDataFactory.fillDefaults().applyTo(this);

        setLayout(new GridLayout(2, false));

        btnCheck = new Button(this, SWT.CHECK);

        btnCheck.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                controller.applyFilter(FilterComposite.this);

            }

        });

        btnCheck.setSelection(true);

        Composite content = new Composite(this, SWT.NONE);

        GridDataFactory.fillDefaults().applyTo(content);

        content.setLayout(new GridLayout());

        Label label = new Label(content, SWT.NONE);

        label.setText(facet.getFacet());

        GridDataFactory.fillDefaults().applyTo(label);

    }

    public boolean isFilterActive() {

        return btnCheck.getSelection();

    }

    public Facet getFacet() {

        return facet;

    }

}

// $Id$

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.view.search.facet;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.ScrolledComposite;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Text;

/**

 * @author pplitzner

 * @date 22.01.2019

 *

 */

public class SearchComposite extends Composite {

    private Text txtSearch;

    private ScrolledComposite filterScrolledComposite;

    private Composite filterListComposite;

    private Composite searchResultComposite;

    private ScrolledComposite resultScrolledComposite;

    /**

     * Create the composite.

     * @param parent

     * @param style

     */

    public SearchComposite(Composite parent, int style) {

        super(parent, style);

        setLayout(new GridLayout(2, false));

        Composite filterComposite = new Composite(this, SWT.NONE);

        filterComposite.setLayout(new GridLayout(1, false));

        GridData gd_filterComposite = new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1);

        gd_filterComposite.widthHint = 170;

        filterComposite.setLayoutData(gd_filterComposite);

        txtSearch = new Text(filterComposite, SWT.BORDER);

        txtSearch.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false, 1, 1));

        filterScrolledComposite = new ScrolledComposite(filterComposite, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);

        filterScrolledComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));

        filterScrolledComposite.setExpandHorizontal(true);

        filterScrolledComposite.setExpandVertical(true);

        initFilterList();

        Composite composite_1 = new Composite(this, SWT.NONE);

        composite_1.setLayout(new GridLayout(1, false));

        composite_1.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));

        resultScrolledComposite = new ScrolledComposite(composite_1, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);

        resultScrolledComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));

        resultScrolledComposite.setExpandHorizontal(true);

        resultScrolledComposite.setExpandVertical(true);

        initSearchResultList();

    }

    private void initSearchResultList() {

        searchResultComposite = new Composite(resultScrolledComposite, SWT.NONE);

        searchResultComposite.setLayout(new GridLayout(1, false));

        resultScrolledComposite.setContent(searchResultComposite);

        resultScrolledComposite.setMinSize(searchResultComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT));

    }

    private void initFilterList() {

        filterListComposite = new Composite(filterScrolledComposite, SWT.NONE);

        filterListComposite.setLayout(new GridLayout(1, false));

        filterScrolledComposite.setContent(filterListComposite);

        filterScrolledComposite.setMinSize(filterListComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT));

    }

    @Override

    protected void checkSubclass() {

        // Disable the check that prevents subclassing of SWT components

    }

    public Text getTxtSearch() {

        return txtSearch;

    }

    public Composite getFilterListComposite() {

        return filterListComposite;

    }

    public void clear(){

        filterListComposite.dispose();

        initFilterList();

        clearResults();

    }

    public void clearResults() {

        searchResultComposite.dispose();

        initSearchResultList();

    }

    public void refresh(){

        filterScrolledComposite.layout(true, true);

        filterScrolledComposite.setMinSize(filterListComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT));

        resultScrolledComposite.layout(true, true);

        resultScrolledComposite.setMinSize(searchResultComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT));

    }

    public Composite getSearchResultComposite() {

        return searchResultComposite;

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.view.search.facet;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.KeyListener;

/**

 * @author pplitzner

 * @since Jan 22, 2019

 *

 */

public abstract class SearchController implements KeyListener{

    private SearchComposite composite;

    private List<SearchResult> searchResults = new ArrayList<>();

    private Set<Facet> appliedFacets = new HashSet<>();

    public SearchController(SearchComposite composite) {

        this.composite = composite;

        composite.getTxtSearch().addKeyListener(this);

    }

    protected abstract List<SearchResult> searchResults(String searchString);

    private void search(String searchString){

        searchResults.clear();

        searchResults = searchResults(searchString);

        Set<Facet> facets = createResults(searchResults);

        createFilterButtons(facets);

        composite.refresh();

    }

    private void createFilterButtons(Set<Facet> facets) {

        for (Facet facet : facets) {

            FilterComposite filterComposite = new FilterComposite(facet, this, composite.getFilterListComposite(), SWT.NONE);

            appliedFacets.add(facet);

        }

    }

    private Set<Facet> createResults(List<SearchResult> results) {

        Set<Facet> facets = new HashSet<>();

        for (SearchResult result : results) {

            createResultComposite(result);

            facets.addAll(result.getFacets());

        }

        return facets;

    }

    private void createResultComposite(SearchResult result) {

        new SearchResultComposite(result, composite.getSearchResultComposite(), SWT.NONE);

    }

    @Override

    public void keyPressed(KeyEvent e) {

        if(e.keyCode==SWT.CR && e.widget==composite.getTxtSearch()){

            composite.clear();

            search(composite.getTxtSearch().getText());

        }

    }

    @Override

    public void keyReleased(KeyEvent e) {

    }

    public void applyFilter(FilterComposite filterComposite) {

        composite.clearResults();

        Facet facet = filterComposite.getFacet();

        if(filterComposite.isFilterActive()){

            appliedFacets.add(facet);

        }

        else{

            appliedFacets.remove(facet);

        }

        for (SearchResult searchResult : searchResults) {

            if(searchResult.hasAnyFacet(appliedFacets)){

                createResultComposite(searchResult);

            }

        }

        composite.refresh();

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.view.search.facet;

import java.util.HashSet;

import java.util.Set;

/**

 * @author pplitzner

 * @since Jan 23, 2019

 *

 * @param <T> The type of the search result

 */

public abstract class SearchResult<T> {

    private Set<Facet> facets = new HashSet<>();

    private T content;

    public SearchResult(T content) {

        super();

        this.content = content;

        facets = initFacets(content);

    }

    protected abstract Set<Facet> initFacets(T content);

    public boolean hasFacet(Facet facet){

        return facets.contains(facet);

    }

    public boolean hasAnyFacet(Set<Facet> facets){

        return facets.stream().anyMatch(facet->this.facets.contains(facet));

    }

    public T getContent() {

        return content;

    }

    public Set<Facet> getFacets() {

        return facets;

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.view.search.facet;

import org.eclipse.jface.layout.GridDataFactory;

import org.eclipse.swt.SWT;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Label;

/**

 * @author pplitzner

 * @since Jan 23, 2019

 *

 */

public class SearchResultComposite extends Composite {

    /**

     * Create the composite.

     * @param result

     * @param parent

     * @param style

     */

    public SearchResultComposite(SearchResult result, Composite parent, int style) {

        super(parent, style);

        setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));

        setLayout(new GridLayout());

        Label label = new Label(parent, SWT.NONE);

        label.setText(result.getContent().toString());

        GridDataFactory.fillDefaults().applyTo(label);

    }

    @Override

    protected void checkSubclass() {

        // Disable the check that prevents subclassing of SWT components

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.view.search.facet.term;

import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;

/**

 * @author pplitzner

 * @since Jan 22, 2019

 *

 */

public class TermFilter {

    private TermVocabularyDto vocabulary;

    /**

     * @param vocabulary

     */

    public TermFilter(TermVocabularyDto vocabulary) {

        super();

        this.vocabulary = vocabulary;

    }

    /**

     * @return the vocabulary

     */

    public TermVocabularyDto getVocabulary() {

        return vocabulary;

    }

    /**

     * @param vocabulary the vocabulary to set

     */

    public void setVocabulary(TermVocabularyDto vocabulary) {

        this.vocabulary = vocabulary;

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.view.search.facet.term;

import javax.annotation.PostConstruct;

import javax.inject.Named;

import org.eclipse.e4.core.contexts.IEclipseContext;

import org.eclipse.e4.ui.services.EMenuService;

import org.eclipse.e4.ui.services.IServiceConstants;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Shell;

import eu.etaxonomy.taxeditor.view.search.facet.SearchComposite;

/**

 * @author pplitzner

 * @since Jan 22, 2019

 *

 */

public class TermSearch {

    @PostConstruct

    public void create(Composite parent, IEclipseContext context, @Named(IServiceConstants.ACTIVE_SHELL)Shell shell,

            EMenuService menuService){

        new TermSearchController(new SearchComposite(parent, SWT.NONE));

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.view.search.facet.term;

import java.util.ArrayList;

import java.util.List;

import eu.etaxonomy.cdm.model.common.Language;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.taxeditor.view.search.facet.SearchComposite;

import eu.etaxonomy.taxeditor.view.search.facet.SearchController;

import eu.etaxonomy.taxeditor.view.search.facet.SearchResult;

/**

 * @author pplitzner

 * @since Jan 22, 2019

 *

 */

public class TermSearchController extends SearchController {

    public TermSearchController(SearchComposite composite) {

        super(composite);

    }

    @Override

    protected List<SearchResult> searchResults(String searchString){

        List<SearchResult> searchResults = new ArrayList<>();

        searchResults.add(new TermSearchResult(Language.ABKHAZIAN()));

        searchResults.add(new TermSearchResult(Language.WAKASHANS()));

        searchResults.add(new TermSearchResult(Feature.ADDITIONAL_PUBLICATION()));

        return searchResults;

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.view.search.facet.term;

import java.util.HashSet;

import java.util.Set;

import eu.etaxonomy.cdm.model.common.DefinedTermBase;

import eu.etaxonomy.taxeditor.view.search.facet.Facet;

import eu.etaxonomy.taxeditor.view.search.facet.SearchResult;

/**

 * @author pplitzner

 * @since Jan 24, 2019

 *

 */

public class TermSearchResult extends SearchResult<DefinedTermBase> {

    public TermSearchResult(DefinedTermBase content) {

        super(content);

    }

    @Override

    protected Set<Facet> initFacets(DefinedTermBase content) {

        Set<Facet> facets = new HashSet<>();

        facets.add(new Facet(content.getVocabulary().getLabel()));

        return facets;

    }

}