eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/matrix/CharacterMatrix.java

   1 /**
   2  * Copyright (C) 2017 EDIT
   3  * European Distributed Institute of Taxonomy
   4  * http://www.e-taxonomy.eu
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version 1.1
   7  * See LICENSE.TXT at the top of this package for the full license terms.
   8  */
   9 package eu.etaxonomy.taxeditor.editor.descriptiveDataSet.matrix;
  10
  11 import java.io.File;
  12 import java.util.ArrayList;
  13 import java.util.Collection;
  14 import java.util.HashMap;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Properties;
  18 import java.util.Set;
  19 import java.util.UUID;
  20 import java.util.stream.Collectors;
  21
  22 import javax.inject.Inject;
  23
  24 import org.apache.commons.collections4.map.LinkedMap;
  25 import org.eclipse.core.runtime.ICoreRunnable;
  26 import org.eclipse.core.runtime.IProgressMonitor;
  27 import org.eclipse.core.runtime.SubMonitor;
  28 import org.eclipse.core.runtime.jobs.IJobChangeEvent;
  29 import org.eclipse.core.runtime.jobs.Job;
  30 import org.eclipse.core.runtime.jobs.JobChangeAdapter;
  31 import org.eclipse.e4.ui.di.UISynchronize;
  32 import org.eclipse.jface.layout.GridDataFactory;
  33 import org.eclipse.jface.viewers.ComboViewer;
  34 import org.eclipse.nebula.widgets.nattable.NatTable;
  35 import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;
  36 import org.eclipse.nebula.widgets.nattable.config.DefaultNatTableStyleConfiguration;
  37 import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
  38 import org.eclipse.nebula.widgets.nattable.data.IDataProvider;
  39 import org.eclipse.nebula.widgets.nattable.data.ListDataProvider;
  40 import org.eclipse.nebula.widgets.nattable.export.command.ExportCommandHandler;
  41 import org.eclipse.nebula.widgets.nattable.extension.glazedlists.GlazedListsEventLayer;
  42 import org.eclipse.nebula.widgets.nattable.extension.glazedlists.GlazedListsSortModel;
  43 import org.eclipse.nebula.widgets.nattable.extension.glazedlists.tree.GlazedListTreeData;
  44 import org.eclipse.nebula.widgets.nattable.extension.glazedlists.tree.GlazedListTreeRowModel;
  45 import org.eclipse.nebula.widgets.nattable.freeze.CompositeFreezeLayer;
  46 import org.eclipse.nebula.widgets.nattable.freeze.FreezeHelper;
  47 import org.eclipse.nebula.widgets.nattable.freeze.FreezeLayer;
  48 import org.eclipse.nebula.widgets.nattable.grid.GridRegion;
  49 import org.eclipse.nebula.widgets.nattable.grid.command.ClientAreaResizeCommand;
  50 import org.eclipse.nebula.widgets.nattable.grid.data.DefaultColumnHeaderDataProvider;
  51 import org.eclipse.nebula.widgets.nattable.grid.data.DefaultCornerDataProvider;
  52 import org.eclipse.nebula.widgets.nattable.grid.data.DefaultRowHeaderDataProvider;
  53 import org.eclipse.nebula.widgets.nattable.grid.data.FixedSummaryRowHeaderLayer;
  54 import org.eclipse.nebula.widgets.nattable.grid.layer.ColumnHeaderLayer;
  55 import org.eclipse.nebula.widgets.nattable.grid.layer.CornerLayer;
  56 import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultRowHeaderDataLayer;
  57 import org.eclipse.nebula.widgets.nattable.grid.layer.GridLayer;
  58 import org.eclipse.nebula.widgets.nattable.layer.AbstractLayer;
  59 import org.eclipse.nebula.widgets.nattable.layer.CompositeLayer;
  60 import org.eclipse.nebula.widgets.nattable.layer.DataLayer;
  61 import org.eclipse.nebula.widgets.nattable.layer.ILayer;
  62 import org.eclipse.nebula.widgets.nattable.layer.cell.ColumnOverrideLabelAccumulator;
  63 import org.eclipse.nebula.widgets.nattable.layer.stack.DefaultBodyLayerStack;
  64 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
  65 import org.eclipse.nebula.widgets.nattable.sort.SortHeaderLayer;
  66 import org.eclipse.nebula.widgets.nattable.sort.config.SingleClickSortConfiguration;
  67 import org.eclipse.nebula.widgets.nattable.style.HorizontalAlignmentEnum;
  68 import org.eclipse.nebula.widgets.nattable.style.theme.ModernNatTableThemeConfiguration;
  69 import org.eclipse.nebula.widgets.nattable.summaryrow.FixedSummaryRowLayer;
  70 import org.eclipse.nebula.widgets.nattable.summaryrow.SummaryRowLayer;
  71 import org.eclipse.nebula.widgets.nattable.tree.ITreeRowModel;
  72 import org.eclipse.nebula.widgets.nattable.tree.TreeLayer;
  73 import org.eclipse.nebula.widgets.nattable.util.GUIHelper;
  74 import org.eclipse.swt.SWT;
  75 import org.eclipse.swt.layout.GridData;
  76 import org.eclipse.swt.layout.GridLayout;
  77 import org.eclipse.swt.widgets.Button;
  78 import org.eclipse.swt.widgets.Composite;
  79
  80 import ca.odell.glazedlists.BasicEventList;
  81 import ca.odell.glazedlists.EventList;
  82 import ca.odell.glazedlists.SortedList;
  83 import ca.odell.glazedlists.TreeList;
  84 import eu.etaxonomy.cdm.api.service.IDescriptiveDataSetService;
  85 import eu.etaxonomy.cdm.api.service.UpdateResult;
  86 import eu.etaxonomy.cdm.api.service.dto.RowWrapperDTO;
  87 import eu.etaxonomy.cdm.api.service.dto.SpecimenRowWrapperDTO;
  88 import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;
  89 import eu.etaxonomy.cdm.model.description.DescriptionBase;
  90 import eu.etaxonomy.cdm.model.description.DescriptiveDataSet;
  91 import eu.etaxonomy.cdm.model.description.Feature;
  92 import eu.etaxonomy.cdm.model.description.FeatureNode;
  93 import eu.etaxonomy.cdm.model.description.FeatureTree;
  94 import eu.etaxonomy.cdm.model.description.MeasurementUnit;
  95 import eu.etaxonomy.cdm.model.description.State;
  96 import eu.etaxonomy.cdm.persistence.dto.SpecimenNodeWrapper;
  97 import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin;
  98 import eu.etaxonomy.taxeditor.editor.l10n.Messages;
  99 import eu.etaxonomy.taxeditor.model.MessagingUtils;
 100 import eu.etaxonomy.taxeditor.store.CdmStore;
 101 import eu.etaxonomy.taxeditor.workbench.WorkbenchUtility;
 102
 103 /**
 104  * Character matrix editor for editing specimen/taxon descriptions in a table
 105  * @author pplitzner
 106  * @since Nov 26, 2017
 107  *
 108  */
 109 public class CharacterMatrix extends Composite {
 110
 111     private static final String CHARACTER_MATRIX_STATE_PROPERTIES = "characterMatrixState.properties"; //$NON-NLS-1$
 112
 113     static final int LEADING_COLUMN_COUNT = 4;
 114     static final String TAXON_COLUMN = "taxon_column"; //$NON-NLS-1$
 115     static final String COLLECTOR_COLUMN = "collector_column"; //$NON-NLS-1$
 116     static final String IDENTIFIER_COLUMN = "identifier_column"; //$NON-NLS-1$
 117     static final String COUNTRY_COLUMN = "country_column"; //$NON-NLS-1$
 118
 119     static final String LABEL_TAXON_ROW = "TAXON_ROW"; //$NON-NLS-1$
 120     static final String LABEL_TAXON_AGGREGATED_DESCRIPTION = "TAXON_AGGREGATED_DESCRIPTION"; //$NON-NLS-1$
 121     static final String LABEL_TAXON_DESCRIPTION = "LABEL_TAXON_DESCRIPTION"; //$NON-NLS-1$
 122
 123     @Inject
 124     private UISynchronize sync;
 125
 126     private DescriptiveDataSet descriptiveDataSet;
 127
 128     private NatTable natTable;
 129
 130     private Map<Integer, Feature> indexToFeatureMap = new HashMap<>();
 131
 132     private Map<Feature, List<State>> categoricalFeatureToStateMap = new HashMap<>();
 133
 134     private LinkedMap<String, String> propertyToLabelMap = new LinkedMap<>();
 135
 136     private EventList<Object> descriptions;
 137
 138     private Collection<SpecimenNodeWrapper> specimenCache = null;
 139
 140     private Map<Feature, CategoricalDataHistogram> featureToHistogramMap = new HashMap<>();
 141
 142     private Map<Feature, QuantitativeDataStatistics> featureToQuantDataStatisticsMap = new HashMap<>();
 143
 144     private ListDataProvider<Object> bodyDataProvider;
 145
 146     private FreezeLayer freezeLayer;
 147
 148     private List<Feature> features;
 149
 150     private CharacterMatrixPart part;
 151
 152     private AbstractLayer topMostLayer;
 153
 154     private FixedSummaryRowLayer summaryRowLayer;
 155
 156     private ConfigRegistry configRegistry;
 157
 158     private DefaultBodyLayerStack bodyLayer;
 159
 160     private boolean isTreeView = true;
 161
 162     private CharacterMatrixToolbar toolbar;
 163
 164     private boolean isShowTooltips = true;
 165
 166     public CharacterMatrix(Composite parent, CharacterMatrixPart part) {
 167         super(parent, SWT.NONE);
 168         this.part = part;
 169         this.setLayout(new GridLayout());
 170
 171         createToolBar();
 172
 173         natTable = new NatTable(this, false);
 174
 175         createBottomToolbar();
 176
 177     }
 178
 179     private void createToolBar(){
 180         toolbar = new CharacterMatrixToolbar(this, SWT.NONE);
 181     }
 182
 183     @SuppressWarnings("unused")
 184     private void createBottomToolbar() {
 185         new CharacterMatrixBottomToolbar(this, SWT.NONE);
 186     }
 187
 188
 189     private void applyStyles(){
 190         ModernNatTableThemeConfiguration configuration = new ModernNatTableThemeConfiguration();
 191         configuration.summaryRowHAlign = HorizontalAlignmentEnum.CENTER;
 192         // NOTE: Getting the colors and fonts from the GUIHelper ensures that
 193         // they are disposed properly (required by SWT)
 194         configuration.cHeaderBgColor = GUIHelper.getColor(211, 211, 211);
 195         configuration.rHeaderBgColor = GUIHelper.getColor(211, 211, 211);
 196         natTable.addConfiguration(configuration);
 197
 198     }
 199
 200     void toggleTreeFlat(boolean isTree, Button btnToggleFlat, Button btnToggleTree, Button btnCollapseAll, Button btnExpandAll, Button btnFreezeSuppInfo) {
 201         isTreeView = isTree;
 202         createTable(isTree, freezeLayer.isFrozen());
 203         btnToggleFlat.setEnabled(isTree);
 204         btnToggleTree.setEnabled(!isTree);
 205         btnCollapseAll.setEnabled(isTree);
 206         btnExpandAll.setEnabled(isTree);
 207     }
 208
 209     public boolean isTreeView() {
 210         return isTreeView;
 211     }
 212
 213     public void createTable(boolean treeView, boolean freezeSupplementalColumns){
 214         /**
 215          * layers
 216          */
 217         createLayers(treeView);
 218
 219         /**
 220          * configuration
 221          */
 222         configureNatTable(treeView, configRegistry, topMostLayer, summaryRowLayer);
 223
 224         /**
 225          * handlers and listeners
 226          */
 227         registerHandlersAndListeners(topMostLayer);
 228
 229         //grab all space
 230         GridDataFactory.fillDefaults().grab(true, true).applyTo(natTable);
 231
 232         //update label to current data set
 233         toolbar.getWsLabel().setText(descriptiveDataSet.getLabel());
 234         toolbar.getWsLabel().setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
 235         toolbar.getWsLabel().getParent().layout();
 236
 237         //initial freeze of supplemental columns
 238         freezeSupplementalColumns(freezeSupplementalColumns);
 239
 240
 241         //add tooltip to table
 242         new CategoricalChartTooltip(this);
 243         new QuantitativeChartTooltip(this);
 244
 245         this.layout();
 246         natTable.doCommand(new ClientAreaResizeCommand(natTable));
 247     }
 248
 249     private List<Feature> initFeatureList(FeatureNode node){
 250         List<Feature> features = new ArrayList<>();
 251         node.getChildNodes().forEach(childNode->
 252                 {
 253                     features.add(childNode.getFeature());
 254                     features.addAll(initFeatureList(childNode));
 255                 });
 256         return features;
 257     }
 258
 259     public void initDescriptiveDataSet(DescriptiveDataSet descriptiveDataSet){
 260         this.descriptiveDataSet = descriptiveDataSet;
 261         //get features/columns stored in descriptive data set
 262         FeatureTree tree = descriptiveDataSet.getDescriptiveSystem();
 263         features = initFeatureList(tree.getRoot());
 264
 265         //init state data for categorical features
 266         features.forEach(feature->
 267         {
 268             if(feature.isSupportsCategoricalData()){
 269                 List<State> supportedStates = new ArrayList<>();
 270                 feature.getSupportedCategoricalEnumerations().forEach(voc->supportedStates.addAll(voc.getTerms()));
 271                 categoricalFeatureToStateMap.put(feature, supportedStates);
 272             }
 273         });
 274         descriptions = new BasicEventList<>();
 275
 276     }
 277
 278     private void createLayers(boolean treeView) {
 279         // use the SortedList constructor with 'null' for the Comparator
 280         // because the Comparator will be set by configuration
 281         SortedList<Object> sortedList = new SortedList<>(descriptions, new MatrixRowComparator());
 282         // wrap the SortedList with the TreeList
 283         TreeList<Object> treeList = new TreeList(sortedList, new DescriptionTreeFormat(descriptiveDataSet), TreeList.NODES_START_EXPANDED);
 284         /**
 285          * data provider
 286          */
 287         SpecimenColumnPropertyAccessor columnPropertyAccessor = new SpecimenColumnPropertyAccessor(this);
 288         bodyDataProvider = treeView?new ListDataProvider<>(treeList, columnPropertyAccessor):new ListDataProvider<>(sortedList, columnPropertyAccessor);
 289
 290         configRegistry = new ConfigRegistry();
 291
 292
 293         /**
 294          * BODY layer
 295          *
 296          *
 297
 298         CompositeLayer
 299          - (top) SummaryRowLayer
 300          - (bottom) ViewportLayer
 301
 302              ^
 303         ViewportLayer
 304
 305              ^
 306         TreeLayer (default visible)
 307
 308              ^
 309         CompositeFreezeLayer
 310          - viewportLayer
 311          - selectionLayer
 312          - freezeLayer
 313
 314              ^
 315         FreezeLayer
 316
 317              ^
 318         SelectionLayer
 319
 320              ^
 321         ColumnHideShowLayer
 322
 323              ^
 324         ColumnReorderLayer
 325
 326              ^
 327         DataLayer
 328
 329          *
 330
 331          */
 332         DataLayer bodyDataLayer = new DataLayer(bodyDataProvider);
 333
 334         //register labels
 335         CharacterMatrixConfigLabelAccumulator labelAccumulator = new CharacterMatrixConfigLabelAccumulator(this);
 336         bodyDataLayer.setConfigLabelAccumulator(labelAccumulator);
 337
 338
 339         propertyToLabelMap.put(TAXON_COLUMN, Messages.CharacterMatrix_TAXON);
 340         propertyToLabelMap.put(COLLECTOR_COLUMN, Messages.CharacterMatrix_COLLECTOR_NO);
 341         propertyToLabelMap.put(IDENTIFIER_COLUMN, Messages.CharacterMatrix_IDENTIFIER);
 342         propertyToLabelMap.put(COUNTRY_COLUMN, Messages.CharacterMatrix_COUNTRY);
 343         for(int i=0;i<features.size();i++){
 344             Feature feature = features.get(i);
 345             initLabels(i, feature);
 346         }
 347
 348         // layer for event handling of GlazedLists and PropertyChanges
 349         GlazedListsEventLayer eventLayer = new GlazedListsEventLayer<>(bodyDataLayer, treeList);
 350         GlazedListTreeData treeData = new GlazedListTreeData<>(treeList);
 351         ITreeRowModel treeRowModel = new GlazedListTreeRowModel<>(treeData);
 352
 353         bodyLayer = new DefaultBodyLayerStack(eventLayer);
 354         final SelectionLayer selectionLayer = bodyLayer.getSelectionLayer();
 355         freezeLayer = new FreezeLayer(selectionLayer);
 356         final CompositeFreezeLayer compositeFreezeLayer = new CompositeFreezeLayer(
 357                 freezeLayer, bodyLayer.getViewportLayer(), selectionLayer);
 358         TreeLayer treeLayer = new TreeLayer(compositeFreezeLayer, treeRowModel);
 359
 360         topMostLayer = treeView?treeLayer:compositeFreezeLayer;
 361
 362         summaryRowLayer = new FixedSummaryRowLayer(bodyDataLayer, topMostLayer, configRegistry, false);
 363         //regoster labels with summary prefix for summary layer
 364         ColumnOverrideLabelAccumulator summaryColumnLabelAccumulator =new ColumnOverrideLabelAccumulator(bodyDataLayer);
 365         summaryRowLayer.setConfigLabelAccumulator(summaryColumnLabelAccumulator);
 366         for(int i=0;i<features.size();i++){
 367             Feature feature = features.get(i);
 368             summaryColumnLabelAccumulator.registerColumnOverrides(
 369                     i+LEADING_COLUMN_COUNT,
 370                     SummaryRowLayer.DEFAULT_SUMMARY_COLUMN_CONFIG_LABEL_PREFIX+MatrixUtility.getProperty(feature));
 371         }
 372         // because the horizontal dependency is the ViewportLayer
 373         // we need to set the composite dependency to false
 374         summaryRowLayer.setHorizontalCompositeDependency(false);
 375
 376         CompositeLayer composite = new CompositeLayer(1, 2);
 377         composite.setChildLayer("SUMMARY", summaryRowLayer, 0, 0); //$NON-NLS-1$
 378         composite.setChildLayer(GridRegion.BODY, topMostLayer, 0, 1);
 379
 380
 381         /**
 382          * column header layer
 383          */
 384         IDataProvider columnHeaderDataProvider = new DefaultColumnHeaderDataProvider(
 385                 propertyToLabelMap.values().toArray(new String[] {}), propertyToLabelMap);
 386         DataLayer columnHeaderDataLayer = new DataLayer(columnHeaderDataProvider);
 387         ColumnHeaderLayer columnHeaderLayer = new ColumnHeaderLayer(columnHeaderDataLayer, topMostLayer, selectionLayer);
 388
 389         // add the SortHeaderLayer to the column header layer stack
 390         // as we use GlazedLists, we use the GlazedListsSortModel which
 391         // delegates the sorting to the SortedList
 392         final SortHeaderLayer<DescriptionBase> sortHeaderLayer = new SortHeaderLayer<>(
 393                 columnHeaderLayer,
 394                 new GlazedListsSortModel<>(
 395                         sortedList,
 396                         columnPropertyAccessor,
 397                         configRegistry,
 398                         columnHeaderDataLayer));
 399
 400
 401         /**
 402          * row header layer
 403          */
 404         IDataProvider rowHeaderDataProvider = new DefaultRowHeaderDataProvider(bodyDataProvider);
 405         DefaultRowHeaderDataLayer rowHeaderDataLayer = new DefaultRowHeaderDataLayer(rowHeaderDataProvider);
 406         FixedSummaryRowHeaderLayer fixedSummaryRowHeaderLayer = new FixedSummaryRowHeaderLayer(rowHeaderDataLayer,
 407                 composite, selectionLayer);
 408         fixedSummaryRowHeaderLayer.setSummaryRowLabel("\u2211"); //$NON-NLS-1$
 409
 410
 411         /**
 412          * corner layer
 413          */
 414         ILayer cornerLayer = new CornerLayer(
 415                 new DataLayer(new DefaultCornerDataProvider(columnHeaderDataProvider, rowHeaderDataProvider)),
 416                 fixedSummaryRowHeaderLayer, sortHeaderLayer);
 417
 418
 419         /**
 420          * GRID layer (composition of all other layers)
 421          */
 422         GridLayer gridLayer = new GridLayer(composite, sortHeaderLayer, fixedSummaryRowHeaderLayer, cornerLayer);
 423
 424         natTable.setLayer(gridLayer);
 425
 426     }
 427
 428     private void registerHandlersAndListeners(AbstractLayer topMostLayer) {
 429         // add the ExportCommandHandler to the ViewportLayer in order to make
 430         // exporting work
 431         topMostLayer.registerCommandHandler(new ExportCommandHandler(topMostLayer));
 432
 433         //propagate single cell selection
 434         natTable.addLayerListener(new CellSelectionListener(part));
 435
 436         //register handler for view configuration menu
 437         natTable.registerCommandHandler(toolbar.getDisplayPersistenceDialogCommandHandler());
 438     }
 439
 440     private void configureNatTable(boolean treeView,
 441             ConfigRegistry configRegistry,
 442             AbstractLayer topMostLayer,
 443             FixedSummaryRowLayer summaryRowLayer) {
 444         /**
 445          * CONFIGURATION
 446          */
 447         natTable.setConfigRegistry(configRegistry);
 448
 449         applyStyles();
 450
 451         //add default configuration because autoconfigure is set to false in constructor
 452         natTable.addConfiguration(new DefaultNatTableStyleConfiguration());
 453
 454         //FIXME: this is for DEBUG ONLY
 455         //        natTable.addConfiguration(new DebugMenuConfiguration(natTable));
 456
 457         // override the default sort configuration and change the mouse bindings
 458         // to sort on a single click
 459         if(!treeView){
 460             natTable.addConfiguration(new SingleClickSortConfiguration());
 461         }
 462
 463         natTable.addConfiguration(new CharacterMatrixLabelStyleConfiguration());
 464
 465         // add the header menu configuration for adding the column header menu
 466         // with hide/show actions
 467         natTable.addConfiguration(new CharacterMatrixHeaderMenuConfiguration(natTable));
 468
 469         // add custom configuration for data conversion and add column labels to viewport layer
 470         topMostLayer.addConfiguration(new CellEditorDataConversionConfiguration(this));
 471
 472         //register aggregation configuration
 473         summaryRowLayer.addConfiguration(new AggregationConfiguration(this));
 474
 475         natTable.configure();
 476     }
 477
 478     void freezeSupplementalColumns(boolean freeze){
 479         if(freeze){
 480             FreezeHelper.freeze(freezeLayer, bodyLayer.getViewportLayer(),
 481                     new PositionCoordinate(bodyLayer.getViewportLayer(), 0, 0),
 482                     new PositionCoordinate(bodyLayer.getViewportLayer(), LEADING_COLUMN_COUNT-1, -1));
 483         }
 484         else{
 485             FreezeHelper.unfreeze(freezeLayer, bodyLayer.getViewportLayer());
 486         }
 487     }
 488
 489     void selectStateItem(ComboViewer comboStates, String stateName){
 490         String[] items = comboStates.getCombo().getItems();
 491         for(int i=0;i<items.length;i++){
 492             if(items[i].equals(stateName)){
 493                 comboStates.getCombo().select(i);
 494                 break;
 495             }
 496         }
 497     }
 498
 499     private void initLabels(int index, Feature feature) {
 500         indexToFeatureMap.put(index+LEADING_COLUMN_COUNT, feature);
 501
 502         String featureLabel = feature.getLabel();
 503         String property = featureLabel;
 504         //show unit for quantitative data
 505         if(feature.isSupportsQuantitativeData()){
 506             Set<MeasurementUnit> recommendedMeasurementUnits = feature.getRecommendedMeasurementUnits();
 507             if(recommendedMeasurementUnits.size()>1){
 508                 MessagingUtils.warningDialog(Messages.CharacterMatrix_INIT_PROBLEM, CharacterMatrix.class,
 509                         String.format(Messages.CharacterMatrix_INIT_PROBLEM_MESSAGE, feature.getLabel()));
 510             }
 511             if(recommendedMeasurementUnits.size()==1){
 512                 MeasurementUnit unit = recommendedMeasurementUnits.iterator().next();
 513                 featureLabel += " ["+unit.getIdInVocabulary()+"]"; //$NON-NLS-1$ //$NON-NLS-2$
 514             }
 515         }
 516         propertyToLabelMap.put(property, featureLabel);
 517     }
 518
 519     public void loadDescriptions(DescriptiveDataSet descriptiveDataSet) {
 520         UUID monitorUuid = CdmStore.getService(IDescriptiveDataSetService.class).monitGetRowWrapper(descriptiveDataSet);
 521
 522         final Collection<RowWrapperDTO> wrappers = new ArrayList<>();
 523         String jobLabel = Messages.CharacterMatrix_LOAD_CHARACTER_DATA;
 524         Job job = Job.create(jobLabel, (ICoreRunnable) monitor -> {
 525             SubMonitor subMonitor = SubMonitor.convert(monitor);
 526             subMonitor.beginTask(jobLabel, IProgressMonitor.UNKNOWN);
 527             IRemotingProgressMonitor remotingMonitor;
 528             try {
 529                  remotingMonitor = CdmStore.getProgressMonitorClientManager()
 530                 .pollMonitor(jobLabel,
 531                         monitorUuid,
 532                         50,
 533                         null,
 534                         (List)null,
 535                         subMonitor);
 536             } catch (InterruptedException e) {
 537                 MessagingUtils.informationDialog(Messages.CharacterMatrix_LOADING_FAILED_TITLE,
 538                         Messages.CharacterMatrix_LOADING_FAILED_MESSAGE);
 539                 return;
 540             }
 541             Object result = remotingMonitor.getResult();
 542             if(result instanceof Collection){
 543                 wrappers.addAll((Collection<RowWrapperDTO>) result);
 544             }
 545             if(result instanceof Exception){
 546                 MessagingUtils.errorDialog("Exception during description loading", this.getClass(), "An exception occured during loading", TaxeditorEditorPlugin.PLUGIN_ID, (Throwable) result, true);
 547             }
 548             else if(wrappers.isEmpty()){
 549                 MessagingUtils.informationDialog(Messages.CharacterMatrix_NO_DESCRIPTION_TITLE,
 550                         Messages.CharacterMatrix_NO_DESCRIPTION_MESSAGE);
 551             }
 552             monitor.done();
 553         });
 554         job.addJobChangeListener(new JobChangeAdapter(){
 555             @Override
 556             public void done(IJobChangeEvent event) {
 557                 sync.syncExec(()->{
 558                     List<RowWrapperDTO> rowsWithoutTaxonNode = wrappers.stream().filter(row->row.getTaxonNode()==null).collect(Collectors.toList());
 559                     if(!rowsWithoutTaxonNode.isEmpty()){
 560                         String collect = rowsWithoutTaxonNode.stream().
 561                         map(row->row.getDescription().toString())
 562                         .collect(Collectors.joining("\n\n - ")); //$NON-NLS-1$
 563                         MessagingUtils.warningDialog(
 564                                 Messages.CharacterMatrix_NO_NODE_FOUND_TITLE,
 565                                 this.getClass(),
 566                                 String.format(Messages.CharacterMatrix_NO_NODE_FOUND_MESSAGE, collect)
 567                                 );
 568                     }
 569                     wrappers.stream().filter(row->row.getTaxonNode()!=null).forEach(wrapper->CharacterMatrix.this.descriptions.add(wrapper));
 570                     loadingDone();
 571                 });
 572             }
 573         });
 574         job.schedule();
 575     }
 576
 577     private void loadingDone() {
 578         this.part.loadingDone();
 579     }
 580
 581     public List<State> getSupportedStatesForCategoricalFeature(Feature feature){
 582         return categoricalFeatureToStateMap.get(feature);
 583     }
 584
 585     public Map<Integer, Feature> getIndexToFeatureMap() {
 586         return indexToFeatureMap;
 587     }
 588
 589     public LinkedMap<String, String> getPropertyToLabelMap() {
 590         return propertyToLabelMap;
 591     }
 592
 593     public void setDirty() {
 594         part.setDirty();
 595     }
 596
 597     public NatTable getNatTable() {
 598         return natTable;
 599     }
 600
 601     public EventList<Object> getDescriptions() {
 602         return descriptions;
 603     }
 604
 605     public DescriptiveDataSet getDescriptiveDataSet() {
 606         return descriptiveDataSet;
 607     }
 608
 609     public Collection<SpecimenNodeWrapper> getSpecimenCache() {
 610         return specimenCache;
 611     }
 612
 613     public void setSpecimenCache(Collection<SpecimenNodeWrapper> specimenCache) {
 614         this.specimenCache = specimenCache.stream()
 615                 .filter(wrapper ->
 616         //map descriptions on a list of uuids of the described specimen
 617         !this.descriptions.stream()
 618         .filter(rowWrapper->rowWrapper instanceof SpecimenRowWrapperDTO)
 619         .map(specimenRowWrapper->((SpecimenRowWrapperDTO) specimenRowWrapper).getSpecimen().getUuid())
 620         .collect(Collectors.toList())
 621         //an check if the specimen to add is already contained
 622         .contains(wrapper.getUuidAndTitleCache().getUuid())
 623         )
 624         .collect(Collectors.toList());
 625     }
 626
 627     public Properties getNatTableState() {
 628         return toolbar.getNatTableState();
 629     }
 630
 631     public ListDataProvider<Object> getBodyDataProvider() {
 632         return bodyDataProvider;
 633     }
 634
 635     DefaultBodyLayerStack getBodyLayer() {
 636         return bodyLayer;
 637     }
 638
 639     File getStatePropertiesFile() {
 640         return new File(WorkbenchUtility.getBaseLocation(), CHARACTER_MATRIX_STATE_PROPERTIES);
 641     }
 642
 643     public List<Feature> getFeatures() {
 644         return features;
 645     }
 646
 647     public void addUpdateResult(UpdateResult result){
 648         part.addUpdateResult(result);
 649     }
 650
 651     public Map<Feature, CategoricalDataHistogram> getFeatureToHistogramMap() {
 652         return featureToHistogramMap;
 653     }
 654
 655     public Map<Feature, QuantitativeDataStatistics> getFeatureToQuantDataStatisticsMap() {
 656         return featureToQuantDataStatisticsMap;
 657     }
 658
 659     public void toogleIsShowTooltips() {
 660         this.isShowTooltips = !this.isShowTooltips;
 661     }
 662
 663     public boolean isShowTooltips() {
 664         return isShowTooltips;
 665     }
 666
 667 }