EDIT

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

        /**

         * exact value editor

         */

                CharacterMatrixConfigLabelAccumulator.QUANT_EXACT);

                CharacterMatrixConfigLabelAccumulator.QUANT_EXACT);

        // add custum message

                CharacterMatrixConfigLabelAccumulator.QUANT_EXACT);

        if(feature.isSupportsQuantitativeData()){

        /**

         * aggregated value editor

         */

        configRegistry.registerConfigAttribute(

                EditConfigAttributes.CELL_EDITOR,

                new QuantitativeDataCellEditor(feature, matrix),

                DisplayMode.EDIT,

                CharacterMatrixConfigLabelAccumulator.QUANT_AGGREGATED);

        }

        else if(feature.isSupportsCategoricalData()){

    public static final String QUANT_AGGREGATED = QUANTITATIVE+"_AGGREGATED";

    public static final String QUANT_EXACT = QUANTITATIVE+"_EXACT";

                configLabels.addLabel(matrix.isExactQuantitativeValue()?QUANT_EXACT:QUANT_AGGREGATED);

/**

* 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.descriptiveDataSet.matrix.quantitative;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

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

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

import org.eclipse.swt.SWT;

import org.eclipse.swt.layout.FillLayout;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.swt.widgets.Text;

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

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

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

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

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

/**

 * Cell editor for QuantitativeData

 * @author pplitzner

 * @since Dec 7, 2017

 *

 */

public class QuantitativeDataCellEditor extends AbstractCellEditor{

    private Control editorControl;

    private Feature feature;

    private Map<StatisticalMeasure, Text> measureToTextMap = new HashMap<>();

    private Object editorValue;

    private CharacterMatrix matrix;

    private boolean dirty = false;

    public QuantitativeDataCellEditor(Feature feature, CharacterMatrix matrix) {

        super();

        this.matrix = matrix;

        this.feature = feature;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Object getEditorValue() {

        return this.editorValue;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void setEditorValue(Object value) {

        this.editorValue = value;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Control getEditorControl() {

        return editorControl;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Control createEditorControl(Composite parent) {

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

        composite.setLayout(new FillLayout(SWT.HORIZONTAL));

        for (StatisticalMeasure measure: feature.getRecommendedStatisticalMeasures()) {

            Composite measureComposite = new Composite(composite, SWT.NONE);

            GridLayout layout = new GridLayout(2, false);

            layout.horizontalSpacing = 0;

            layout.marginBottom = 0;

            layout.marginHeight = 0;

            layout.marginLeft = 0;

            layout.marginRight = 0;

            layout.marginTop = 0;

            layout.marginWidth = 0;

            layout.verticalSpacing = 0;

            measureComposite.setLayout(layout);

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

            GridData layoutData = new GridData(SWT.CENTER, SWT.TOP, false, false);

            label.setLayoutData(layoutData);

            label.setText(measure.getLabel().substring(0, 3));

            Text text = new Text(measureComposite, SWT.NONE);

            label.setLayoutData(new GridData(SWT.CENTER, SWT.TOP, false, false));

            measureToTextMap.put(measure, text);

        }

        return composite;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean commit(MoveDirectionEnum direction, boolean closeAfterCommit, boolean skipValidation) {

        if(dirty){

            matrix.setDirty();

            dirty = false;

        }

        return super.commit(direction, closeAfterCommit, skipValidation);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected Control activateCell(Composite parent, Object originalCanonicalValue) {

        Object rowObject = matrix.getBodyDataProvider().getRowObject(this.getRowIndex());

        if(rowObject instanceof RowWrapperDTO){

            this.editorControl = createEditorControl(parent);

            if(originalCanonicalValue==null){

                originalCanonicalValue = ((RowWrapperDTO) rowObject).addQuantitativeData(feature);

            }

            this.setEditorValue(originalCanonicalValue);

            if(originalCanonicalValue instanceof QuantitativeData){

                QuantitativeData quantitativeData = (QuantitativeData)originalCanonicalValue;

                Set<StatisticalMeasure> statisticalValues = quantitativeData.getFeature().getRecommendedStatisticalMeasures();

                //Fill text controls with actual values and add modify listeners for editing

                for (StatisticalMeasure value : statisticalValues) {

                    Text text = measureToTextMap.get(value);

                    text.addModifyListener(e->{

                        try {

                            float parseFloat = Float.parseFloat(text.getText());

                            quantitativeData.setSpecificStatisticalValue(parseFloat, null, value);

                            dirty = true;

                        } catch (NumberFormatException|NullPointerException ex) {

                            // ignore exception for wrong number format

                        }

                    });

                    Float specificStatisticalValue = quantitativeData.getSpecificStatisticalValue(value);

                    if(specificStatisticalValue!=null){

                        Listener[] listeners = text.getListeners(SWT.Modify);

                        for (Listener listener : listeners) {

                            text.removeListener(SWT.Modify, listener);

                        }

                        text.setText(Float.toString(specificStatisticalValue));

                        for (Listener listener : listeners) {

                            text.addListener(SWT.Modify, listener);

                        }

                    }

                }

            }

        }

        return this.editorControl;

    }

}

import java.util.stream.Collectors;

    void updateQuantitativeData(QuantitativeData object){

        QuantitativeData quantitativeData = object;

        //get all non-exact values

        List<StatisticalMeasurementValue> values = quantitativeData.getStatisticalValues().stream()

                .filter(value->!value.getType().equals(StatisticalMeasure.EXACT_VALUE()))

                .collect(Collectors.toList());

        //add back all non-exact values

        values.forEach(value->quantitativeData.addStatisticalValue(value));

        //get exact values from text fields

        List<Text> textFields = composite.getTextFields();

        for (Text text : textFields) {

                quantitativeData.addStatisticalValue(StatisticalMeasurementValue.NewInstance(StatisticalMeasure.EXACT_VALUE(), exactValue));

        }

    private List<Text> textFields = new ArrayList<>();

        //add empty text field

        Text emptyTextField = addValue(initialInput==null?null:initialInput.toString(), valuesComposite);

        //add exisiting values

        .filter(value->value.getType().equals(StatisticalMeasure.EXACT_VALUE()))

        .forEach(exact->addValue(Float.toString(exact.getValue()), valuesComposite));

    private Text addValue(String value, Composite valuesComposite) {

        GridLayout gl_composite_2 = new GridLayout(2, false);

        textFields.add(text);

    public List<Text> getTextFields() {

        return textFields;