EDIT

/**

 * Copyright (C) 2017 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.workingSet.matrix;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Properties;

import java.util.Set;

import java.util.UUID;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

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

import org.eclipse.core.runtime.IProgressMonitor;

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

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.jface.layout.GridDataFactory;

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.ComboViewer;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.window.Window;

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

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

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

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

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

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

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

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

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

import org.eclipse.nebula.widgets.nattable.edit.EditConfigAttributes;

import org.eclipse.nebula.widgets.nattable.edit.editor.IComboBoxDataProvider;

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

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

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

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

import org.eclipse.nebula.widgets.nattable.extension.glazedlists.tree.GlazedListTreeData;

import org.eclipse.nebula.widgets.nattable.extension.glazedlists.tree.GlazedListTreeRowModel;

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

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.hideshow.ColumnHideShowLayer;

import org.eclipse.nebula.widgets.nattable.hideshow.RowHideShowLayer;

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

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

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

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

import org.eclipse.nebula.widgets.nattable.persistence.PersistenceHelper;

import org.eclipse.nebula.widgets.nattable.persistence.command.DisplayPersistenceDialogCommand;

import org.eclipse.nebula.widgets.nattable.persistence.command.DisplayPersistenceDialogCommandHandler;

import org.eclipse.nebula.widgets.nattable.persistence.command.IStateChangedListener;

import org.eclipse.nebula.widgets.nattable.persistence.command.StateChangeEvent;

import org.eclipse.nebula.widgets.nattable.persistence.gui.PersistenceDialog;

import org.eclipse.nebula.widgets.nattable.reorder.ColumnReorderLayer;

import org.eclipse.nebula.widgets.nattable.reorder.RowReorderLayer;

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

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

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

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

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

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

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

import org.eclipse.nebula.widgets.nattable.tree.ITreeRowModel;

import org.eclipse.nebula.widgets.nattable.tree.TreeLayer;

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

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

import org.eclipse.nebula.widgets.nattable.viewport.ViewportLayer;

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 ca.odell.glazedlists.EventList;

import ca.odell.glazedlists.GlazedLists;

import ca.odell.glazedlists.SortedList;

import ca.odell.glazedlists.TreeList;

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

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

import eu.etaxonomy.taxeditor.editor.workingSet.matrix.categorical.CategoricalDataCellEditor;

import eu.etaxonomy.taxeditor.editor.workingSet.matrix.categorical.CategoricalDataDisplayConverter;

import eu.etaxonomy.taxeditor.editor.workingSet.matrix.quantitative.QuantitativeDataCellEditor;

import eu.etaxonomy.taxeditor.editor.workingSet.matrix.quantitative.QuantitativeDataDisplayConverter;

import eu.etaxonomy.taxeditor.editor.workingSet.matrix.supplementalInfo.SupplementalInfoDisplayConverter;

import eu.etaxonomy.taxeditor.model.DescriptionHelper;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.ImageResources;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.workbench.WorkbenchUtility;

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

/**

 * @author pplitzner

 * @since Nov 26, 2017

 *

 */

public class CharacterMatrix implements IE4SavablePart, IPartContentHasDetails, IConversationEnabled, IDirtyMarkable,

ICdmEntitySessionEnabled{

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

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

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

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

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

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

    });

    private static final String CHARACTER_MATRIX_STATE_PROPERTIES = "characterMatrixState.properties";

    private static final int LEADING_COLUMN_COUNT = 4;

    private static final String TAXON_COLUMN = "taxon_column";

    private static final String COLLECTOR_COLUMN = "collector_column";

    private static final String IDENTIFIER_COLUMN = "identifier_column";

    private static final String COUNTRY_COLUMN = "country_column";

    private WorkingSet workingSet;

    private Composite parent;

    private ConversationHolder conversation;

    private ICdmEntitySession cdmEntitySession;

    @Inject

    private ESelectionService selService;

    @Inject

    private MDirtyable dirty;

    @Inject

    private MPart thisPart;

    private NatTable natTable;

    private Map<Integer, Feature> indexToFeatureMap = new HashMap<>();

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

    private Properties natTableState;

    private EventList<Object> descriptions;

    private Collection<SpecimenOrObservationBase> specimenCache = null;

    @PostConstruct

    public void create(Composite parent) {

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

            conversation = CdmStore.createConversation();

        }

        if(cdmEntitySession == null){

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

        }

        else{

            return;

        }

        parent.setLayout(new GridLayout());

        this.parent = parent;

    }

    public void init(UUID workingSetUuid) {

        this.workingSet = CdmStore.getService(IWorkingSetService.class).load(workingSetUuid, WS_PROPERTY_PATH);

        thisPart.setLabel(workingSet.getLabel());

        Composite toolbarComposite = new Composite(parent, SWT.NONE);

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

        toolbarComposite.setLayout(new GridLayout(4, false));

        //get features/columns stored in working set

        FeatureTree tree = workingSet.getDescriptiveSystem();

        List<Feature> features = new ArrayList<>(tree.getDistinctFeatures());

        Collections.sort(features);

        descriptions = GlazedLists.eventList(getDescriptions(workingSet));

        // use the SortedList constructor with 'null' for the Comparator

        // because the Comparator will be set by configuration

        SortedList<Object> sortedList = new SortedList<>(descriptions, null);

        // wrap the SortedList with the TreeList

        TreeList treeList = new TreeList(sortedList, new DescriptionTreeFormat(), TreeList.NODES_START_EXPANDED);

        ConfigRegistry configRegistry = new ConfigRegistry();

        /**

         * data provider

         */

        SpecimenColumnPropertyAccessor columnPropertyAccessor = new SpecimenColumnPropertyAccessor(this);

        IDataProvider bodyDataProvider = new ListDataProvider<Object>(treeList, columnPropertyAccessor);

        /**

         * BODY layer

         *

         *

        CompositeLayer

         - (top) SummaryRowLayer

         - (bottom) ViewportLayer

             ^

        ViewportLayer

             ^

        SelectionLayer

             ^

        RowHideShowLayer

             ^

        ColumnHideShowLayer

             ^

        ColumnReorderLayer

             ^

        RowReorderLayer

             ^

        DataLayer

         *

         */

        DataLayer bodyDataLayer = new DataLayer(bodyDataProvider);

        //register labels for columns

        ColumnOverrideLabelAccumulator bodyColumnLabelAccumulator =new ColumnOverrideLabelAccumulator(bodyDataLayer);

        bodyDataLayer.setConfigLabelAccumulator(bodyColumnLabelAccumulator);

        propertyToLabelMap.put(TAXON_COLUMN, "Taxon");

        bodyColumnLabelAccumulator.registerColumnOverrides(0, TAXON_COLUMN);

        propertyToLabelMap.put(COLLECTOR_COLUMN, "Collector + No");

        bodyColumnLabelAccumulator.registerColumnOverrides(1, COLLECTOR_COLUMN);

        propertyToLabelMap.put(IDENTIFIER_COLUMN, "Identifier");

        bodyColumnLabelAccumulator.registerColumnOverrides(2, IDENTIFIER_COLUMN);

        propertyToLabelMap.put(COUNTRY_COLUMN, "Country");

        bodyColumnLabelAccumulator.registerColumnOverrides(3, COUNTRY_COLUMN);

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

            Feature feature = features.get(i);

            initLabels(bodyColumnLabelAccumulator, i, feature);

        }

        // layer for event handling of GlazedLists and PropertyChanges

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

        GlazedListTreeData treeData = new GlazedListTreeData<>(treeList);

        ITreeRowModel treeRowModel = new GlazedListTreeRowModel<>(treeData);

        RowReorderLayer rowReorderLayer = new RowReorderLayer(eventLayer);

        ColumnReorderLayer columnReorderLayer = new ColumnReorderLayer(rowReorderLayer);

        ColumnHideShowLayer columnHideShowLayer = new ColumnHideShowLayer(columnReorderLayer);

        RowHideShowLayer rowHideShowLayer = new RowHideShowLayer(columnHideShowLayer);

        SelectionLayer selectionLayer = new SelectionLayer(rowHideShowLayer);

        TreeLayer treeLayer = new TreeLayer(selectionLayer, treeRowModel);

        ViewportLayer viewportLayer = new ViewportLayer(treeLayer);

        // create a standalone FixedSummaryRowLayer

        // since the summary row should be fixed at the top of the body

        // region the horizontal dependency of the FixedSummaryRowLayer

        // is the ViewportLayer

        FixedSummaryRowLayer summaryRowLayer =

                new FixedSummaryRowLayer(bodyDataLayer, viewportLayer, configRegistry, false);

        //regoster labels with summary prefix for summary layer

        ColumnOverrideLabelAccumulator summaryColumnLabelAccumulator =new ColumnOverrideLabelAccumulator(bodyDataLayer);

        summaryRowLayer.setConfigLabelAccumulator(summaryColumnLabelAccumulator);

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

            Feature feature = features.get(i);

            summaryColumnLabelAccumulator.registerColumnOverrides(

                    i+LEADING_COLUMN_COUNT,

                    SummaryRowLayer.DEFAULT_SUMMARY_COLUMN_CONFIG_LABEL_PREFIX+MatrixUtility.getProperty(feature));

        }

        // 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);

        composite.setChildLayer(GridRegion.BODY, viewportLayer, 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, viewportLayer, 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<SpecimenDescription> 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");

        /**

         * 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, fixedSummaryRowHeaderLayer, cornerLayer);

        natTable = new NatTable(parent, gridLayer, false);

        /**

         * CONFIGURATION

         */

        natTable.setConfigRegistry(configRegistry);

        //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());

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

        // with hide/show actions

        natTable.addConfiguration(new AbstractHeaderMenuConfiguration(natTable) {

            @Override

            protected PopupMenuBuilder createColumnHeaderMenu(NatTable natTable) {

                return super.createColumnHeaderMenu(natTable)

                        .withHideColumnMenuItem()

                        .withShowAllColumnsMenuItem();

            }

            @Override

            protected PopupMenuBuilder createRowHeaderMenu(NatTable natTable) {

                return super.createRowHeaderMenu(natTable)

                        .withHideRowMenuItem()

                        .withShowAllRowsMenuItem();

            }

            @Override

            protected PopupMenuBuilder createCornerMenu(NatTable natTable) {

                return super.createCornerMenu(natTable)

                        .withShowAllColumnsMenuItem()

                        .withShowAllRowsMenuItem();

            }

        });

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

        viewportLayer.addConfiguration(new AbstractRegistryConfiguration() {

            @Override

            public void configureRegistry(IConfigRegistry configRegistry) {

                //add display converter for string representation

                configRegistry.registerConfigAttribute(

                        CellConfigAttributes.DISPLAY_CONVERTER,

                        new SupplementalInfoDisplayConverter(),

                        DisplayMode.NORMAL,

                        TAXON_COLUMN);

                configRegistry.registerConfigAttribute(

                        CellConfigAttributes.DISPLAY_CONVERTER,

                        new SupplementalInfoDisplayConverter(),

                        DisplayMode.NORMAL,

                        COLLECTOR_COLUMN);

                configRegistry.registerConfigAttribute(

                        CellConfigAttributes.DISPLAY_CONVERTER,

                        new SupplementalInfoDisplayConverter(),

                        DisplayMode.NORMAL,

                        IDENTIFIER_COLUMN);

                configRegistry.registerConfigAttribute(

                        CellConfigAttributes.DISPLAY_CONVERTER,

                        new SupplementalInfoDisplayConverter(),

                        DisplayMode.NORMAL,

                        COUNTRY_COLUMN);

                features.forEach(feature->registerColumnConfiguration(feature, configRegistry));

            }

        });

        //register aggregation configuration for each feature

        features.forEach(feature->summaryRowLayer.addConfiguration(new AggregationConfiguration(bodyDataProvider, feature)));

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

        // exporting work

        viewportLayer.registerCommandHandler(new ExportCommandHandler(viewportLayer));

        //propagate single cell selection

        natTable.addLayerListener(new ILayerListener() {

            @Override

            public void handleLayerEvent(ILayerEvent event) {

                if(event instanceof CellSelectionEvent){

                    CellSelectionEvent cellSelectionEvent = (CellSelectionEvent)event;

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

                    StructuredSelection selection = new StructuredSelection();

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

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

                        Object dataValue = cell.getDataValue();

                        if(dataValue!=null){

                            selection = new StructuredSelection(dataValue);

                        }

                    }

                    selService.setSelection(selection);

                }

            }

        });

        natTable.configure();

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

        /**

         * Info label

         */

        Label wsLabel = new Label(toolbarComposite, SWT.NONE);

        wsLabel.setText(workingSet.getLabel());

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

        /**

         * Table state persistence

         */

        natTableState = new Properties();

        //load persisted state

        File statePropertiesFile = getStatePropertiesFile();

        FileInputStream inputStream;

        try {

            inputStream = new FileInputStream(statePropertiesFile);

            natTableState.load(inputStream);

        } catch (IOException e) {

            MessagingUtils.info("No initial state properties file found for character matrix");

        }

        DisplayPersistenceDialogCommandHandler handler =

                new DisplayPersistenceDialogCommandHandler(natTableState, natTable);

        gridLayer.registerCommandHandler(handler);

        // create a combobox for showing the available view states

        ComboViewer comboStates= new ComboViewer(toolbarComposite, SWT.DROP_DOWN) ;

        Collection<String> availableStates = PersistenceHelper.getAvailableStates(natTableState);

        comboStates.setLabelProvider(new LabelProvider(){

            @Override

            public String getText(Object element) {

                if(element instanceof String && ((String) element).isEmpty()){

                    return "-default-";

                }

                return super.getText(element);

            }

        });

        comboStates.setContentProvider(new ArrayContentProvider());

        comboStates.addSelectionChangedListener(e->

        {

            int index = comboStates.getCombo().getSelectionIndex();

            if (index >= 0) {

                String selected = comboStates.getCombo().getItem(index);

                // load the state

                natTable.loadState(selected, natTableState);

                natTableState.setProperty(PersistenceDialog.ACTIVE_VIEW_CONFIGURATION_KEY, selected);

            }

        });

        comboStates.setInput(availableStates);

        if(comboStates.getCombo().getItemCount()>0){

            comboStates.getCombo().select(0);

        }

        // add listener to update the combo on view state management changes

        handler.addStateChangeListener(new IStateChangedListener() {

            @Override

            public void handleStateChange(StateChangeEvent event) {

                comboStates.setInput(PersistenceHelper.getAvailableStates(natTableState));

                selectStateItem(comboStates, event.getViewConfigName());

            }

        });

        // add button to show dialog

        Button btnManageState = new Button(toolbarComposite, SWT.PUSH);

        btnManageState.setImage(ImageResources.getImage(ImageResources.SETTINGS));

        btnManageState.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                natTable.doCommand(new DisplayPersistenceDialogCommand(natTable));

                selectStateItem(comboStates, natTableState.get(PersistenceDialog.ACTIVE_VIEW_CONFIGURATION_KEY).toString());

            }

        });

        /**

         * excel export

         */

        Button btnExcelExport = new Button(toolbarComposite, SWT.PUSH);

        btnExcelExport.setToolTipText("Export to Excel");

        btnExcelExport.setImage(ImageResources.getImage(ImageResources.EXPORT));

        btnExcelExport.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                natTable.doCommand(

                        new ExportCommand(

                                natTable.getConfigRegistry(),

                                natTable.getShell()));

            }

        });

        /**

         * Add description button

         */

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

        btnAddDescription.setImage(ImageResources.getImage(ImageResources.ADD_ICON));

        btnAddDescription.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                SpecimenSelectionDialog dialog = new SpecimenSelectionDialog(natTable.getShell(), CharacterMatrix.this);

                if(dialog.open()==Window.OK){

                    Collection<SpecimenOrObservationBase> specimens = dialog.getSpecimen();

                    boolean hasAdded = false;

                    for (SpecimenOrObservationBase specimen : specimens) {

                        SpecimenDescription description = getDescriptionForWorkingSet(specimen);

                        if(!workingSet.getDescriptions().contains(description)){

                            CharacterMatrix.this.descriptions.add(new RowWrapper(description));

                            workingSet.addDescription(description);

                            hasAdded = true;

                        }

                    }

                    if(hasAdded){

                        setDirty();

                    }

                }

            }

        });

        parent.layout();

    }

    private void selectStateItem(ComboViewer comboStates, String stateName){

        String[] items = comboStates.getCombo().getItems();

        for(int i=0;i<items.length;i++){

            if(items[i].equals(stateName)){

                comboStates.getCombo().select(i);

                break;

            }

        }

    }

    private SpecimenDescription getDescriptionForWorkingSet(SpecimenOrObservationBase specimen){

        Set<Feature> wsFeatures = workingSet.getDescriptiveSystem().getDistinctFeatures();

        List<DescriptionElementBase> matchingDescriptionElements = new ArrayList<>();

        for (SpecimenDescription specimenDescription : (Set<SpecimenDescription>) specimen.getDescriptions()) {

            Set<Feature> specimenDescriptionFeatures = new HashSet<>();

            //gather specimen description features and check for match with WS features

            for (DescriptionElementBase specimenDescriptionElement : specimenDescription.getElements()) {

                Feature feature = specimenDescriptionElement.getFeature();

                specimenDescriptionFeatures.add(feature);

                if(wsFeatures.contains(feature)){

                    matchingDescriptionElements.add(specimenDescriptionElement);

                }

            }

            //if description with the exact same features is found return the description

            if(specimenDescriptionFeatures.equals(wsFeatures)){

                return specimenDescription;

            }

        }

        //Create new specimen description if no match was found

        setDirty();

        SpecimenDescription newDesription = SpecimenDescription.NewInstance(specimen);

        newDesription.setTitleCache("WorkingSet "+workingSet.getLabel()+": "+newDesription.generateTitle(), true);

        //check for equals description element (same feature and same values)

        Map<Feature, List<DescriptionElementBase>> featureToElementMap = new HashMap<>();

        for(DescriptionElementBase element:matchingDescriptionElements){

            List<DescriptionElementBase> list = featureToElementMap.get(element.getFeature());

            if(list==null){

                list = new ArrayList<>();

            }

            list.add(element);

            featureToElementMap.put(element.getFeature(), list);

        }

        Set<DescriptionElementBase> descriptionElementsToClone = new HashSet<>();

        for(Feature feature:featureToElementMap.keySet()){

            List<DescriptionElementBase> elements = featureToElementMap.get(feature);

            //no duplicate description elements found for this feature

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

                descriptionElementsToClone.add(elements.get(0));

            }

            //duplicates found -> check if all are equal

            else{

                DescriptionElementBase match = null;

                for (DescriptionElementBase descriptionElementBase : elements) {

                    if(match==null){

                        match = descriptionElementBase;

                    }

                    else if(!new DescriptionElementCompareWrapper(match).equals(new DescriptionElementCompareWrapper(descriptionElementBase))){

                        match = null;

                        MessagingUtils.informationDialog("Multiple data found",

                                String.format("Multiple description elements with different values "

                                        + "found for feature '%s'.\nData will not be copied to new specimen description.", feature.getLabel()));

                        break;

                    }

                }

                if(match!=null){

                    descriptionElementsToClone.add(match);

                }

            }

        }

        //clone matching descriptionElements

        for (DescriptionElementBase descriptionElementBase : descriptionElementsToClone) {

            DescriptionElementBase clone;

            try {

                clone = descriptionElementBase.clone(newDesription);

                clone.getSources().forEach(source -> source.setOriginalNameString(DescriptionHelper.getLabel(descriptionElementBase)));

            } catch (CloneNotSupportedException e) {

                MessagingUtils.error(CharacterMatrix.class, e);

            }

        }

        return newDesription;

    }

    private void initLabels(final ColumnOverrideLabelAccumulator columnLabelAccumulator,

            int index, Feature feature) {

        columnLabelAccumulator.registerColumnOverrides(index+LEADING_COLUMN_COUNT, MatrixUtility.getProperty(feature));

        indexToFeatureMap.put(index+LEADING_COLUMN_COUNT, feature);

        String featureLabel = feature.getLabel();

        String property = featureLabel;

        //show unit for quantitative data

        if(feature.isSupportsQuantitativeData()){

            Set<MeasurementUnit> recommendedMeasurementUnits = feature.getRecommendedMeasurementUnits();

            if(recommendedMeasurementUnits.size()!=1){

                MessagingUtils.warningDialog("Column initialization problem", CharacterMatrix.class,

                        String.format("Only one unit is allowed for quantitative data: %s", feature.getLabel()));

                return;

            }

            MeasurementUnit unit = recommendedMeasurementUnits.iterator().next();

            featureLabel += " ["+unit.getLabel()+"]";

        }

        propertyToLabelMap.put(property, featureLabel);

    }

    private void registerColumnConfiguration(Feature feature, IConfigRegistry configRegistry) {

        //make cell editable

        configRegistry.registerConfigAttribute(

                EditConfigAttributes.CELL_EDITABLE_RULE,

                IEditableRule.ALWAYS_EDITABLE,

                DisplayMode.EDIT,

                MatrixUtility.getProperty(feature)

                );

        if(feature.isSupportsQuantitativeData()){

            //add display converter for string representation

            configRegistry.registerConfigAttribute(

                    CellConfigAttributes.DISPLAY_CONVERTER,

                    new QuantitativeDataDisplayConverter(),

                    DisplayMode.NORMAL,

                    MatrixUtility.getProperty(feature));

            //register quantitative editor

            configRegistry.registerConfigAttribute(

                    EditConfigAttributes.CELL_EDITOR,

                    new QuantitativeDataCellEditor(feature.getRecommendedStatisticalMeasures(), this),

                    DisplayMode.EDIT,

                    MatrixUtility.getProperty(feature));

        }

        else if(feature.isSupportsCategoricalData()){

            //add display converter for string representation

            configRegistry.registerConfigAttribute(

                    CellConfigAttributes.DISPLAY_CONVERTER,

                    new CategoricalDataDisplayConverter(),

                    DisplayMode.NORMAL,

                    MatrixUtility.getProperty(feature));

            //add combo box cell editor

            CategoricalDataCellEditor comboBoxCellEditor = new CategoricalDataCellEditor(new IComboBoxDataProvider() {

                @Override

                public List<?> getValues(int columnIndex, int rowIndex) {

                    List<State> states = new ArrayList<>();

                    Feature feature = indexToFeatureMap.get(columnIndex);

                    if(feature.isSupportsCategoricalData()){

                        Set<TermVocabulary<State>> stateVocs = feature.getSupportedCategoricalEnumerations();

                        for (TermVocabulary<State> voc : stateVocs) {

                            states.addAll(voc.getTerms());

                        }

                    }

                    return states;

                }

            }, 5, this);

            //register editor

            configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR,

                    comboBoxCellEditor,

                    DisplayMode.EDIT,

                    MatrixUtility.getProperty(feature));

        }

    }

    private List<RowWrapper> getDescriptions(WorkingSet workingSet) {

        List<RowWrapper> rowWrappers = new ArrayList<>();

        Set<DescriptionBase> wsDescriptions = workingSet.getDescriptions();

        for (DescriptionBase descriptionBase : wsDescriptions) {

            if(descriptionBase instanceof SpecimenDescription){

                rowWrappers.add(new RowWrapper((SpecimenDescription) descriptionBase));

            }

        }

        return rowWrappers;

    }

    public Map<Integer, Feature> getIndexToFeatureMap() {

        return indexToFeatureMap;

    }

    public LinkedMap<String, String> getPropertyToLabelMap() {

        return propertyToLabelMap;

    }

    public void setDirty() {

        this.dirty.setDirty(true);

    }

    public NatTable getNatTable() {

        return natTable;

    }

    public WorkingSet getWorkingSet() {

        return workingSet;

    }

    public Collection<SpecimenOrObservationBase> getSpecimenCache() {

        return specimenCache;

    }

    public void setSpecimenCache(Collection<SpecimenOrObservationBase> specimenCache) {

        this.specimenCache = specimenCache;

    }

    @Persist

    @Override

    public void save(IProgressMonitor monitor) {

        CdmStore.getService(IWorkingSetService.class).merge(workingSet, true);

        conversation.commit();

        dirty.setDirty(false);

    }

    @Focus

    public void setFocus(){

        if(conversation!=null){

            conversation.bind();

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.bind();

        }

    }

    @PreDestroy

    public void dispose(){

        if (conversation != null) {

            conversation.close();

            conversation = null;

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.dispose();

            cdmEntitySession = null;

        }

        dirty.setDirty(false);

        if(natTableState!=null){

            try (FileOutputStream tableStateStream =

                    new FileOutputStream(getStatePropertiesFile())) {

                natTableState.store(tableStateStream, null);

            } catch (IOException ioe) {

                ioe.printStackTrace();

            }

        }

    }

    private File getStatePropertiesFile() {

        return new File(WorkbenchUtility.getBaseLocation(), CHARACTER_MATRIX_STATE_PROPERTIES);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void update(CdmDataChangeMap arg0) {

    }