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

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 java.util.Properties;

import java.util.Set;

import java.util.UUID;

import java.util.stream.Collectors;

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

import org.eclipse.core.runtime.ICoreRunnable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.jobs.Job;

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.command.VisualRefreshCommand;

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.coordinate.PositionCoordinate;

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.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.freeze.CompositeFreezeLayer;

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

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.grid.layer.config.DefaultRowStyleConfiguration;

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.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.config.DefaultColumnHeaderStyleConfiguration;

import org.eclipse.nebula.widgets.nattable.layer.config.DefaultRowHeaderStyleConfiguration;

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

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

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.selection.SelectionLayer;

import org.eclipse.nebula.widgets.nattable.selection.config.DefaultSelectionStyleConfiguration;

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

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

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

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

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

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

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

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

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

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.tree.command.TreeCollapseAllCommand;

import org.eclipse.nebula.widgets.nattable.tree.command.TreeExpandAllCommand;

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

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

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

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.graphics.Color;

import org.eclipse.swt.graphics.FontData;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.layout.RowLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Label;

import ca.odell.glazedlists.BasicEventList;

import ca.odell.glazedlists.EventList;

import ca.odell.glazedlists.SortedList;

import ca.odell.glazedlists.TreeList;

import eu.etaxonomy.cdm.api.application.CdmApplicationState;

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

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

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

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

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

import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;

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

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

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

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

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

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

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

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.persistence.dto.SpecimenNodeWrapper;

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

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

import eu.etaxonomy.taxeditor.model.DescriptionHelper;

import eu.etaxonomy.taxeditor.model.ImageResources;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.preference.Resources;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.workbench.WorkbenchUtility;

/**

 * Character matrix editor for editing specimen/taxon descriptions in a table

 * @author pplitzner

 * @since Nov 26, 2017

 *

 */

public class CharacterMatrix extends Composite {

    private static final String CHARACTER_MATRIX_STATE_PROPERTIES = "characterMatrixState.properties"; //$NON-NLS-1$

    private static final int LEADING_COLUMN_COUNT = 4;

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

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

    private static final String IDENTIFIER_COLUMN = "identifier_column"; //$NON-NLS-1$

    private static final String COUNTRY_COLUMN = "country_column"; //$NON-NLS-1$

    private WorkingSet workingSet;

    private NatTable natTable;

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

    private Map<Feature, List<State>> categoricalFeatureToStateMap = new HashMap<>();

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

    private Properties natTableState;

    private EventList<Object> descriptions;

    private Collection<SpecimenNodeWrapper> specimenCache = null;

    private ListDataProvider<Object> bodyDataProvider;

    private FreezeLayer freezeLayer;

    private ViewportLayer viewportLayer;

    private Label wsLabel;

    private List<Feature> features;

    private DisplayPersistenceDialogCommandHandler displayPersistenceDialogCommandHandler;

    private CharacterMatrixPart part;

    private AbstractLayer topMostLayer;

    private FixedSummaryRowLayer summaryRowLayer;

    private ConfigRegistry configRegistry;

    private DefaultBodyLayerStack bodyLayer;

    private boolean isTreeView = true;

    public CharacterMatrix(Composite parent, CharacterMatrixPart part) {

        super(parent, SWT.NONE);

        this.part = part;

        this.setLayout(new GridLayout());

        createToolBar();

        natTable = new NatTable(this, false);

        applyStyles();

        createBottomToolbar();

    }

    private void createToolBar(){

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

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

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

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

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

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

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

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

        Button btnFreezeSuppInfo = new Button(toolbarComposite, SWT.TOGGLE);

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

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

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

        /**

         * Toogle tree button

         */

        btnToggleTree.setImage(ImageResources.getImage(ImageResources.HIERARCHICAL));

        btnToggleTree.setToolTipText(Messages.CharacterMatrix_SHOW_HIERARCHY);

        btnToggleTree.setSelection(true);

        btnToggleTree.setEnabled(false);

        btnToggleTree.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                toggleTreeFlat(true, btnToggleFlat, btnToggleTree, btnCollapseAll, btnExpandAll, btnFreezeSuppInfo);

            }

        });

        /**

         * Toogle flat button

         */

        btnToggleFlat.setImage(ImageResources.getImage(ImageResources.FLAT));

        btnToggleFlat.setToolTipText(Messages.CharacterMatrix_SHOW_FLAT_LIST);

        btnToggleFlat.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                toggleTreeFlat(false, btnToggleFlat, btnToggleTree, btnCollapseAll, btnExpandAll, btnFreezeSuppInfo);

            }

        });

        /**

         *

         * Collapse button

         */

        btnCollapseAll.setImage(ImageResources.getImage(ImageResources.COLLAPSE_ALL));

        btnCollapseAll.setToolTipText(Messages.CharacterMatrix_COLLAPSE);

        btnCollapseAll.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                natTable.doCommand(new TreeCollapseAllCommand());

            }

        });

        /**

         * Expand button

         */

        btnExpandAll.setImage(ImageResources.getImage(ImageResources.EXPAND_ALL));

        btnExpandAll.setToolTipText(Messages.CharacterMatrix_EXPAND);

        btnExpandAll.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                natTable.doCommand(new TreeExpandAllCommand());

            }

        });

        /**

         * Freeze supplemental info button

         */

        btnFreezeSuppInfo.setImage(ImageResources.getImage(ImageResources.LOCK_ICON));

        btnFreezeSuppInfo.setToolTipText(Messages.CharacterMatrix_LOCK_COLUMNS);

        btnFreezeSuppInfo.setSelection(true);

        btnFreezeSuppInfo.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                boolean isSelected = btnFreezeSuppInfo.getSelection();

                freezeSupplementalColumns(isSelected);

                btnFreezeSuppInfo.setImage(isSelected?

                                ImageResources.getImage(ImageResources.LOCK_ICON):

                                    ImageResources.getImage(ImageResources.LOCK_OPEN_ICON));

            }

        });

        /**

         * 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"); //$NON-NLS-1$

        }

        // create a combobox for showing the available view states

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

        comboStates.setLabelProvider(new LabelProvider(){

            @Override

            public String getText(Object element) {

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

                    return Messages.CharacterMatrix_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);

        }

        displayPersistenceDialogCommandHandler = new DisplayPersistenceDialogCommandHandler(natTableState, natTable);

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

        displayPersistenceDialogCommandHandler.addStateChangeListener(new IStateChangedListener() {

            @Override

            public void handleStateChange(StateChangeEvent event) {

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

                selectStateItem(comboStates, event.getViewConfigName());

            }

        });

        // add button to show dialog

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

        btnManageState.setToolTipText(Messages.CharacterMatrix_VIEW_CONFIG);

        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

         */

        btnExcelExport.setToolTipText(Messages.CharacterMatrix_EXPORT);

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

        btnExcelExport.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                natTable.doCommand(

                        new ExportCommand(

                                natTable.getConfigRegistry(),

                                natTable.getShell()));

            }

        });

    }

    private void createBottomToolbar() {

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

        buttonPanel.setLayout(new RowLayout());

        GridDataFactory.fillDefaults().grab(true, false).applyTo(buttonPanel);

        /**

         * Add description button

         */

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

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

        btnAddDescription.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

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

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

                    Collection<SpecimenNodeWrapper> wrappers = dialog.getSpecimen();

                    for (SpecimenNodeWrapper wrapper : wrappers) {

                        SpecimenOrObservationBase specimen = CdmStore.getService(IOccurrenceService.class).load(wrapper.getUuidAndTitleCache().getUuid());

                        SpecimenDescription description = getDescriptionForWorkingSet(specimen);

                        //description elements

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

                        Set<DescriptionElementBase> elements = description.getElements();

                        for (DescriptionElementBase descriptionElementBase : elements) {

                            Feature feature = descriptionElementBase.getFeature();

                            featureToElementMap.put(feature, descriptionElementBase);

                        }

                        RowWrapperDTO rowWrapper = CdmStore.getService(IWorkingSetService.class).createRowWrapper(description, workingSet);

                        CharacterMatrix.this.descriptions.add(rowWrapper);

                        workingSet.addDescription(description);

                        setDirty();

                        specimenCache.remove(wrapper);

                    }

                }

            }

        });

        /**

         * Remove description button

         */

        Button btnRemoveDescription = new Button(buttonPanel, SWT.PUSH);

        btnRemoveDescription.setImage(ImageResources.getImage(ImageResources.ACTIVE_DELETE_ICON));

        btnRemoveDescription.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

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

                List<RowWrapperDTO> toRemove = new ArrayList<>();

                for (int i : fullySelectedRowPositions) {

                    Object rowObject = bodyDataProvider.getRowObject(i);

                    if(rowObject instanceof RowWrapperDTO){

                        toRemove.add((RowWrapperDTO) rowObject);

                    }

                }

                toRemove.forEach(rowToRemove->{

                    CharacterMatrix.this.descriptions.remove(rowToRemove);

                    workingSet.removeDescription(rowToRemove.getSpecimenDescription());

                    setDirty();

                });

            }

        });

    }

    private void applyStyles(){

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

        // they are disposed properly (required by SWT)

        DefaultNatTableStyleConfiguration natTableConfiguration = new DefaultNatTableStyleConfiguration();

        natTableConfiguration.bgColor = GUIHelper.getColor(249, 172, 7);

        natTableConfiguration.fgColor = GUIHelper.getColor(30, 76, 19);

        natTableConfiguration.hAlign = HorizontalAlignmentEnum.LEFT;

        natTableConfiguration.vAlign = VerticalAlignmentEnum.TOP;

//        natTableConfiguration.borderStyle = new BorderStyle(1, GUIHelper.getColor(249, 172, 7), LineStyleEnum.SOLID);

        // Setup even odd row colors - row colors override the NatTable default

        // colors

        DefaultRowStyleConfiguration rowStyleConfiguration = new DefaultRowStyleConfiguration();

        rowStyleConfiguration.oddRowBgColor = ColorResources.getColor(Resources.COLOR_LIST_ODD);

        rowStyleConfiguration.evenRowBgColor = ColorResources.getColor(Resources.COLOR_LIST_EVEN);

        // Setup selection styling

        DefaultSelectionStyleConfiguration selectionStyle = new DefaultSelectionStyleConfiguration();

//        selectionStyle.selectionFont = GUIHelper.getFont(new FontData("Verdana", 8, SWT.NORMAL));

//        selectionStyle.selectionBgColor = GUIHelper.getColor(217, 232, 251);

//        selectionStyle.selectionFgColor = GUIHelper.COLOR_BLACK;

//        selectionStyle.anchorBorderStyle = new BorderStyle(1, GUIHelper.COLOR_DARK_GRAY, LineStyleEnum.SOLID);

//        selectionStyle.anchorBgColor = GUIHelper.getColor(65, 113, 43);

        selectionStyle.selectedHeaderBgColor = GUIHelper.getColor(156, 209, 103);

        // Add all style configurations to NatTable

        natTable.addConfiguration(natTableConfiguration);

        natTable.addConfiguration(rowStyleConfiguration);

        natTable.addConfiguration(selectionStyle);

        // Column/Row header style and custom painters

        DefaultRowHeaderStyleConfiguration rowHeaderConfig = new DefaultRowHeaderStyleConfiguration();

        Color rowColumnColor = GUIHelper.getColor(230, 255, 255);

        rowHeaderConfig.bgColor = rowColumnColor;

        natTable.addConfiguration(rowHeaderConfig);

        DefaultColumnHeaderStyleConfiguration columnHeaderStyle = new DefaultColumnHeaderStyleConfiguration();

        columnHeaderStyle.bgColor = rowColumnColor;

        columnHeaderStyle.font = GUIHelper.getFont(new FontData("Verdana", 9, SWT.BOLD)); //$NON-NLS-1$

        natTable.addConfiguration(columnHeaderStyle);

    }

    private void toggleTreeFlat(boolean isTree, Button btnToggleFlat, Button btnToggleTree, Button btnCollapseAll, Button btnExpandAll, Button btnFreezeSuppInfo) {

        isTreeView = isTree;

        createLayers(isTree);

        btnToggleFlat.setEnabled(isTree);

        btnToggleTree.setEnabled(!isTree);

        btnCollapseAll.setEnabled(isTree);

        btnExpandAll.setEnabled(isTree);

        natTable.doCommand(new ClientAreaResizeCommand(natTable));

        natTable.doCommand(new VisualRefreshCommand());

        freezeSupplementalColumns(btnFreezeSuppInfo.getSelection());

    }

    public boolean isTreeView() {

        return isTreeView;

    }

    public void createTable(boolean treeView){

        /**

         * layers

         */

        createLayers(treeView);

        /**

         * configuration

         */

        configureNatTable(treeView, configRegistry, topMostLayer, summaryRowLayer);

        /**

         * handlers and listeners

         */

        registerHandlersAndListeners(topMostLayer);

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

        wsLabel.setText(workingSet.getLabel());

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

        wsLabel.getParent().layout();

        freezeSupplementalColumns(true);

        this.layout();

    }

    private List<Feature> initFeatureList(FeatureNode node){

        List<Feature> features = new ArrayList<>();

        node.getChildNodes().forEach(childNode->

                {

                    features.add(childNode.getFeature());

                    features.addAll(initFeatureList(childNode));

                });

        return features;

    }

    public void initWorkingSet(WorkingSet workingSet){

        this.workingSet = workingSet;

        //get features/columns stored in working set

        FeatureTree tree = workingSet.getDescriptiveSystem();

        features = initFeatureList(tree.getRoot());

        //init state data for categorical features

        features.forEach(feature->

        {

            if(feature.isSupportsCategoricalData()){

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

                feature.getSupportedCategoricalEnumerations().forEach(voc->supportedStates.addAll(voc.getTerms()));

                categoricalFeatureToStateMap.put(feature, supportedStates);

            }

        });

        descriptions = new BasicEventList<>();

    }

    private void createLayers(boolean treeView) {

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

        // because the Comparator will be set by configuration

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

        // wrap the SortedList with the TreeList

        TreeList<Object> treeList = new TreeList(sortedList, new DescriptionTreeFormat(workingSet), TreeList.NODES_START_EXPANDED);

        /**

         * data provider

         */

        SpecimenColumnPropertyAccessor columnPropertyAccessor = new SpecimenColumnPropertyAccessor(this);

        bodyDataProvider = treeView?new ListDataProvider<>(treeList, columnPropertyAccessor):new ListDataProvider<>(sortedList, columnPropertyAccessor);

        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 for columns

        ColumnOverrideLabelAccumulator bodyColumnLabelAccumulator =new ColumnOverrideLabelAccumulator(bodyDataLayer);

        bodyDataLayer.setConfigLabelAccumulator(bodyColumnLabelAccumulator);

        propertyToLabelMap.put(TAXON_COLUMN, Messages.CharacterMatrix_TAXON);

        bodyColumnLabelAccumulator.registerColumnOverrides(0, TAXON_COLUMN);

        propertyToLabelMap.put(COLLECTOR_COLUMN, Messages.CharacterMatrix_COLLECTOR_NO);

        bodyColumnLabelAccumulator.registerColumnOverrides(1, COLLECTOR_COLUMN);

        propertyToLabelMap.put(IDENTIFIER_COLUMN, Messages.CharacterMatrix_IDENTIFIER);

        bodyColumnLabelAccumulator.registerColumnOverrides(2, IDENTIFIER_COLUMN);

        propertyToLabelMap.put(COUNTRY_COLUMN, Messages.CharacterMatrix_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);

        bodyLayer = new DefaultBodyLayerStack(

                eventLayer);

        viewportLayer = bodyLayer.getViewportLayer();

        final SelectionLayer selectionLayer = bodyLayer.getSelectionLayer();

        freezeLayer = new FreezeLayer(selectionLayer);

        final CompositeFreezeLayer compositeFreezeLayer = new CompositeFreezeLayer(

                freezeLayer, bodyLayer.getViewportLayer(), selectionLayer);

        TreeLayer treeLayer = new TreeLayer(compositeFreezeLayer, treeRowModel);

        topMostLayer = treeView?treeLayer:compositeFreezeLayer;

        summaryRowLayer = new FixedSummaryRowLayer(bodyDataLayer, topMostLayer, 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); //$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<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"); //$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, fixedSummaryRowHeaderLayer, cornerLayer);

        natTable.setLayer(gridLayer);

    }

    private void registerHandlersAndListeners(AbstractLayer topMostLayer) {

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

        // exporting work

        topMostLayer.registerCommandHandler(new ExportCommandHandler(topMostLayer));

        //propagate single cell selection

        natTable.addLayerListener(new ILayerListener() {

            @Override

            public void handleLayerEvent(ILayerEvent event) {

                if(event instanceof CellSelectionEvent){

                    CellSelectionEvent cellSelectionEvent = (CellSelectionEvent)event;

                    int columnPosition = cellSelectionEvent.getColumnPosition();

                    if(columnPosition>LEADING_COLUMN_COUNT){

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

                            }

                        }

                        part.getSelectionService().setSelection(selection);

                    }

                }

            }

        });

        //register handler for view configuration menu

        natTable.registerCommandHandler(displayPersistenceDialogCommandHandler);

    }

    private void configureNatTable(boolean treeView, ConfigRegistry configRegistry, AbstractLayer topMostLayer,

            FixedSummaryRowLayer summaryRowLayer) {

        /**

         * 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

        if(!treeView){

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

            }

        });

        Style cellStyle = new Style();

        cellStyle.setAttributeValue(CellStyleAttributes.HORIZONTAL_ALIGNMENT, HorizontalAlignmentEnum.LEFT);

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

        topMostLayer.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.CELL_STYLE,

                        cellStyle,

                        DisplayMode.NORMAL,

                        TAXON_COLUMN);

                configRegistry.registerConfigAttribute(

                        CellConfigAttributes.DISPLAY_CONVERTER,

                        new SupplementalInfoDisplayConverter(),

                        DisplayMode.NORMAL,

                        COLLECTOR_COLUMN);

                configRegistry.registerConfigAttribute(

                        CellConfigAttributes.CELL_STYLE,

                        cellStyle,

                        DisplayMode.NORMAL,

                        COLLECTOR_COLUMN);

                configRegistry.registerConfigAttribute(

                        CellConfigAttributes.DISPLAY_CONVERTER,

                        new SupplementalInfoDisplayConverter(),

                        DisplayMode.NORMAL,

                        IDENTIFIER_COLUMN);

                configRegistry.registerConfigAttribute(

                        CellConfigAttributes.CELL_STYLE,

                        cellStyle,

                        DisplayMode.NORMAL,

                        IDENTIFIER_COLUMN);

                configRegistry.registerConfigAttribute(

                        CellConfigAttributes.DISPLAY_CONVERTER,

                        new SupplementalInfoDisplayConverter(),

                        DisplayMode.NORMAL,

                        COUNTRY_COLUMN);

                configRegistry.registerConfigAttribute(

                        CellConfigAttributes.CELL_STYLE,

                        cellStyle,

                        DisplayMode.NORMAL,

                        COUNTRY_COLUMN);

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

            }

        });

        //no summary for the supplemental columns

        for(int i=0;i<LEADING_COLUMN_COUNT;i++){

            int index = i;

            summaryRowLayer.addConfiguration(new DefaultSummaryRowConfiguration() {

                @Override

                public void addSummaryProviderConfig(IConfigRegistry configRegistry) {

                    configRegistry.registerConfigAttribute(

                            SummaryRowConfigAttributes.SUMMARY_PROVIDER,

                            new ISummaryProvider() {

                                @Override

                                public Object summarize(int columnIndex) {

                                    return "";