EDIT

/**

* Copyright (C) 2018 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.editor.view.checklist.e4;

import java.util.Collection;

import org.eclipse.e4.ui.workbench.modeling.ESelectionService;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.nebula.widgets.nattable.data.IRowDataProvider;

import org.eclipse.nebula.widgets.nattable.extension.e4.selection.E4SelectionListener;

import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;

import org.eclipse.nebula.widgets.nattable.layer.event.ILayerEvent;

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;

import org.eclipse.nebula.widgets.nattable.selection.event.CellSelectionEvent;

import org.eclipse.nebula.widgets.nattable.selection.event.RowSelectionEvent;

import eu.etaxonomy.cdm.api.service.dto.RowWrapperDTO;

import eu.etaxonomy.cdm.api.service.dto.TaxonDistributionDTO;

/**

 * @author k.luther

 * @since 28.11.2018

 *

 */

public class DistributionCellSelectionListener extends E4SelectionListener<TaxonDistributionDTO>{

    private DistributionEditorPart part;

    public DistributionCellSelectionListener(

            ESelectionService service,

            SelectionLayer selectionLayer,

            IRowDataProvider<TaxonDistributionDTO> rowDataProvider,

            DistributionEditorPart part) {

        super(service, selectionLayer, rowDataProvider);

        this.part = part;

    }

    @Override

    public void handleLayerEvent(ILayerEvent event) {

        if(event instanceof CellSelectionEvent){

            CellSelectionEvent cellSelectionEvent = (CellSelectionEvent)event;

            int columnPosition = cellSelectionEvent.getColumnPosition();

            if(columnPosition>=part.getEditor().getFirstDataColumnIndex()){

                Collection<ILayerCell> selectedCells = cellSelectionEvent.getSelectionLayer().getSelectedCells();

                if(selectedCells.size()==1){

                    ILayerCell cell = selectedCells.iterator().next();

                    Object dataValue = cell.getDataValue();

                    if(dataValue!=null){

                        part.getSelectionService().setSelection(new StructuredSelection(dataValue));

                        return;

                    }

                }

            }

        }

        else if(event instanceof RowSelectionEvent){

            RowSelectionEvent rowSelectionEvent = (RowSelectionEvent) event;

            int[] fullySelectedRowPositions = rowSelectionEvent.getSelectionLayer().getFullySelectedRowPositions();

            if(fullySelectedRowPositions.length==1){

                Object rowObject = part.getEditor().getBodyDataProvider().getRowObject(fullySelectedRowPositions[0]);

                if(rowObject instanceof RowWrapperDTO){

                    part.getSelectionService().setSelection(new StructuredSelection(((RowWrapperDTO) rowObject).getDescription()));

                    return;

                }

            }

        }

        part.getSelectionService().setSelection(new StructuredSelection());

    }

}

/**

* Copyright (C) 2018 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.editor.view.checklist.e4;

import java.util.HashSet;

import java.util.Set;

import org.eclipse.nebula.widgets.nattable.data.IColumnPropertyAccessor;

import eu.etaxonomy.cdm.api.service.dto.TaxonDistributionDTO;

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

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

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

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

import eu.etaxonomy.cdm.model.location.NamedArea;

/**

 * @author k.luther

 * @since 28.11.2018

 *

 */

public class DistributionColumnAccessor implements IColumnPropertyAccessor<TaxonDistributionDTO> {

    private DistributionEditor editor;

    public DistributionColumnAccessor(DistributionEditor editor) {

        this.editor = editor;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Object getDataValue(TaxonDistributionDTO rowObject, int columnIndex) {

     switch (columnIndex) {

            case 0:

                return rowObject.getNameCache();

            case 1:

                if (editor.isShowRank()){

                    return rowObject.getRankString();

                }else{

                    break;

                }

            default:

                break;

            }

        NamedArea area = editor.getAreaToColumnIndexMap().get(columnIndex);

        return rowObject.getDistributionMap().get(area);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public int getColumnCount() {

        return editor.getPropertyToLabelMap().size();

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public String getColumnProperty(int columnIndex) {

        return editor.getPropertyToLabelMap().get(columnIndex);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public int getColumnIndex(String propertyName){

        return editor.getPropertyToLabelMap().indexOf(propertyName);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void setDataValue(TaxonDistributionDTO taxonWrapper, int columnIndex, Object newValue) {

            if (newValue instanceof PresenceAbsenceTerm){

                NamedArea area =editor.getAreaToColumnIndexMap().get(columnIndex);

                Set<DescriptionElementBase> distributions = taxonWrapper.getDistributionMap().get(area);

                if (distributions != null && !distributions.isEmpty()){

                    DescriptionElementBase desc = distributions.iterator().next();

                    if (desc instanceof Distribution){

                        ((Distribution)desc).setStatus((PresenceAbsenceTerm)newValue);

                    }

                }else{

                    if (distributions == null){

                        distributions = new HashSet();

                    }

                    Distribution dist = Distribution.NewInstance(area, (PresenceAbsenceTerm)newValue);

                    Set<TaxonDescription> descs = taxonWrapper.getDescriptionsWrapper().getDescriptions();

                    TaxonDescription desc;

                    if (descs.size() >= 1){

                        desc = descs.iterator().next();

                    }else {

                        desc = TaxonDescription.NewInstance();

                    }

                    desc.addElement(dist);

                    distributions.add(dist);

                }

            }

    }

}

/**

* Copyright (C) 2018 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.editor.view.checklist.e4;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import javax.inject.Inject;

import org.apache.commons.collections4.map.LinkedMap;

import org.apache.log4j.Logger;

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

import org.eclipse.jface.layout.GridDataFactory;

import org.eclipse.jface.wizard.WizardDialog;

import org.eclipse.nebula.widgets.nattable.NatTable;

import org.eclipse.nebula.widgets.nattable.config.AbstractUiBindingConfiguration;

import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;

import org.eclipse.nebula.widgets.nattable.config.DefaultNatTableStyleConfiguration;

import org.eclipse.nebula.widgets.nattable.data.IDataProvider;

import org.eclipse.nebula.widgets.nattable.data.IRowDataProvider;

import org.eclipse.nebula.widgets.nattable.data.ListDataProvider;

import org.eclipse.nebula.widgets.nattable.export.command.ExportCommandHandler;

import org.eclipse.nebula.widgets.nattable.extension.e4.selection.E4SelectionListener;

import org.eclipse.nebula.widgets.nattable.extension.glazedlists.GlazedListsEventLayer;

import org.eclipse.nebula.widgets.nattable.extension.glazedlists.GlazedListsSortModel;

import org.eclipse.nebula.widgets.nattable.freeze.CompositeFreezeLayer;

import org.eclipse.nebula.widgets.nattable.freeze.FreezeLayer;

import org.eclipse.nebula.widgets.nattable.grid.GridRegion;

import org.eclipse.nebula.widgets.nattable.grid.command.ClientAreaResizeCommand;

import org.eclipse.nebula.widgets.nattable.grid.data.DefaultColumnHeaderDataProvider;

import org.eclipse.nebula.widgets.nattable.grid.data.DefaultCornerDataProvider;

import org.eclipse.nebula.widgets.nattable.grid.data.DefaultRowHeaderDataProvider;

import org.eclipse.nebula.widgets.nattable.grid.data.FixedSummaryRowHeaderLayer;

import org.eclipse.nebula.widgets.nattable.grid.layer.ColumnHeaderLayer;

import org.eclipse.nebula.widgets.nattable.grid.layer.CornerLayer;

import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultRowHeaderDataLayer;

import org.eclipse.nebula.widgets.nattable.grid.layer.GridLayer;

import org.eclipse.nebula.widgets.nattable.layer.AbstractLayer;

import org.eclipse.nebula.widgets.nattable.layer.CompositeLayer;

import org.eclipse.nebula.widgets.nattable.layer.DataLayer;

import org.eclipse.nebula.widgets.nattable.layer.ILayer;

import org.eclipse.nebula.widgets.nattable.layer.cell.ColumnOverrideLabelAccumulator;

import org.eclipse.nebula.widgets.nattable.layer.stack.DefaultBodyLayerStack;

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;

import org.eclipse.nebula.widgets.nattable.sort.SortHeaderLayer;

import org.eclipse.nebula.widgets.nattable.sort.config.SingleClickSortConfiguration;

import org.eclipse.nebula.widgets.nattable.style.HorizontalAlignmentEnum;

import org.eclipse.nebula.widgets.nattable.style.theme.ModernNatTableThemeConfiguration;

import org.eclipse.nebula.widgets.nattable.summaryrow.FixedSummaryRowLayer;

import org.eclipse.nebula.widgets.nattable.summaryrow.SummaryRowLayer;

import org.eclipse.nebula.widgets.nattable.ui.binding.UiBindingRegistry;

import org.eclipse.nebula.widgets.nattable.ui.matcher.MouseEventMatcher;

import org.eclipse.nebula.widgets.nattable.ui.menu.PopupMenuAction;

import org.eclipse.nebula.widgets.nattable.ui.menu.PopupMenuBuilder;

import org.eclipse.nebula.widgets.nattable.util.GUIHelper;

import org.eclipse.swt.SWT;

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.Label;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.Text;

import ca.odell.glazedlists.EventList;

import ca.odell.glazedlists.SortedList;

import eu.etaxonomy.cdm.api.service.dto.TaxonDistributionDTO;

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

import eu.etaxonomy.cdm.model.location.NamedArea;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.editor.descriptiveDataSet.matrix.CharacterMatrixLabelStyleConfiguration;

import eu.etaxonomy.taxeditor.editor.l10n.Messages;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.preference.Resources;

import eu.etaxonomy.taxeditor.preference.wizard.AvailableDistributionWizard;

import eu.etaxonomy.taxeditor.store.StoreUtil;

import eu.etaxonomy.taxeditor.ui.dialog.selection.ReferenceSelectionDialog;

/**

 * @author k.luther

 * @since 27.11.2018

 *

 */

public class DistributionEditor extends Composite {

    private static final String DISTRIBUTION_EDITOR = "Distribution Editor";

    private static final String LOADING_TAXA = Messages.ChecklistEditor_LOAD_TAXA;

    private static final String UNKNOWN = Messages.ChecklistEditor_UNKNOWN;

    private static final String ELEMENT_COUNT = Messages.ChecklistEditor_ELEMENT_COUNT;

    public static final String TYPE_FILTER_TEXT = "type filter text"; //$NON-NLS-1$

    static final String TAXON_COLUMN = "taxon_column"; //$NON-NLS-1$

    static final String RANK_COLUMN = "collector_column"; //$NON-NLS-1$

    private static final Logger logger = Logger.getLogger(DistributionEditor.class);

    @Inject

    private EMenuService menuService;

    private NatTable natTable;

    private Label statusLabel;

    private Label statusLabelSourceReference;

    private Reference defaultSource;

    private Map<Integer, NamedArea> areaToColumnIndexMap= new HashMap();

    private int firstDataColumnIndex;

    private ListDataProvider<TaxonDistributionDTO> bodyDataProvider;

    private LinkedMap<String, String> propertyToLabelMap = new LinkedMap<>();

    private boolean isShowRank;

    private Integer countNodes;

    private Text searchText;

    EventList<TaxonDistributionDTO> taxonList;

    List<NamedArea> areas = new ArrayList();

    DistributionEditorPart part;

    private DefaultBodyLayerStack bodyLayer;

    private FreezeLayer freezeLayer;

    private ConfigRegistry configRegistry;

    private AbstractLayer topMostLayer;

    private FixedSummaryRowLayer summaryRowLayer;

    /**

     * @param parent

     * @param style

     */

    public DistributionEditor(Composite parent, DistributionEditorPart part) {

        super(parent, SWT.NULL);

        this.setLayout(new GridLayout());

        this.part = part;

        createTopComposite(parent);

        natTable = new NatTable(this, false);

        createStatusBar(parent);

    }

    public boolean isShowRank() {

        return isShowRank;

    }

    public void setShowRank(boolean isShowRank) {

        this.isShowRank = isShowRank;

    }

    public int getFirstDataColumnIndex() {

        return firstDataColumnIndex;

    }

    public void setFirstDataColumnIndex(int firstDataColumnIndex) {

        this.firstDataColumnIndex = firstDataColumnIndex;

    }

    public LinkedMap<String, String> getPropertyToLabelMap() {

        return propertyToLabelMap;

    }

    public void setPropertyToLabelMap(LinkedMap<String, String> propertyToLabelMap) {

        this.propertyToLabelMap = propertyToLabelMap;

    }

    public Map<Integer, NamedArea> getAreaToColumnIndexMap() {

        return areaToColumnIndexMap;

    }

    public void setAreaToColumnIndexMap(Map<Integer, NamedArea> areaToColumnIndexMap) {

        this.areaToColumnIndexMap = areaToColumnIndexMap;

    }

    private void createStatusBar(Composite composite) {

        GridData gridData = new GridData();

        gridData.horizontalSpan = 1;

        gridData.grabExcessHorizontalSpace = true;

        gridData.horizontalAlignment = GridData.FILL;

        statusLabel = new Label(composite, SWT.LEFT);

        statusLabel.setText(ELEMENT_COUNT + (countNodes != null ? countNodes : UNKNOWN));

        statusLabel.setLayoutData(gridData);

        statusLabelSourceReference = new Label(composite, SWT.RIGHT);

//        GridData sourceGrid = new GridData();

//        sourceGrid.horizontalAlignment = GridData.HORIZONTAL_ALIGN_END;

//        //sourceGrid.grabExcessHorizontalSpace = false;

//        sourceGrid.horizontalSpan = 1;

       statusLabelSourceReference.setLayoutData(gridData);

        if (defaultSource != null){

            statusLabelSourceReference.setText("Default Source Reference: " + defaultSource.getAbbrevTitle() != null? defaultSource.getAbbrevTitle() : defaultSource.getAbbrevTitleCache());

        }

    }

    private void applyStyles(){

        ModernNatTableThemeConfiguration configuration = new ModernNatTableThemeConfiguration();

        configuration.summaryRowHAlign = HorizontalAlignmentEnum.CENTER;

        // NOTE: Getting the colors and fonts from the GUIHelper ensures that

        // they are disposed properly (required by SWT)

        configuration.cHeaderBgColor = GUIHelper.getColor(211, 211, 211);

        configuration.rHeaderBgColor = GUIHelper.getColor(211, 211, 211);

        natTable.addConfiguration(configuration);

    }

    private void configureNatTable(ConfigRegistry configRegistry,

            AbstractLayer topMostLayer) {

        /**

         * CONFIGURATION

         */

        natTable.setConfigRegistry(configRegistry);

        applyStyles();

        //add default configuration because autoconfigure is set to false in constructor

        natTable.addConfiguration(new DefaultNatTableStyleConfiguration());

        //FIXME: this is for DEBUG ONLY

        //        natTable.addConfiguration(new DebugMenuConfiguration(natTable));

        // override the default sort configuration and change the mouse bindings

        // to sort on a single click

        natTable.addConfiguration(new SingleClickSortConfiguration());

        natTable.addConfiguration(new CharacterMatrixLabelStyleConfiguration());

        // add the header menu configuration for adding the column header menu

        // with hide/show actions

        natTable.addConfiguration(new DistributionEditorHeaderMenuConfiguration(natTable));

        // add custom configuration for data conversion and add column labels to viewport layer

     //   topMostLayer.addConfiguration(new CellEditorDataConversionConfiguration(this));

//        //register aggregation configuration

//        summaryRowLayer.addConfiguration(new AggregationConfiguration(this));

      //+++CONTEXT MENU+++

        menuService.registerContextMenu(natTable, "eu.etaxonomy.taxeditor.editor.popupmenu.charactermatrix"); //$NON-NLS-1$

        // get the menu registered by EMenuService

        final Menu e4Menu = natTable.getMenu();

        // remove the menu reference from NatTable instance

        natTable.setMenu(null);

        natTable.addConfiguration(

                new AbstractUiBindingConfiguration() {

            @Override

            public void configureUiBindings(

                    UiBindingRegistry uiBindingRegistry) {

                // add e4 menu to NatTable

                new PopupMenuBuilder(natTable, e4Menu)

                    .build();

                // register the UI binding for header, corner and body region

                uiBindingRegistry.registerMouseDownBinding(

                        new MouseEventMatcher(

                                SWT.NONE,

                                null,

                                MouseEventMatcher.RIGHT_BUTTON),

                        new PopupMenuAction(e4Menu));

            }

        });

        natTable.configure();

    }

    public void createTable(boolean freezeSupplementalColumns){

        /**

         * layers

         */

        createLayers();

        /**

         * configuration

         */

        configureNatTable( configRegistry, topMostLayer);

        /**

         * handlers and listeners

         */

        registerHandlersAndListeners(topMostLayer);

        //grab all space

        GridDataFactory.fillDefaults().grab(true, true).applyTo(natTable);

        //update label to current data set

//        toolbar.getWsLabel().setText(descriptiveDataSet.getLabel());

//        toolbar.getWsLabel().setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

//        toolbar.getWsLabel().getParent().layout();

        //initial freeze of supplemental columns

//        freezeSupplementalColumns(freezeSupplementalColumns);

        this.layout();

        natTable.doCommand(new ClientAreaResizeCommand(natTable));

    }

    private void createLayers() {

        SortedList sortedList = new SortedList(taxonList, new TaxonDistributionDtoComparator());

        /**

         * data provider

         */

        DistributionColumnAccessor columnPropertyAccessor = new DistributionColumnAccessor(this);

        bodyDataProvider = new ListDataProvider(sortedList, columnPropertyAccessor);

        propertyToLabelMap.put(TAXON_COLUMN, Messages.CharacterMatrix_TAXON);

        if (isShowRank){

            propertyToLabelMap.put(RANK_COLUMN, Messages.CharacterMatrix_COLLECTOR_NO);

        }

        configRegistry = new ConfigRegistry();

        /**

         * BODY layer

         *

         *

        CompositeLayer

         - (top) SummaryRowLayer

         - (bottom) ViewportLayer

             ^

        ViewportLayer

             ^

        TreeLayer (default visible)

             ^

        CompositeFreezeLayer

         - viewportLayer

         - selectionLayer

         - freezeLayer

             ^

        FreezeLayer

             ^

        SelectionLayer

             ^

        ColumnHideShowLayer

             ^

        ColumnReorderLayer

             ^

        DataLayer

         *

         */

        DataLayer bodyDataLayer = new DataLayer(bodyDataProvider);

        //register labels

//        CharacterMatrixConfigLabelAccumulator labelAccumulator = new CharacterMatrixConfigLabelAccumulator(this);

//        bodyDataLayer.setConfigLabelAccumulator(labelAccumulator);

        propertyToLabelMap.put(TAXON_COLUMN, Messages.CharacterMatrix_TAXON);

        initLabels();

   //     layer for event handling of GlazedLists and PropertyChanges

        GlazedListsEventLayer eventLayer = new GlazedListsEventLayer<>(bodyDataLayer, taxonList);

        bodyLayer = new DefaultBodyLayerStack(eventLayer);

        final SelectionLayer selectionLayer = bodyLayer.getSelectionLayer();

        freezeLayer = new FreezeLayer(selectionLayer);

        final CompositeFreezeLayer compositeFreezeLayer = new CompositeFreezeLayer(

                freezeLayer, bodyLayer.getViewportLayer(), selectionLayer);

        topMostLayer = compositeFreezeLayer;

        summaryRowLayer = new FixedSummaryRowLayer(bodyDataLayer, topMostLayer, configRegistry, false);

        //register labels with summary prefix for summary layer

        ColumnOverrideLabelAccumulator summaryColumnLabelAccumulator =new ColumnOverrideLabelAccumulator(bodyDataLayer);

        summaryRowLayer.setConfigLabelAccumulator(summaryColumnLabelAccumulator);

        int n = 1;

        if (isShowRank){

            n++;

        }

        for(int i=0;i<areas.size();i++){

            NamedArea namedArea = areas.get(i);

            summaryColumnLabelAccumulator.registerColumnOverrides(

                    i+n,

                    SummaryRowLayer.DEFAULT_SUMMARY_COLUMN_CONFIG_LABEL_PREFIX+namedArea.getLabel());

        }

        // because the horizontal dependency is the ViewportLayer

        // we need to set the composite dependency to false

        summaryRowLayer.setHorizontalCompositeDependency(false);

        CompositeLayer composite = new CompositeLayer(1, 2);

        composite.setChildLayer("SUMMARY", summaryRowLayer, 0, 0); //$NON-NLS-1$

        composite.setChildLayer(GridRegion.BODY, topMostLayer, 0, 1);

        /**

         * column header layer

         */

        IDataProvider columnHeaderDataProvider = new DefaultColumnHeaderDataProvider(

                propertyToLabelMap.values().toArray(new String[] {}), propertyToLabelMap);

        DataLayer columnHeaderDataLayer = new DataLayer(columnHeaderDataProvider);

        ColumnHeaderLayer columnHeaderLayer = new ColumnHeaderLayer(columnHeaderDataLayer, topMostLayer, selectionLayer);

        // add the SortHeaderLayer to the column header layer stack

        // as we use GlazedLists, we use the GlazedListsSortModel which

        // delegates the sorting to the SortedList

        final SortHeaderLayer<TaxonDistributionDTO> sortHeaderLayer = new SortHeaderLayer<>(

                columnHeaderLayer,

                new GlazedListsSortModel<>(sortedList,

                        columnPropertyAccessor,

                        configRegistry,

                        columnHeaderDataLayer));

        /**

         * row header layer

         */

        IDataProvider rowHeaderDataProvider = new DefaultRowHeaderDataProvider(bodyDataProvider);

        DefaultRowHeaderDataLayer rowHeaderDataLayer = new DefaultRowHeaderDataLayer(rowHeaderDataProvider);

        FixedSummaryRowHeaderLayer fixedSummaryRowHeaderLayer = new FixedSummaryRowHeaderLayer(rowHeaderDataLayer,

                composite, selectionLayer);

        fixedSummaryRowHeaderLayer.setSummaryRowLabel("\u2211"); //$NON-NLS-1$

        /**

         * corner layer

         */

        ILayer cornerLayer = new CornerLayer(

                new DataLayer(new DefaultCornerDataProvider(columnHeaderDataProvider, rowHeaderDataProvider)),

                fixedSummaryRowHeaderLayer, sortHeaderLayer);

        /**

         * GRID layer (composition of all other layers)

         */

        GridLayer gridLayer = new GridLayer(composite, sortHeaderLayer, null, cornerLayer);

        natTable.setLayer(gridLayer);

    }

    /**

     * @param parent

     * @return

     */

    private Text createSearchBar(Composite parent) {

        final Text searchText = new Text(parent, SWT.BORDER | SWT.SEARCH | SWT.ICON_SEARCH | SWT.CANCEL);

        GridData gridData = new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL);

        searchText.setLayoutData(gridData);

        searchText.setForeground(EditorUtil.getColor(Resources.SEARCH_VIEW_FOREGROUND));

        searchText.setText(TYPE_FILTER_TEXT);

        searchText.setToolTipText(Messages.ChecklistEditor_SEARCH_TOOLTIP);

        Button button1 = new Button(parent, SWT.PUSH );

        GridData gridData2 = new GridData();

        gridData2.horizontalSpan = 1;

        gridData2.horizontalAlignment = SWT.RIGHT;

        button1.setLayoutData(gridData2);

        button1.setText(Messages.ChecklistEditor_DIST_STATUS);

        button1.setToolTipText(Messages.ChecklistEditor_DIST_STATUS_TOOLTIP);

        button1.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent event) {

                AvailableDistributionWizard availableDistributionWizard = new AvailableDistributionWizard();

                WizardDialog dialog = new WizardDialog(StoreUtil.getShell(),

                        availableDistributionWizard);

                int open = dialog.open();

                if(open == 0){

                    //TODO!!!!

                   // reload();

                }

            }

        });

        Button button2 = new Button(parent, SWT.PUSH );

        GridData gridData3 = new GridData();

        gridData2.horizontalSpan = 1;

        button2.setLayoutData(gridData3);

        button2.setText(Messages.ChecklistEditor_DEFAULT_SOURCE);

        button2.setToolTipText(Messages.ChecklistEditor_DEFAULT_SOURCE_TOOLTIP);

        button2.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent event) {

                defaultSource = ReferenceSelectionDialog.select(AbstractUtility.getShell(), null);

                String defaultSourceStr = (defaultSource == null) ? "" : "Default Source Reference: " + defaultSource.getTitleCache();

                if (defaultSourceStr.length()> 100){

                    defaultSourceStr = defaultSourceStr.substring(0, 98) + "...";

                }

                statusLabelSourceReference.setText(defaultSourceStr);

                button2.setBackground(EditorUtil.getColor(Resources.COLOR_CONTROL_SELECTED));

            }

        });

        parent.pack();

        return searchText;

    }

    /**

     * @param parent

     */

    private void createTopComposite(Composite parent) {

        GridLayout gridLayout = new GridLayout(3, false);

        gridLayout.marginWidth = 0;

        gridLayout.marginHeight = 0;

        parent.setLayout(gridLayout);

       searchText = createSearchBar(parent);

    }

    public void loadDistributions(List<TaxonDistributionDTO> taxonList) {

        this.taxonList.addAll(taxonList);

    }

    public Collection<DescriptionElementBase> getDistributions() {

        Collection<DescriptionElementBase> descElements = new HashSet();

//TODO: only for edited taxa

        taxonList.forEach(taxonDto->taxonDto.getDistributionMap()

                .forEach((area, descriptionElements)->descElements.addAll(descriptionElements)));

        return descElements;

    }

    private void initLabels() {

        int index = 1;

        if (isShowRank){

            index++;

        }

        for (NamedArea area: areas) {

            this.areaToColumnIndexMap.put(index++, area);

            //TODO: adapt to preference

            String areaLabel = area.getLabel();

            String property = areaLabel;

            propertyToLabelMap.put(property, areaLabel);

        }

    }

    private void registerHandlersAndListeners(AbstractLayer topMostLayer) {

        // add the ExportCommandHandler to the ViewportLayer in order to make

        // exporting work

        topMostLayer.registerCommandHandler(new ExportCommandHandler(topMostLayer));

        //selection listener

        E4SelectionListener selectionListener = new DistributionCellSelectionListener(part.getSelectionService(),

                bodyLayer.getSelectionLayer(), bodyDataProvider, part);

        bodyLayer.getSelectionLayer().addLayerListener(selectionListener);

        selectionListener.setFullySelectedRowsOnly(false);

        //register handler for view configuration menu

      //  natTable.registerCommandHandler(toolbar.getDisplayPersistenceDialogCommandHandler());

    }

    /**

     * @return

     */

    public IRowDataProvider<TaxonDistributionDTO> getBodyDataProvider() {

        return bodyDataProvider;

    }

}

/**

* Copyright (C) 2018 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.editor.view.checklist.e4;

import org.eclipse.nebula.widgets.nattable.NatTable;

import org.eclipse.nebula.widgets.nattable.ui.menu.AbstractHeaderMenuConfiguration;

import org.eclipse.nebula.widgets.nattable.ui.menu.PopupMenuBuilder;

/**

 * @author kluther

 * @date 28.11.2018

 *

 */

final class DistributionEditorHeaderMenuConfiguration extends AbstractHeaderMenuConfiguration {

    /**

     * @param natTable

     */

    public DistributionEditorHeaderMenuConfiguration(NatTable natTable) {

        super(natTable);

    }

    @Override

    protected PopupMenuBuilder createColumnHeaderMenu(NatTable natTable) {

        return super.createColumnHeaderMenu(natTable)

                .withHideColumnMenuItem()

                .withShowAllColumnsMenuItem();

    }

}

/**

* Copyright (C) 2018 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.editor.view.checklist.e4;

import java.util.Arrays;

import java.util.Collection;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import javax.annotation.PostConstruct;

import javax.inject.Inject;

import org.eclipse.core.runtime.IProgressMonitor;

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

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

import org.eclipse.e4.ui.di.Persist;

import org.eclipse.e4.ui.model.application.ui.MDirtyable;

import org.eclipse.e4.ui.model.application.ui.basic.MPart;

import org.eclipse.e4.ui.workbench.modeling.ESelectionService;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.StackLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Label;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;

import eu.etaxonomy.cdm.api.service.IDescriptionService;

import eu.etaxonomy.cdm.api.service.ITaxonNodeService;

import eu.etaxonomy.cdm.api.service.UpdateResult;

import eu.etaxonomy.cdm.api.service.dto.TaxonDistributionDTO;

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

import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;

import eu.etaxonomy.taxeditor.editor.l10n.Messages;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;

/**

 * @author k.luther

 * @since 28.11.2018

 *

 */

public class DistributionEditorPart implements IE4SavablePart, IConversationEnabled, IDirtyMarkable,

ICdmEntitySessionEnabled, IPartContentHasSupplementalData, IPartContentHasDetails{

    private static final List<String> TAXONNODE_PROPERTY_PATH = Arrays.asList(new String[] {

            "taxon", //$NON-NLS-1$

            "taxon.name", //$NON-NLS-1$

            "taxon.name.rank",//$NON-NLS-1$

            "taxon.descriptions", //$NON-NLS-1$

            "taxon.descriptions.descriptionElements", //$NON-NLS-1$

            "taxon.descriptions.descriptionElements.feature", //$NON-NLS-1$

            "taxon.descriptions.descriptionElements.sources", //$NON-NLS-1$

            "taxon.descriptions.descriptionElements.media" //$NON-NLS-1$

    });

    private List<TaxonDistributionDTO> taxonList;

    private Collection<UpdateResult> updateResults;

    private ConversationHolder conversation;

    private ICdmEntitySession cdmEntitySession;

    @Inject

    private ESelectionService selService;

    @Inject

    private MDirtyable dirty;

    @Inject

    private MPart thisPart;

    private DistributionEditor editor;

    private StackLayout stackLayout;

    @PostConstruct

    public void create(Composite parent, IEclipseContext context) {

        if(CdmStore.isActive() && conversation==null){

            conversation = CdmStore.createConversation();

        }

        if(cdmEntitySession == null){

            cdmEntitySession = CdmStore.getCurrentSessionManager().newSession(this, true);

        }

        else{

            return;

        }

        stackLayout = new StackLayout();

        parent.setLayout(stackLayout);

        editor = new DistributionEditor(parent, this);

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

        label.setText(Messages.CharacterMatrixPart_LOADING_MATRIX);

        stackLayout.topControl = label;

        ContextInjectionFactory.inject(editor, context);

    }

    public void init(UUID parentTaxonUuid) {

        this.taxonList = CdmStore.getService(ITaxonNodeService.class).getTaxonDistributionDTOForSubtree(parentTaxonUuid, TAXONNODE_PROPERTY_PATH);

        if(taxonList!=null){

            editor.createTable( true);

            editor.loadDistributions(taxonList);

        }

    }

    public ESelectionService getSelectionService() {

        return selService;

    }

    public DistributionEditor getEditor() {

        return editor;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void update(CdmDataChangeMap changeEvents) {

        // TODO Auto-generated method stub

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public ICdmEntitySession getCdmEntitySession() {

        // TODO Auto-generated method stub

        return null;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public <T extends CdmBase> Collection<T> getRootEntities() {

        // TODO Auto-generated method stub

        return null;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Map<Object, List<String>> getPropertyPathsMap() {

        // TODO Auto-generated method stub

        return null;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void changed(Object element) {

        // TODO Auto-generated method stub

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void forceDirty() {

        // TODO Auto-generated method stub

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public ConversationHolder getConversationHolder() {

        // TODO Auto-generated method stub

        return null;

    }

    @Persist

    @Override

    public void save(IProgressMonitor monitor) {

        //save distributions

      CdmStore.getService(IDescriptionService.class).saveDescriptionElement(editor.getDistributions());

      conversation.commit();

      updateResults = null;

      dirty.setDirty(false);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean isDirty() {

        // TODO Auto-generated method stub

        return false;

    }

}

/**

* Copyright (C) 2018 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.editor.view.checklist.e4;

import java.util.Comparator;

import eu.etaxonomy.cdm.api.service.dto.TaxonDistributionDTO;

import eu.etaxonomy.cdm.model.name.Rank;

/**

 * @author k.luther

 * @since 28.11.2018

 *

 */

public class TaxonDistributionDtoComparator implements Comparator<TaxonDistributionDTO> {

    /**

     * {@inheritDoc}

     */

    @Override

    public int compare(TaxonDistributionDTO arg0, TaxonDistributionDTO arg1) {

        if (arg0 == arg1){

            return 0;

        }

        if (arg0.getTaxonUuid().equals(arg1.getTaxonUuid())){

            return 0;

        }

        String name1 = arg0.getNameCache();

        String name2 = arg1.getNameCache();

        Rank rankTax1 = arg0.getRank();

        Rank rankTax2 = arg1.getRank();

        if (rankTax1 == null && rankTax2 != null){

            return 1;

        }else if(rankTax2 == null && rankTax1 != null){

            return -1;

        }else if (rankTax1 != null && rankTax1.isHigher(rankTax2)){

            return -1;

        }else if (rankTax1 == null && rankTax2 == null || rankTax1.equals(rankTax2)) {

            //same rank, order by name

            return name1.compareTo(name2);

         }

        return 0;

    }

}