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.HashSet;
  16 import java.util.LinkedList;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Map.Entry;
  20 import java.util.Properties;
  21 import java.util.Set;
  22 import java.util.TreeSet;
  23 import java.util.UUID;
  24 import java.util.stream.Collectors;
  25
  26 import javax.inject.Inject;
  27
  28 import org.apache.commons.collections4.map.LinkedMap;
  29 import org.eclipse.core.runtime.ICoreRunnable;
  30 import org.eclipse.core.runtime.IProgressMonitor;
  31 import org.eclipse.core.runtime.SubMonitor;
  32 import org.eclipse.core.runtime.jobs.IJobChangeEvent;
  33 import org.eclipse.core.runtime.jobs.Job;
  34 import org.eclipse.core.runtime.jobs.JobChangeAdapter;
  35 import org.eclipse.e4.ui.di.UISynchronize;
  36 import org.eclipse.e4.ui.services.EMenuService;
  37 import org.eclipse.jface.layout.GridDataFactory;
  38 import org.eclipse.jface.viewers.IStructuredSelection;
  39 import org.eclipse.jface.viewers.StructuredSelection;
  40 import org.eclipse.nebula.widgets.nattable.NatTable;
  41 import org.eclipse.nebula.widgets.nattable.config.AbstractUiBindingConfiguration;
  42 import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;
  43 import org.eclipse.nebula.widgets.nattable.config.DefaultNatTableStyleConfiguration;
  44 import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
  45 import org.eclipse.nebula.widgets.nattable.coordinate.Range;
  46 import org.eclipse.nebula.widgets.nattable.copy.command.InternalCopyDataCommandHandler;
  47 import org.eclipse.nebula.widgets.nattable.copy.command.InternalPasteDataCommandHandler;
  48 import org.eclipse.nebula.widgets.nattable.data.IDataProvider;
  49 import org.eclipse.nebula.widgets.nattable.data.ListDataProvider;
  50 import org.eclipse.nebula.widgets.nattable.export.command.ExportCommandHandler;
  51 import org.eclipse.nebula.widgets.nattable.extension.e4.selection.E4SelectionListener;
  52 import org.eclipse.nebula.widgets.nattable.extension.glazedlists.GlazedListsEventLayer;
  53 import org.eclipse.nebula.widgets.nattable.extension.glazedlists.GlazedListsSortModel;
  54 import org.eclipse.nebula.widgets.nattable.extension.glazedlists.tree.GlazedListTreeData;
  55 import org.eclipse.nebula.widgets.nattable.extension.glazedlists.tree.GlazedListTreeRowModel;
  56 import org.eclipse.nebula.widgets.nattable.freeze.CompositeFreezeLayer;
  57 import org.eclipse.nebula.widgets.nattable.freeze.FreezeHelper;
  58 import org.eclipse.nebula.widgets.nattable.freeze.FreezeLayer;
  59 import org.eclipse.nebula.widgets.nattable.grid.GridRegion;
  60 import org.eclipse.nebula.widgets.nattable.grid.command.ClientAreaResizeCommand;
  61 import org.eclipse.nebula.widgets.nattable.grid.data.DefaultColumnHeaderDataProvider;
  62 import org.eclipse.nebula.widgets.nattable.grid.data.DefaultCornerDataProvider;
  63 import org.eclipse.nebula.widgets.nattable.grid.data.DefaultRowHeaderDataProvider;
  64 import org.eclipse.nebula.widgets.nattable.grid.data.FixedSummaryRowHeaderLayer;
  65 import org.eclipse.nebula.widgets.nattable.grid.layer.ColumnHeaderLayer;
  66 import org.eclipse.nebula.widgets.nattable.grid.layer.CornerLayer;
  67 import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultRowHeaderDataLayer;
  68 import org.eclipse.nebula.widgets.nattable.grid.layer.GridLayer;
  69 import org.eclipse.nebula.widgets.nattable.group.ColumnGroupGroupHeaderLayer;
  70 import org.eclipse.nebula.widgets.nattable.group.ColumnGroupHeaderLayer;
  71 import org.eclipse.nebula.widgets.nattable.group.ColumnGroupModel;
  72 import org.eclipse.nebula.widgets.nattable.layer.AbstractLayer;
  73 import org.eclipse.nebula.widgets.nattable.layer.CompositeLayer;
  74 import org.eclipse.nebula.widgets.nattable.layer.DataLayer;
  75 import org.eclipse.nebula.widgets.nattable.layer.ILayer;
  76 import org.eclipse.nebula.widgets.nattable.layer.cell.ColumnOverrideLabelAccumulator;
  77 import org.eclipse.nebula.widgets.nattable.persistence.gui.PersistenceDialog;
  78 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
  79 import org.eclipse.nebula.widgets.nattable.sort.SortHeaderLayer;
  80 import org.eclipse.nebula.widgets.nattable.sort.config.SingleClickSortConfiguration;
  81 import org.eclipse.nebula.widgets.nattable.style.HorizontalAlignmentEnum;
  82 import org.eclipse.nebula.widgets.nattable.style.theme.ModernNatTableThemeConfiguration;
  83 import org.eclipse.nebula.widgets.nattable.summaryrow.FixedSummaryRowLayer;
  84 import org.eclipse.nebula.widgets.nattable.summaryrow.SummaryRowLayer;
  85 import org.eclipse.nebula.widgets.nattable.tree.ITreeRowModel;
  86 import org.eclipse.nebula.widgets.nattable.tree.TreeLayer;
  87 import org.eclipse.nebula.widgets.nattable.tree.command.TreeExpandToLevelCommand;
  88 import org.eclipse.nebula.widgets.nattable.ui.binding.UiBindingRegistry;
  89 import org.eclipse.nebula.widgets.nattable.ui.matcher.MouseEventMatcher;
  90 import org.eclipse.nebula.widgets.nattable.ui.menu.PopupMenuAction;
  91 import org.eclipse.nebula.widgets.nattable.ui.menu.PopupMenuBuilder;
  92 import org.eclipse.nebula.widgets.nattable.util.GUIHelper;
  93 import org.eclipse.swt.SWT;
  94 import org.eclipse.swt.layout.GridData;
  95 import org.eclipse.swt.layout.GridLayout;
  96 import org.eclipse.swt.widgets.Button;
  97 import org.eclipse.swt.widgets.Composite;
  98 import org.eclipse.swt.widgets.Menu;
  99
 100 import ca.odell.glazedlists.BasicEventList;
 101 import ca.odell.glazedlists.EventList;
 102 import ca.odell.glazedlists.SortedList;
 103 import ca.odell.glazedlists.TreeList;
 104 import eu.etaxonomy.cdm.api.application.CdmApplicationState;
 105 import eu.etaxonomy.cdm.api.service.IDescriptiveDataSetService;
 106 import eu.etaxonomy.cdm.api.service.dto.RowWrapperDTO;
 107 import eu.etaxonomy.cdm.api.service.dto.SpecimenRowWrapperDTO;
 108 import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;
 109 import eu.etaxonomy.cdm.model.description.DescriptionBase;
 110 import eu.etaxonomy.cdm.model.description.DescriptiveDataSet;
 111 import eu.etaxonomy.cdm.model.description.Feature;
 112 import eu.etaxonomy.cdm.model.description.MeasurementUnit;
 113 import eu.etaxonomy.cdm.model.term.TermNode;
 114 import eu.etaxonomy.cdm.model.term.TermTree;
 115 import eu.etaxonomy.cdm.persistence.dto.SpecimenNodeWrapper;
 116 import eu.etaxonomy.cdm.persistence.dto.TermDto;
 117 import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin;
 118 import eu.etaxonomy.taxeditor.editor.l10n.Messages;
 119 import eu.etaxonomy.taxeditor.model.MessagingUtils;
 120 import eu.etaxonomy.taxeditor.session.ICdmEntitySession;
 121 import eu.etaxonomy.taxeditor.store.CdmStore;
 122 import eu.etaxonomy.taxeditor.workbench.WorkbenchUtility;
 123
 124 /**
 125  * Character matrix editor for editing specimen/taxon descriptions in a table
 126  * @author pplitzner
 127  * @since Nov 26, 2017
 128  *
 129  */
 130 public class CharacterMatrix extends Composite {
 131
 132     private static final String CHARACTER_MATRIX_STATE_PROPERTIES = "characterMatrixState.properties"; //$NON-NLS-1$
 133
 134     static final int LEADING_COLUMN_COUNT = 4;
 135     static final String TAXON_COLUMN = "taxon_column"; //$NON-NLS-1$
 136     static final String COLLECTOR_COLUMN = "collector_column"; //$NON-NLS-1$
 137     static final String IDENTIFIER_COLUMN = "identifier_column"; //$NON-NLS-1$
 138     static final String COUNTRY_COLUMN = "country_column"; //$NON-NLS-1$
 139
 140     static final String LABEL_TAXON_ROW = "TAXON_ROW"; //$NON-NLS-1$
 141     static final String LABEL_TAXON_AGGREGATED_DESCRIPTION = "TAXON_AGGREGATED_DESCRIPTION"; //$NON-NLS-1$
 142     static final String LABEL_TAXON_AGGREGATED_DESCRIPTION_ICON = "TAXON_AGGREGATED_DESCRIPTION_ICON"; //$NON-NLS-1$
 143     static final String LABEL_TAXON_DEFAULT_DESCRIPTION = "TAXON_DEFAULT_DESCRIPTION"; //$NON-NLS-1$
 144     static final String LABEL_TAXON_DEFAULT_DESCRIPTION_ICON = "TAXON_DEFAULT_DESCRIPTION_ICON"; //$NON-NLS-1$
 145     static final String LABEL_TAXON_LITERATURE_DESCRIPTION = "TAXON_LITERATURE_DESCRIPTION"; //$NON-NLS-1$
 146     static final String LABEL_TAXON_LITERATURE_DESCRIPTION_ICON = "TAXON_LITERATURE_DESCRIPTION_ICON"; //$NON-NLS-1$
 147     static final String LABEL_TAXON_DESCRIPTION = "LABEL_TAXON_DESCRIPTION"; //$NON-NLS-1$
 148     static final String LABEL_DESCRIPTION_HAS_SUPPLEMENTAL_DATA = "LABEL_DESCRIPTION_HAS_SUPPLEMENTAL_DATA"; //$NON-NLS-1$
 149
 150     @Inject
 151     private UISynchronize sync;
 152
 153     @Inject
 154     private EMenuService menuService;
 155
 156     private NatTable natTable;
 157
 158     private Collection<RowWrapperDTO<?>> rowsToSave = new HashSet<>();
 159
 160     private Map<Integer, Feature> indexToFeatureMap = new HashMap<>();
 161
 162     private Map<Feature, List<TermDto>> categoricalFeatureToStateMap = new HashMap<>();
 163
 164     private LinkedMap<String, String> propertyToLabelMap = new LinkedMap<>();
 165
 166     private EventList<Object> descriptions;
 167
 168     private Collection<SpecimenNodeWrapper> specimenCache = null;
 169
 170     private Map<Feature, CategoricalDataHistogram> featureToHistogramMap = new HashMap<>();
 171
 172     private Map<Feature, QuantitativeDataStatistics> featureToQuantDataStatisticsMap = new HashMap<>();
 173
 174     private ListDataProvider<Object> bodyDataProvider;
 175
 176     private FreezeLayer freezeLayer;
 177
 178     private List<Feature> features;
 179
 180     private CharacterMatrixPart part;
 181
 182     private AbstractLayer topMostLayer;
 183
 184     private FixedSummaryRowLayer summaryRowLayer;
 185
 186     private ConfigRegistry configRegistry;
 187
 188     private MatrixBodyLayerStack bodyLayer;
 189
 190     private boolean isTreeView = true;
 191
 192     private CharacterMatrixToolbar toolbar;
 193
 194     private boolean isShowTooltips = true;
 195
 196     private DescriptionTreeFormat treeFormat;
 197
 198     public CharacterMatrix(Composite parent, CharacterMatrixPart part) {
 199         super(parent, SWT.NONE);
 200         this.part = part;
 201         this.setLayout(new GridLayout());
 202
 203         createToolBar();
 204
 205         natTable = new NatTable(this, false);
 206
 207         createBottomToolbar();
 208
 209     }
 210
 211     private void createToolBar(){
 212         toolbar = new CharacterMatrixToolbar(this, SWT.NONE);
 213     }
 214
 215     @SuppressWarnings("unused")
 216     private void createBottomToolbar() {
 217         new CharacterMatrixBottomToolbar(this, SWT.NONE);
 218     }
 219
 220
 221     private void applyStyles(){
 222         ModernNatTableThemeConfiguration configuration = new ModernNatTableThemeConfiguration();
 223         configuration.summaryRowHAlign = HorizontalAlignmentEnum.CENTER;
 224         // NOTE: Getting the colors and fonts from the GUIHelper ensures that
 225         // they are disposed properly (required by SWT)
 226         configuration.cHeaderBgColor = GUIHelper.getColor(211, 211, 211);
 227         configuration.rHeaderBgColor = GUIHelper.getColor(211, 211, 211);
 228         natTable.addConfiguration(configuration);
 229
 230     }
 231
 232     void toggleTreeFlat(boolean isTree, Button btnToggleFlat, Button btnToggleTree, Button btnCollapseAll, Button btnExpandAll, Button btnFreezeSuppInfo) {
 233         isTreeView = isTree;
 234         createTable(isTree, freezeLayer.isFrozen(), true);
 235         btnToggleFlat.setEnabled(isTree);
 236         btnToggleTree.setEnabled(!isTree);
 237         btnCollapseAll.setEnabled(isTree);
 238         btnExpandAll.setEnabled(isTree);
 239     }
 240
 241     public boolean isTreeView() {
 242         return isTreeView;
 243     }
 244
 245     public void createTable(boolean treeView, boolean freezeSupplementalColumns, boolean isInitialExpandToDeepestTaxonLevel){
 246         /**
 247          * layers
 248          */
 249         createLayers(treeView);
 250
 251         /**
 252          * configuration
 253          */
 254         configureNatTable(treeView, configRegistry, topMostLayer, summaryRowLayer);
 255
 256         /**
 257          * handlers and listeners
 258          */
 259         registerHandlersAndListeners();
 260
 261         //grab all space
 262         GridDataFactory.fillDefaults().grab(true, true).applyTo(natTable);
 263
 264         //update label to current data set
 265         toolbar.getWsLabel().setText(getDescriptiveDataSet().getLabel());
 266         toolbar.getWsLabel().setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
 267         toolbar.getWsLabel().getParent().layout();
 268
 269         //initial freeze of supplemental columns
 270         freezeSupplementalColumns(freezeSupplementalColumns);
 271
 272
 273         //add tooltip to table
 274 //        new CategoricalChartTooltip(this);
 275 //        new QuantitativeChartTooltip(this);
 276
 277
 278         this.layout();
 279         natTable.doCommand(new ClientAreaResizeCommand(natTable));
 280
 281         // expand all taxa
 282         if(isInitialExpandToDeepestTaxonLevel){
 283             Integer deepestTaxonLevel = treeFormat.getDeepestTaxonLevel();
 284             if(deepestTaxonLevel!=null){
 285                 natTable.doCommand(new TreeExpandToLevelCommand(deepestTaxonLevel-2));
 286             }
 287         }
 288
 289         // clean up table state
 290         getNatTableState().remove(NatTable.INITIAL_PAINT_COMPLETE_FLAG);
 291         getNatTableState().remove(PersistenceDialog.ACTIVE_VIEW_CONFIGURATION_KEY);
 292     }
 293
 294     private List<Feature> initFeatureList(TermNode<Feature> node){
 295         List<Feature> features = new ArrayList<>();
 296         node.getChildNodes().forEach(childNode->
 297                 {
 298                     features.add(childNode.getTerm());
 299                     features.addAll(initFeatureList(childNode));
 300                 });
 301         return features;
 302     }
 303
 304     public void initDescriptiveDataSet(){
 305         //get features/columns stored in descriptive data set
 306         TermTree<Feature> tree = getDescriptiveDataSet().getDescriptiveSystem();
 307         features = initFeatureList(tree.getRoot());
 308
 309         //init state data for categorical features
 310         features.forEach(feature->fetchSupportedStates(feature));
 311
 312         descriptions = new BasicEventList<>();
 313
 314     }
 315
 316     private void fetchSupportedStates(Feature feature) {
 317         List<TermDto> supportedStates = CdmStore.getService(IDescriptiveDataSetService.class).getSupportedStatesForFeature(feature.getUuid());
 318         categoricalFeatureToStateMap.put(feature, supportedStates);
 319     }
 320
 321     private void createLayers(boolean treeView) {
 322         SortedList<Object> sortedList = new SortedList<>(descriptions, new MatrixRowComparator());
 323         // wrap the SortedList with the TreeList
 324         treeFormat = new DescriptionTreeFormat(getDescriptiveDataSet());
 325         TreeList<Object> treeList = new TreeList(sortedList, treeFormat, TreeList.NODES_START_COLLAPSED);
 326         /**
 327          * data provider
 328          */
 329         SpecimenColumnPropertyAccessor columnPropertyAccessor = new SpecimenColumnPropertyAccessor(this);
 330         bodyDataProvider = treeView?new ListDataProvider<>(treeList, columnPropertyAccessor):new ListDataProvider<>(sortedList, columnPropertyAccessor);
 331
 332         configRegistry = new ConfigRegistry();
 333
 334
 335         /**
 336          * BODY layer
 337          *
 338          *
 339
 340         CompositeLayer
 341          - (top) SummaryRowLayer
 342          - (bottom) ViewportLayer
 343
 344              ^
 345         ViewportLayer
 346
 347              ^
 348         TreeLayer (default visible)
 349
 350              ^
 351         CompositeFreezeLayer
 352          - viewportLayer
 353          - selectionLayer
 354          - freezeLayer
 355
 356              ^
 357         FreezeLayer
 358
 359              ^
 360         SelectionLayer
 361
 362              ^
 363         ColumnHideShowLayer
 364
 365              ^
 366         ColumnReorderLayer
 367
 368              ^
 369         DataLayer
 370
 371          *
 372
 373          */
 374         DataLayer bodyDataLayer = new DataLayer(bodyDataProvider);
 375         bodyDataLayer.registerCommandHandler(new CopyPasteUpdateDataCommandHandler(bodyDataLayer));
 376
 377         //register labels
 378         CharacterMatrixConfigLabelAccumulator labelAccumulator = new CharacterMatrixConfigLabelAccumulator(this);
 379         bodyDataLayer.setConfigLabelAccumulator(labelAccumulator);
 380
 381
 382         propertyToLabelMap.put(TAXON_COLUMN, Messages.CharacterMatrix_TAXON);
 383         propertyToLabelMap.put(COLLECTOR_COLUMN, Messages.CharacterMatrix_COLLECTOR_NO);
 384         propertyToLabelMap.put(IDENTIFIER_COLUMN, Messages.CharacterMatrix_IDENTIFIER);
 385         propertyToLabelMap.put(COUNTRY_COLUMN, Messages.CharacterMatrix_COUNTRY);
 386         for(int i=0;i<features.size();i++){
 387             Feature feature = features.get(i);
 388             initLabels(i, feature);
 389         }
 390
 391         // layer for event handling of GlazedLists and PropertyChanges
 392         GlazedListsEventLayer eventLayer = new GlazedListsEventLayer<>(bodyDataLayer, (EventList)bodyDataProvider.getList());
 393
 394         GlazedListTreeData treeData = new GlazedListTreeData<>(treeList);
 395         ITreeRowModel treeRowModel = new GlazedListTreeRowModel<>(treeData);
 396
 397         // assemble the column groups
 398         LinkedList<ColumnGroupWrapper> columnGroups = new LinkedList<>();
 399         List<TermNode<Feature>> rootChildren = getDescriptiveDataSet().getDescriptiveSystem().getRootChildren();
 400         buildHeader(rootChildren, columnGroups);
 401
 402         bodyLayer = new MatrixBodyLayerStack(eventLayer, columnGroups);
 403         final SelectionLayer selectionLayer = bodyLayer.getSelectionLayer();
 404         freezeLayer = new FreezeLayer(selectionLayer);
 405         final CompositeFreezeLayer compositeFreezeLayer = new CompositeFreezeLayer(
 406                 freezeLayer, bodyLayer.getViewportLayer(), selectionLayer);
 407         TreeLayer treeLayer = new TreeLayer(compositeFreezeLayer, treeRowModel);
 408
 409         topMostLayer = treeView?treeLayer:compositeFreezeLayer;
 410
 411         summaryRowLayer = new FixedSummaryRowLayer(bodyDataLayer, topMostLayer, configRegistry, false);
 412         //regoster labels with summary prefix for summary layer
 413         ColumnOverrideLabelAccumulator summaryColumnLabelAccumulator =new ColumnOverrideLabelAccumulator(bodyDataLayer);
 414         summaryRowLayer.setConfigLabelAccumulator(summaryColumnLabelAccumulator);
 415         for(int i=0;i<features.size();i++){
 416             Feature feature = features.get(i);
 417             summaryColumnLabelAccumulator.registerColumnOverrides(
 418                     i+LEADING_COLUMN_COUNT,
 419                     SummaryRowLayer.DEFAULT_SUMMARY_COLUMN_CONFIG_LABEL_PREFIX+MatrixUtility.getProperty(feature));
 420         }
 421         // because the horizontal dependency is the ViewportLayer
 422         // we need to set the composite dependency to false
 423         summaryRowLayer.setHorizontalCompositeDependency(false);
 424
 425         CompositeLayer composite = new CompositeLayer(1, 2);
 426         composite.setChildLayer("SUMMARY", summaryRowLayer, 0, 0); //$NON-NLS-1$
 427         composite.setChildLayer(GridRegion.BODY, topMostLayer, 0, 1);
 428
 429
 430         /**
 431          * column header layer
 432          */
 433         IDataProvider columnHeaderDataProvider = new DefaultColumnHeaderDataProvider(
 434                 propertyToLabelMap.values().toArray(new String[] {}), propertyToLabelMap);
 435         DataLayer columnHeaderDataLayer = new DataLayer(columnHeaderDataProvider);
 436         ColumnHeaderLayer columnHeaderLayer = new ColumnHeaderLayer(columnHeaderDataLayer, topMostLayer, selectionLayer);
 437
 438         ILayer topHeaderLayer = columnHeaderLayer;
 439
 440         if(!columnGroups.isEmpty()){
 441             // first group level
 442             ColumnGroupWrapper groupLevel1 = columnGroups.get(0);
 443             ColumnGroupHeaderLayer groupLayerLevel1 = null;
 444             ColumnGroupGroupHeaderLayer groupLayerLevel2 = null;
 445             groupLayerLevel1 = new ColumnGroupHeaderLayer(columnHeaderLayer, selectionLayer, groupLevel1.getModel());
 446             for (Entry<TermNode<Feature>, TreeSet<Integer>> entry: groupLevel1.getColumnGroupToIndexMap().entrySet()) {
 447                 TermNode<Feature> group = entry.getKey();
 448                 TreeSet<Integer> indexList = entry.getValue();
 449                 int[] intArray = indexList.stream().mapToInt(Integer::intValue).toArray();
 450                 groupLayerLevel1.addColumnsIndexesToGroup(group.getTerm().getTitleCache(), intArray);
 451                 groupLayerLevel1.setGroupUnbreakable(indexList.iterator().next());
 452             }
 453             topHeaderLayer = groupLayerLevel1;
 454
 455             // second group level
 456             if(columnGroups.size()>1){
 457                 ColumnGroupWrapper groupLevel2 = columnGroups.get(1);
 458                 groupLayerLevel2 = new ColumnGroupGroupHeaderLayer(groupLayerLevel1, selectionLayer, groupLevel2.getModel());
 459                 for (Entry<TermNode<Feature>, TreeSet<Integer>> entry: groupLevel2.getColumnGroupToIndexMap().entrySet()) {
 460                     TermNode<Feature> group = entry.getKey();
 461                     TreeSet<Integer> indexList = entry.getValue();
 462                     int[] intArray = indexList.stream().mapToInt(Integer::intValue).toArray();
 463                     groupLayerLevel2.addColumnsIndexesToGroup(group.getTerm().getTitleCache(), intArray);
 464                     groupLayerLevel2.setGroupUnbreakable(indexList.iterator().next());
 465                 }
 466                 topHeaderLayer = groupLayerLevel2;
 467             }
 468         }
 469
 470         // add the SortHeaderLayer to the column header layer stack
 471         // as we use GlazedLists, we use the GlazedListsSortModel which
 472         // delegates the sorting to the SortedList
 473         final SortHeaderLayer<DescriptionBase> sortHeaderLayer = new SortHeaderLayer<>(
 474                 topHeaderLayer,
 475                 new GlazedListsSortModel<>(
 476                         sortedList,
 477                         columnPropertyAccessor,
 478                         configRegistry,
 479                         columnHeaderDataLayer));
 480
 481
 482
 483         /**
 484          * row header layer
 485          */
 486         IDataProvider rowHeaderDataProvider = new DefaultRowHeaderDataProvider(bodyDataProvider);
 487         DefaultRowHeaderDataLayer rowHeaderDataLayer = new DefaultRowHeaderDataLayer(rowHeaderDataProvider);
 488         FixedSummaryRowHeaderLayer fixedSummaryRowHeaderLayer = new FixedSummaryRowHeaderLayer(rowHeaderDataLayer,
 489                 composite, selectionLayer);
 490         fixedSummaryRowHeaderLayer.setSummaryRowLabel("\u2211"); //$NON-NLS-1$
 491
 492
 493         /**
 494          * corner layer
 495          */
 496         ILayer cornerLayer = new CornerLayer(
 497                 new DataLayer(new DefaultCornerDataProvider(columnHeaderDataProvider, rowHeaderDataProvider)),
 498                 fixedSummaryRowHeaderLayer, sortHeaderLayer);
 499
 500
 501         /**
 502          * GRID layer (composition of all other layers)
 503          */
 504         GridLayer gridLayer = new GridLayer(composite, sortHeaderLayer, fixedSummaryRowHeaderLayer, cornerLayer);
 505
 506         natTable.setLayer(gridLayer);
 507
 508     }
 509
 510     private TreeSet<Integer> recurseChildIndexes(TermNode<Feature> node){
 511         TreeSet<Integer> childIndexes = new TreeSet<>();
 512         if(node.getChildCount()>0){
 513             List<TermNode<Feature>> childNodes = node.getChildNodes();
 514             for (TermNode<Feature> childNode: childNodes) {
 515                 childIndexes.addAll(recurseChildIndexes(childNode));
 516             }
 517         }
 518         childIndexes.add(features.indexOf(node.getTerm())+LEADING_COLUMN_COUNT);
 519         return childIndexes;
 520     }
 521
 522     private void buildHeader(List<TermNode<Feature>> nodes, LinkedList<ColumnGroupWrapper> columnGroups){
 523         Map<TermNode<Feature>, TreeSet<Integer>> columnGroupToIndexMap = new HashMap<>();
 524         List<TermNode<Feature>> childNodes = new ArrayList<>();
 525         for (TermNode<Feature> node : nodes) {
 526             TreeSet<Integer> childIndexes = recurseChildIndexes(node);
 527             if(childIndexes.size()>1){
 528                 // filter out groups that only have one member
 529                 columnGroupToIndexMap.put(node, childIndexes);
 530             }
 531             childNodes.addAll(node.getChildNodes());
 532         }
 533         if(!columnGroupToIndexMap.isEmpty()){
 534             columnGroups.addFirst(new ColumnGroupWrapper(new ColumnGroupModel(), columnGroupToIndexMap));
 535         }
 536         if(!childNodes.isEmpty()){
 537             buildHeader(childNodes, columnGroups);
 538         }
 539     }
 540
 541     private void registerHandlersAndListeners() {
 542         natTable.registerCommandHandler(new ExportCommandHandler(natTable));
 543
 544         //selection listener
 545         E4SelectionListener selectionListener = new CellSelectionListener(part.getSelectionService(),
 546                 bodyLayer.getSelectionLayer(), bodyDataProvider, part);
 547         bodyLayer.getSelectionLayer().addLayerListener(selectionListener);
 548         selectionListener.setFullySelectedRowsOnly(false);
 549
 550         //register handler for view configuration menu
 551         natTable.registerCommandHandler(toolbar.getDisplayPersistenceDialogCommandHandler());
 552
 553         //register handlers for copy&paste
 554         natTable.registerCommandHandler(
 555                 new InternalPasteDataCommandHandler(bodyLayer.getSelectionLayer(), natTable.getInternalCellClipboard()));
 556         natTable.registerCommandHandler(
 557                 new InternalCopyDataCommandHandler(bodyLayer.getSelectionLayer(), natTable.getInternalCellClipboard()));
 558     }
 559
 560     private void configureNatTable(boolean treeView,
 561             ConfigRegistry configRegistry,
 562             AbstractLayer topMostLayer,
 563             FixedSummaryRowLayer summaryRowLayer) {
 564         /**
 565          * CONFIGURATION
 566          */
 567         natTable.setConfigRegistry(configRegistry);
 568
 569         applyStyles();
 570
 571         //add default configuration because autoconfigure is set to false in constructor
 572         natTable.addConfiguration(new DefaultNatTableStyleConfiguration());
 573
 574         // this is for DEBUG ONLY
 575         //        natTable.addConfiguration(new DebugMenuConfiguration(natTable));
 576
 577         // override the default sort configuration and change the mouse bindings
 578         // to sort on a single click
 579         if(!treeView){
 580             natTable.addConfiguration(new SingleClickSortConfiguration());
 581         }
 582
 583         natTable.addConfiguration(new CharacterMatrixLabelStyleConfiguration());
 584
 585         // add the header menu configuration for adding the column header menu
 586         // with hide/show actions
 587         natTable.addConfiguration(new CharacterMatrixHeaderMenuConfiguration(natTable));
 588
 589         // add custom configuration for data conversion and add column labels to viewport layer
 590         topMostLayer.addConfiguration(new CellEditorDataConversionConfiguration(this));
 591
 592         //register aggregation configuration
 593         summaryRowLayer.addConfiguration(new AggregationConfiguration(this));
 594
 595         //copy&paste configuration
 596         natTable.addConfiguration(new CopyPasteEditBindings(bodyLayer.getSelectionLayer(), natTable.getInternalCellClipboard()));
 597
 598       //+++CONTEXT MENU+++
 599         menuService.registerContextMenu(natTable, "eu.etaxonomy.taxeditor.editor.popupmenu.charactermatrix"); //$NON-NLS-1$
 600         // get the menu registered by EMenuService
 601         final Menu e4Menu = natTable.getMenu();
 602         // remove the menu reference from NatTable instance
 603         natTable.setMenu(null);
 604         natTable.addConfiguration(
 605                 new AbstractUiBindingConfiguration() {
 606             @Override
 607             public void configureUiBindings(
 608                     UiBindingRegistry uiBindingRegistry) {
 609                 // add e4 menu to NatTable
 610                 new PopupMenuBuilder(natTable, e4Menu)
 611                     .build();
 612
 613                 // register the UI binding for header, corner and body region
 614                 uiBindingRegistry.registerMouseDownBinding(
 615                         new MouseEventMatcher(
 616                                 SWT.NONE,
 617                                 null,
 618                                 MouseEventMatcher.RIGHT_BUTTON),
 619                         new PopupMenuAction(e4Menu));
 620             }
 621         });
 622
 623         natTable.configure();
 624     }
 625
 626     void freezeSupplementalColumns(boolean freeze){
 627         if(freeze){
 628             FreezeHelper.freeze(freezeLayer, bodyLayer.getViewportLayer(),
 629                     new PositionCoordinate(bodyLayer.getViewportLayer(), 0, 0),
 630                     new PositionCoordinate(bodyLayer.getViewportLayer(), LEADING_COLUMN_COUNT-1, -1));
 631         }
 632         else{
 633             FreezeHelper.unfreeze(freezeLayer, bodyLayer.getViewportLayer());
 634         }
 635     }
 636
 637     private void initLabels(int index, Feature feature) {
 638         indexToFeatureMap.put(index+LEADING_COLUMN_COUNT, feature);
 639
 640         String label = feature.getLabel();
 641         String property = feature.getUuid().toString();
 642         //show unit for quantitative data
 643         if(feature.isSupportsQuantitativeData()){
 644             Set<MeasurementUnit> recommendedMeasurementUnits = feature.getRecommendedMeasurementUnits();
 645             if(recommendedMeasurementUnits.size()>1){
 646                 MessagingUtils.warningDialog(Messages.CharacterMatrix_INIT_PROBLEM, CharacterMatrix.class,
 647                         String.format(Messages.CharacterMatrix_INIT_PROBLEM_MESSAGE, feature.getLabel()));
 648             }
 649             if(recommendedMeasurementUnits.size()==1){
 650                 MeasurementUnit unit = recommendedMeasurementUnits.iterator().next();
 651                 label += " ["+unit.getIdInVocabulary()+"]"; //$NON-NLS-1$ //$NON-NLS-2$
 652             }
 653         }
 654         propertyToLabelMap.put(property, label);
 655     }
 656
 657     public void loadDescriptions(UUID descriptiveDataSetUuid, boolean isInitialExpandToDeepestTaxonLevel) {
 658         UUID monitorUuid =  CdmApplicationState.getLongRunningTasksService().monitGetRowWrapper(descriptiveDataSetUuid);
 659
 660         final Collection<RowWrapperDTO> wrappers = new ArrayList<>();
 661         String jobLabel = Messages.CharacterMatrix_LOAD_CHARACTER_DATA;
 662         Job job = Job.create(jobLabel, (ICoreRunnable) monitor -> {
 663             SubMonitor subMonitor = SubMonitor.convert(monitor);
 664             subMonitor.beginTask(jobLabel, IProgressMonitor.UNKNOWN);
 665             IRemotingProgressMonitor remotingMonitor;
 666             try {
 667                  remotingMonitor = CdmStore.getProgressMonitorClientManager()
 668                 .pollMonitor(jobLabel,
 669                         monitorUuid,
 670                         50,
 671                         null,
 672                         (List)null,
 673                         subMonitor);
 674             } catch (InterruptedException e) {
 675                 MessagingUtils.informationDialog(Messages.CharacterMatrix_LOADING_FAILED_TITLE,
 676                         Messages.CharacterMatrix_LOADING_FAILED_MESSAGE);
 677                 return;
 678             }
 679             Object result = remotingMonitor.getResult();
 680             if(result instanceof Collection){
 681                 wrappers.addAll((Collection<RowWrapperDTO>) result);
 682             }
 683             if(result instanceof Exception){
 684                 MessagingUtils.errorDialog("Exception during description loading", this.getClass(), "An exception occured during loading", TaxeditorEditorPlugin.PLUGIN_ID, (Throwable) result, true);
 685             }
 686             else if(wrappers.isEmpty()){
 687                 MessagingUtils.informationDialog(Messages.CharacterMatrix_NO_DESCRIPTION_TITLE,
 688                         Messages.CharacterMatrix_NO_DESCRIPTION_MESSAGE);
 689             }
 690             monitor.done();
 691         });
 692         job.addJobChangeListener(new JobChangeAdapter(){
 693             @Override
 694             public void done(IJobChangeEvent event) {
 695                 sync.syncExec(()->{
 696                     List<RowWrapperDTO> rowsWithoutTaxonNode = wrappers.stream().filter(row->row.getTaxonNode()==null).collect(Collectors.toList());
 697                     if(!rowsWithoutTaxonNode.isEmpty()){
 698                         String collect = rowsWithoutTaxonNode.stream().
 699                         map(row->row.getDescription().toString())
 700                         .collect(Collectors.joining("\n\n - ")); //$NON-NLS-1$
 701                         MessagingUtils.warningDialog(
 702                                 Messages.CharacterMatrix_NO_NODE_FOUND_TITLE,
 703                                 this.getClass(),
 704                                 String.format(Messages.CharacterMatrix_NO_NODE_FOUND_MESSAGE, collect)
 705                                 );
 706                     }
 707                     descriptions.clear();
 708                     wrappers.stream().filter(row->row.getTaxonNode()!=null).forEach(wrapper->CharacterMatrix.this.descriptions.add(wrapper));
 709                     loadingDone(isInitialExpandToDeepestTaxonLevel);
 710                 });
 711             }
 712         });
 713         job.schedule();
 714     }
 715
 716     public IStructuredSelection getSelection(){
 717         Set<Range> selectedRowPositions = bodyLayer.getSelectionLayer().getSelectedRowPositions();
 718         List<Object> selectedObjects = new ArrayList<>();
 719         for (Range range : selectedRowPositions) {
 720             for(int i=range.start;i<range.end;i++){
 721                 selectedObjects.add(bodyDataProvider.getRowObject(i));
 722             }
 723         }
 724         return new StructuredSelection(selectedObjects);
 725     }
 726
 727     private void loadingDone(boolean isInitialExpandToDeepestTaxonLevel) {
 728         this.part.loadingDone();
 729         createTable(isTreeView, freezeLayer.isFrozen(), isInitialExpandToDeepestTaxonLevel);
 730     }
 731
 732     public List<TermDto> getSupportedStatesForCategoricalFeature(Feature feature){
 733         return categoricalFeatureToStateMap.get(feature);
 734     }
 735
 736     public Map<Integer, Feature> getIndexToFeatureMap() {
 737         return indexToFeatureMap;
 738     }
 739
 740     public LinkedMap<String, String> getPropertyToLabelMap() {
 741         return propertyToLabelMap;
 742     }
 743
 744     public void setDirty() {
 745         part.setDirty();
 746     }
 747
 748     public CharacterMatrixPart getPart() {
 749         return part;
 750     }
 751
 752     public NatTable getNatTable() {
 753         return natTable;
 754     }
 755
 756     public EventList<Object> getDescriptions() {
 757         return descriptions;
 758     }
 759
 760     public DescriptiveDataSet getDescriptiveDataSet() {
 761         return part.getDescriptiveDataSet();
 762     }
 763
 764     public void setDescriptiveDataSet(DescriptiveDataSet dataSet) {
 765         part.setDescriptiveDataSet(dataSet);
 766     }
 767
 768     public Collection<SpecimenNodeWrapper> getSpecimenCache() {
 769         return specimenCache;
 770     }
 771
 772     public void setSpecimenCache(Collection<SpecimenNodeWrapper> specimenCache) {
 773         this.specimenCache = specimenCache.stream()
 774                 .filter(wrapper ->
 775         //map descriptions on a list of uuids of the described specimen
 776         !this.descriptions.stream()
 777         .filter(rowWrapper->rowWrapper instanceof SpecimenRowWrapperDTO)
 778         .map(specimenRowWrapper->((SpecimenRowWrapperDTO) specimenRowWrapper).getSpecimen().getUuid())
 779         .collect(Collectors.toList())
 780         //and check if the specimen to add is already contained
 781         .contains(wrapper.getUuidAndTitleCache().getUuid())
 782         )
 783         .collect(Collectors.toList());
 784     }
 785
 786     public void addRowToSave(RowWrapperDTO<?> row){
 787         rowsToSave.add(row);
 788     }
 789
 790     public Collection<RowWrapperDTO<?>> getRowsToSave() {
 791         return rowsToSave;
 792     }
 793
 794     public Properties getNatTableState() {
 795         return toolbar.getNatTableState();
 796     }
 797
 798     public ListDataProvider<Object> getBodyDataProvider() {
 799         return bodyDataProvider;
 800     }
 801
 802     MatrixBodyLayerStack getBodyLayer() {
 803         return bodyLayer;
 804     }
 805
 806     File getStatePropertiesFile() {
 807         return new File(WorkbenchUtility.getBaseLocation(), CHARACTER_MATRIX_STATE_PROPERTIES);
 808     }
 809
 810     public List<Feature> getFeatures() {
 811         return features;
 812     }
 813
 814     public Map<Feature, CategoricalDataHistogram> getFeatureToHistogramMap() {
 815         return featureToHistogramMap;
 816     }
 817
 818     public Map<Feature, QuantitativeDataStatistics> getFeatureToQuantDataStatisticsMap() {
 819         return featureToQuantDataStatisticsMap;
 820     }
 821
 822     public void toogleIsShowTooltips() {
 823         this.isShowTooltips = !this.isShowTooltips;
 824     }
 825
 826     public boolean isShowTooltips() {
 827         return isShowTooltips;
 828     }
 829
 830     public ICdmEntitySession getCdmEntitiySession(){
 831         return part.getCdmEntitySession();
 832     }
 833
 834 }