Project

General

Profile

Revision cb89f4f7

IDcb89f4f7e3766c95635f684be724a814c6ae5281
Parent 3c373afd
Child 50cdece7

Added by Andreas Müller about 1 year ago

ref #6794 adapt TaxEditor to new term structure (rename FeatureNode and FeatureTree)

View differences:

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/api/application/CdmApplicationRemoteConfiguration.java
45 45
import eu.etaxonomy.cdm.api.service.ICommonService;
46 46
import eu.etaxonomy.cdm.api.service.IDatabaseService;
47 47
import eu.etaxonomy.cdm.api.service.IDescriptionService;
48
import eu.etaxonomy.cdm.api.service.IDescriptiveDataSetService;
48 49
import eu.etaxonomy.cdm.api.service.IEntityConstraintViolationService;
49 50
import eu.etaxonomy.cdm.api.service.IEntityValidationService;
50 51
import eu.etaxonomy.cdm.api.service.IEventBaseService;
......
65 66
import eu.etaxonomy.cdm.api.service.IReferenceService;
66 67
import eu.etaxonomy.cdm.api.service.IRegistrationService;
67 68
import eu.etaxonomy.cdm.api.service.IRightsService;
68
import eu.etaxonomy.cdm.api.service.IService;
69 69
import eu.etaxonomy.cdm.api.service.ITaxonNodeService;
70 70
import eu.etaxonomy.cdm.api.service.ITaxonService;
71
import eu.etaxonomy.cdm.api.service.ITermNodeService;
71 72
import eu.etaxonomy.cdm.api.service.ITermService;
73
import eu.etaxonomy.cdm.api.service.ITermTreeService;
72 74
import eu.etaxonomy.cdm.api.service.ITestService;
73 75
import eu.etaxonomy.cdm.api.service.IUserService;
74 76
import eu.etaxonomy.cdm.api.service.IVocabularyService;
75
import eu.etaxonomy.cdm.api.service.IDescriptiveDataSetService;
76 77
import eu.etaxonomy.cdm.api.service.molecular.IAmplificationService;
77 78
import eu.etaxonomy.cdm.api.service.molecular.IPrimerService;
78 79
import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;
79 80
import eu.etaxonomy.cdm.ext.geo.IEditGeoService;
80 81
import eu.etaxonomy.cdm.io.service.IIOService;
81
import eu.etaxonomy.cdm.model.common.CdmBase;
82 82
import eu.etaxonomy.cdm.persistence.hibernate.permission.CdmPermissionEvaluator;
83 83
import eu.etaxonomy.cdm.persistence.hibernate.permission.ICdmPermissionEvaluator;
84 84
import eu.etaxonomy.cdm.persistence.hibernate.permission.UnanimousBasedUnrevokable;
......
375 375
    public IFeatureTreeService getFeatureTreeService(){
376 376
        return (IFeatureTreeService) getService(IFeatureTreeService.class, "/remoting/featuretree.service", new CdmServiceRequestExecutor());
377 377
    }
378
    @Override
379
    public ITermTreeService getTermTreeService() {
380
    	return (ITermTreeService) getService(ITermTreeService.class, "/remoting/termtree.service", new CdmServiceRequestExecutor());
381
    }
378 382

  
379 383
    @Override
380 384
    public IFeatureNodeService getFeatureNodeService(){
381 385
        return (IFeatureNodeService) getService(IFeatureNodeService.class, "/remoting/featurenode.service", new CdmServiceRequestExecutor());
382 386
    }
387
    
388
	@Override
389
	public ITermNodeService getTermNodeService() {
390
        return (ITermNodeService) getService(ITermNodeService.class, "/remoting/termnode.service", new CdmServiceRequestExecutor());
391
	}
383 392

  
384 393
    @Override
385 394
    public IVocabularyService getVocabularyService(){
......
499 508
    public ITestService getTestService() {
500 509
        return (ITestService) getService(ITestService.class, "/remoting/test.service", new CdmServiceRequestExecutor());
501 510
    }
511

  
512

  
502 513
}
eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/DescriptiveDataSetComposite.java
22 22
import org.eclipse.swt.widgets.Text;
23 23
import org.eclipse.swt.widgets.Tree;
24 24

  
25
import eu.etaxonomy.cdm.model.term.TermType;
26 25
import eu.etaxonomy.cdm.model.description.Character;
27
import eu.etaxonomy.cdm.model.term.FeatureTree;
28 26
import eu.etaxonomy.cdm.model.name.Rank;
27
import eu.etaxonomy.cdm.model.term.TermTree;
28
import eu.etaxonomy.cdm.model.term.TermType;
29 29
import eu.etaxonomy.cdm.persistence.dto.TermDto;
30 30
import eu.etaxonomy.cdm.remote.l10n.TermRepresentation_L10n;
31 31
import eu.etaxonomy.taxeditor.editor.l10n.Messages;
......
165 165
        return featureTreeEditorComposite;
166 166
    }
167 167

  
168
    public FeatureTree<Character> getCharacters(){
168
    public TermTree<Character> getCharacters(){
169 169
        return featureTreeEditorComposite.getFeatureTree();
170 170
    }
171
    public void setCharacters(FeatureTree<Character> characters) {
171
    public void setCharacters(TermTree<Character> characters) {
172 172
        featureTreeEditorComposite.setSelectedTree(characters);
173 173
    }
174 174

  
eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/DescriptiveDataSetEditor.java
64 64
import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
65 65
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
66 66
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
67
import eu.etaxonomy.cdm.model.term.FeatureTree;
67
import eu.etaxonomy.cdm.model.term.TermTree;
68 68
import eu.etaxonomy.cdm.model.term.TermType;
69 69
import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;
70 70
import eu.etaxonomy.cdm.persistence.dto.TermDto;
......
289 289
                }
290 290
            }
291 291
        }
292
        FeatureTree<Character> characters = composite.getCharacters();
292
        TermTree<Character> characters = composite.getCharacters();
293 293
        if(characters!=null){
294 294
            //save characters because they can be modified in this editor
295
            characters.getDistinctFeatures().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
295
            characters.getDistinctTerms().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
296 296
        }
297 297

  
298 298

  
eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/character/CharacterDragListener.java
22 22
import org.eclipse.swt.widgets.Display;
23 23

  
24 24
import eu.etaxonomy.cdm.model.description.Character;
25
import eu.etaxonomy.cdm.model.term.FeatureNode;
25
import eu.etaxonomy.cdm.model.term.TermNode;
26 26
import eu.etaxonomy.taxeditor.featuretree.CharacterTransfer;
27 27
import eu.etaxonomy.taxeditor.featuretree.e4.FeatureNodeDragListener;
28 28

  
......
72 72
                !structureViewer.getSelection().isEmpty()
73 73
                && !propertyViewer.getSelection().isEmpty()
74 74
                && ((IStructuredSelection) structureViewer.getSelection()).toList()
75
                .stream().allMatch(element -> element instanceof FeatureNode)
75
                .stream().allMatch(element -> element instanceof TermNode)
76 76
                && ((IStructuredSelection) propertyViewer.getSelection()).toList()
77
                .stream().allMatch(element -> element instanceof FeatureNode);
77
                .stream().allMatch(element -> element instanceof TermNode);
78 78
        if(!event.doit){
79 79
            return;
80 80
        }
eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/character/CharacterDropAdapter.java
15 15

  
16 16
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
17 17
import eu.etaxonomy.cdm.model.description.Character;
18
import eu.etaxonomy.cdm.model.term.FeatureNode;
19
import eu.etaxonomy.cdm.model.term.FeatureTree;
18
import eu.etaxonomy.cdm.model.description.Feature;
19
import eu.etaxonomy.cdm.model.term.TermNode;
20
import eu.etaxonomy.cdm.model.term.TermTree;
20 21
import eu.etaxonomy.taxeditor.featuretree.CharacterTransfer;
21 22
import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeDropAdapter;
22 23
import eu.etaxonomy.taxeditor.store.CdmStore;
......
39 40

  
40 41
	@Override
41 42
	protected Object determineTarget(DropTargetEvent event) {
42
        return event.item == null ? ((FeatureTree)getViewer().getInput()).getRoot() : event.item.getData();
43
        return event.item == null ? ((TermTree<Feature>)getViewer().getInput()).getRoot() : event.item.getData();
43 44
	}
44 45

  
45 46
	@Override
......
53 54
	    if(!characterEditor.isVocabularySet()){
54 55
	        return false;
55 56
	    }
56
	    FeatureNode target = (FeatureNode) getCurrentTarget();
57
	    TermNode<Feature> target = (TermNode<Feature>) getCurrentTarget();
57 58
	    if(data instanceof Object[]){
58 59
	        Object[] transferObjects = (Object[])data;
59 60
	        for(int i=0;i<transferObjects.length;i++){
......
62 63
	                Character character = (Character)object;
63 64
	                if(target==null){
64 65
                        //drop on feature tree
65
                        target = ((FeatureTree)getViewer().getInput()).getRoot();
66
                        target = ((TermTree<Feature>)getViewer().getInput()).getRoot();
66 67
                    }
67 68
                    CdmStore.getService(IFeatureNodeService.class).createChildFeatureNode(target.getUuid(), character, characterEditor.getVocabulary().getUuid());
68 69
	            }
eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/character/CharacterEditor.java
59 59
import eu.etaxonomy.cdm.api.service.ITermService;
60 60
import eu.etaxonomy.cdm.api.service.IVocabularyService;
61 61
import eu.etaxonomy.cdm.model.description.Character;
62
import eu.etaxonomy.cdm.model.description.Feature;
62 63
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
63
import eu.etaxonomy.cdm.model.term.FeatureNode;
64
import eu.etaxonomy.cdm.model.term.FeatureTree;
65 64
import eu.etaxonomy.cdm.model.term.Representation;
65
import eu.etaxonomy.cdm.model.term.TermNode;
66
import eu.etaxonomy.cdm.model.term.TermTree;
66 67
import eu.etaxonomy.cdm.model.term.TermType;
67 68
import eu.etaxonomy.cdm.model.term.TermVocabulary;
68 69
import eu.etaxonomy.cdm.model.term.VocabularyEnum;
......
226 227
                    return;
227 228
                }
228 229
                Collection<Character> characters = createCharacters((TreeSelection)structureTreeSelection, (TreeSelection)propertyTreeSelection);
229
                FeatureNode<Character> parent = ((FeatureTree<Character>) characterTreeEditorComposite.getViewer().getInput()).getRoot();
230
                TermNode<Character> parent = ((TermTree<Character>) characterTreeEditorComposite.getViewer().getInput()).getRoot();
230 231
                for (Character character : characters) {
231 232
                    //add new Character to feature tree
232 233
                    CdmStore.getService(IFeatureNodeService.class).createChildFeatureNode(parent.getUuid(), character, vocabulary.getUuid());
......
291 292
    public static Collection<Character> createCharacters(TreeSelection structureTreeSelection, TreeSelection propertyTreeSelection){
292 293
        Set<Character> characters = new HashSet<>();
293 294
        //get selected structures and properties
294
        Iterator<FeatureNode<DefinedTermBase>> structureIterator = structureTreeSelection.iterator();
295
        Iterator<TermNode<DefinedTermBase>> structureIterator = structureTreeSelection.iterator();
295 296

  
296 297
        //create all combinations of structures and properties
297 298
        while(structureIterator.hasNext()){
298
            FeatureNode<DefinedTermBase> structureNode = structureIterator.next();
299
            Iterator<FeatureNode<DefinedTermBase>> propertiesIterator = propertyTreeSelection.iterator();
299
            TermNode<DefinedTermBase> structureNode = structureIterator.next();
300
            Iterator<TermNode<DefinedTermBase>> propertiesIterator = propertyTreeSelection.iterator();
300 301
            while(propertiesIterator.hasNext()){
301
                FeatureNode<DefinedTermBase> propertyNode = propertiesIterator.next();
302
                TermNode<DefinedTermBase> propertyNode = propertiesIterator.next();
302 303
                Representation structureRepresentation = structureNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());
303 304
                Representation propertyRepresentation = propertyNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());
304 305
                String label = null;
......
327 328
        // commit the conversation and start a new transaction immediately
328 329
        conversation.commit(true);
329 330

  
330
        FeatureTree<Character> featureTree = characterTreeEditorComposite.getFeatureTree();
331
        TermTree<Character> featureTree = characterTreeEditorComposite.getFeatureTree();
331 332
        if(featureTree!=null){
332 333
            //save characters because they can be modified in this editor
333
            featureTree.getDistinctFeatures().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
334
            featureTree.getDistinctTerms().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
334 335
        }
335 336
        CdmStore.getService(IFeatureTreeService.class).saveOrUpdate(featureTree);
336 337

  
......
376 377
        });
377 378
        Map<Object, List<String>> propertyPathMap =
378 379
                new HashMap<Object, List<String>>();
379
        propertyPathMap.put(FeatureNode.class,propertyPaths);
380
        propertyPathMap.put(TermNode.class,propertyPaths);
380 381
        return propertyPathMap;
381 382
    }
382 383

  
383 384
    @Override
384
    public List<FeatureTree<Character>> getRootEntities() {
385
        List<FeatureTree<Character>> root = new ArrayList<>();
385
    public List<TermTree<Character>> getRootEntities() {
386
        List<TermTree<Character>> root = new ArrayList<>();
386 387
        root.add(characterTreeEditorComposite.getFeatureTree());
387 388
        return root;
388 389
    }
......
422 423
        return (IStructuredSelection) characterTreeEditorComposite.getViewer().getSelection();
423 424
    }
424 425

  
425
    public FeatureTree<Character> getCharacterTree(){
426
    public TermTree<Character> getCharacterTree(){
426 427
        return characterTreeEditorComposite.getFeatureTree();
427 428
    }
428 429

  
......
434 435
    }
435 436

  
436 437
    private class FeatureTreeChooserListener extends SelectionAdapter{
437
        private FeatureTreeEditorComposite<?> featureTreeEditorComposite;
438
        private FeatureTreeEditorComposite<Feature> featureTreeEditorComposite;
438 439
        private TermType termType;
439 440

  
440
        public FeatureTreeChooserListener(FeatureTreeEditorComposite<?> featureTreeEditorComposite, TermType termType) {
441
        public FeatureTreeChooserListener(FeatureTreeEditorComposite<Feature> featureTreeEditorComposite, TermType termType) {
441 442
            super();
442 443
            this.featureTreeEditorComposite = featureTreeEditorComposite;
443 444
            this.termType = termType;
......
445 446

  
446 447
        @Override
447 448
        public void widgetSelected(SelectionEvent e) {
448
            FeatureTree tree = FeatureTreeSelectionDialog.select(featureTreeEditorComposite.getDisplay().getActiveShell(), null, termType);
449
            TermTree<Feature> tree = FeatureTreeSelectionDialog.select(featureTreeEditorComposite.getDisplay().getActiveShell(), null, termType);
449 450
            if(tree!=null){
450 451
                featureTreeEditorComposite.setSelectedTree(tree);
451 452
            }
......
475 476
    @Override
476 477
    public boolean postOperation(Object objectAffectedByOperation) {
477 478
        characterTreeEditorComposite.getViewer().refresh();
478
        if(objectAffectedByOperation instanceof FeatureNode){
479
        if(objectAffectedByOperation instanceof TermNode){
479 480
            StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);
480 481
            characterTreeEditorComposite.getViewer().setSelection(selection);
481 482
        }
eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/matrix/CharacterMatrix.java
105 105
import eu.etaxonomy.cdm.model.description.Feature;
106 106
import eu.etaxonomy.cdm.model.description.MeasurementUnit;
107 107
import eu.etaxonomy.cdm.model.description.State;
108
import eu.etaxonomy.cdm.model.term.FeatureNode;
109
import eu.etaxonomy.cdm.model.term.FeatureTree;
108
import eu.etaxonomy.cdm.model.term.TermNode;
109
import eu.etaxonomy.cdm.model.term.TermTree;
110 110
import eu.etaxonomy.cdm.model.term.TermVocabulary;
111 111
import eu.etaxonomy.cdm.persistence.dto.SpecimenNodeWrapper;
112 112
import eu.etaxonomy.cdm.persistence.dto.TermDto;
......
277 277
        getNatTableState().remove(PersistenceDialog.ACTIVE_VIEW_CONFIGURATION_KEY);
278 278
    }
279 279

  
280
    private List<Character> initCharacterList(FeatureNode<Character> node){
280
    private List<Character> initCharacterList(TermNode<Character> node){
281 281
        List<Character> characters = new ArrayList<>();
282 282
        node.getChildNodes().forEach(childNode->
283 283
                {
......
290 290
    public void initDescriptiveDataSet(DescriptiveDataSet descriptiveDataSet){
291 291
        this.descriptiveDataSet = descriptiveDataSet;
292 292
        //get features/columns stored in descriptive data set
293
        FeatureTree<Character> tree = descriptiveDataSet.getDescriptiveSystem();
293
        TermTree<Character> tree = descriptiveDataSet.getDescriptiveSystem();
294 294
        characters = initCharacterList(tree.getRoot());
295 295

  
296 296
        //init state data for categorical features
eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/descriptive/DescriptiveContentProvider.java
17 17
import eu.etaxonomy.cdm.model.common.Marker;
18 18
import eu.etaxonomy.cdm.model.description.DescriptionBase;
19 19
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
20
import eu.etaxonomy.cdm.model.description.Feature;
20 21
import eu.etaxonomy.cdm.model.description.IDescribable;
21 22
import eu.etaxonomy.cdm.model.description.IndividualsAssociation;
22 23
import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
23
import eu.etaxonomy.cdm.model.term.FeatureTree;
24
import eu.etaxonomy.cdm.model.term.TermTree;
24 25
import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput;
25 26
import eu.etaxonomy.taxeditor.model.FeatureNodeContainer;
26 27
import eu.etaxonomy.taxeditor.model.FeatureNodeContainerTree;
......
181 182
	 * @param description
182 183
	 * @return
183 184
	 */
184
	private FeatureTree getFeatureTree(DescriptionBase description){
185
	private TermTree<Feature> getFeatureTree(DescriptionBase description){
185 186

  
186
	        FeatureTree<?> featureTree = null;
187
	        TermTree<Feature> featureTree = null;
187 188

  
188 189
	        // TODO change this to the feature tree associated with this taxon
189 190
	        // description
eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/descriptive/e4/handler/DynamicFeatureMenuE4.java
31 31
import eu.etaxonomy.cdm.model.description.Feature;
32 32
import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
33 33
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
34
import eu.etaxonomy.cdm.model.term.FeatureNode;
35
import eu.etaxonomy.cdm.model.term.FeatureTree;
34
import eu.etaxonomy.cdm.model.term.TermNode;
35
import eu.etaxonomy.cdm.model.term.TermTree;
36 36
import eu.etaxonomy.cdm.model.term.VocabularyEnum;
37 37
import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput;
38 38
import eu.etaxonomy.taxeditor.editor.l10n.Messages;
......
61 61
        Object selectedElement = selection.getFirstElement();
62 62

  
63 63
        if (selectedElement instanceof DescriptionBase<?>) {
64
            FeatureTree<?> featureTree = getFeatureTree((DescriptionBase<?>) selectedElement);
64
            TermTree<?> featureTree = getFeatureTree((DescriptionBase<?>) selectedElement);
65 65

  
66
            for (FeatureNode<?> childNode : featureTree.getRootChildren()) {
66
            for (TermNode<?> childNode : featureTree.getRootChildren()) {
67 67
                createMenuItem(menu, childNode.getTerm(), globalLanguage);
68 68
            }
69 69
        } else if (selectedElement instanceof FeatureNodeContainer) {
70
            FeatureNode<?> featureNode = ((FeatureNodeContainer) selectedElement)
70
            TermNode<?> featureNode = ((FeatureNodeContainer) selectedElement)
71 71
                    .getFeatureNode();
72 72

  
73 73
            // add the feature to the menu
74 74
            createMenuItem(menu, featureNode.getTerm(), globalLanguage);
75 75

  
76 76
            // add possible children to the menu
77
            for (FeatureNode<?> childNode : featureNode.getChildNodes()) {
77
            for (TermNode<?> childNode : featureNode.getChildNodes()) {
78 78
                createMenuItem(menu, childNode.getTerm(), globalLanguage);
79 79
            }
80 80
        } else if (selectedElement instanceof DescriptionElementBase) {
......
123 123
	 * @param description
124 124
	 * @return
125 125
	 */
126
	private FeatureTree<?> getFeatureTree(DescriptionBase description) {
127
		FeatureTree<?> featureTree = null;
126
	private TermTree<?> getFeatureTree(DescriptionBase description) {
127
		TermTree<?> featureTree = null;
128 128

  
129 129
		// TODO change this to the feature tree associated with this taxon
130 130
		// description
......
138 138

  
139 139
		if (featureTree == null) {
140 140
		    featureTree = TermEditorInput.getDefaultFeatureTree();
141
		    		}
141
		}
142 142
		if (description instanceof TaxonNameDescription){
143 143
		    List<Feature> terms = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()));
144 144
		    terms.remove(Feature.PROTOLOGUE());
145
		    featureTree = FeatureTree.NewInstance(terms);
145
		    featureTree = TermTree.NewInstance(terms);
146 146
		}
147 147

  
148 148
		return featureTree;
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/databaseAdmin/wizard/DatabaseRepairUpdateSortIndicesWizard.java
25 25
/**
26 26
 * @author k.luther
27 27
 * @date 06.12.2016
28
 *
29 28
 */
30 29
public class DatabaseRepairUpdateSortIndicesWizard extends Wizard implements IPostMoniteredOperationEnabled{
31 30
   // private final DatabaseRepairSortIndexPage repairSortIndexPage;
......
51 50
            if (config == null){
52 51
                ICdmSource source= CdmStore.getActiveCdmSource();
53 52
                config = SortIndexUpdaterConfigurator.NewInstance();
54
                config.setDoFeatureNode(false);
53
                config.setDoTermNode(false);
55 54
                config.setDoPolytomousKeyNode(false);
56

  
57

  
58 55
             }
59
            if (config.isDoFeatureNode() || config.isDoPolytomousKeyNode() || config.isDoTaxonNode()){
56
            if (config.isDoTermNode() || config.isDoPolytomousKeyNode() || config.isDoTaxonNode()){
60 57

  
61 58
                final UUID uuid = longRunningTaskService.monitLongRunningTask(config);
62 59
                Display.getDefault().asyncExec(new Runnable() {
......
69 66
                                DatabaseRepairUpdateSortIndicesWizard.this,
70 67
                                null,
71 68
                                true);
72

  
73 69
                    }
74

  
75 70
                });
76

  
77

  
78 71
            }
79 72

  
80

  
81 73
        return true;
82 74
    }
83 75

  
......
92 84
    @Override
93 85
    public void postOperation(IRemotingProgressMonitor monitor) {
94 86
        // TODO Auto-generated method stub
95

  
96 87
    }
97

  
98

  
99 88
}
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/databaseAdmin/wizard/SortIndexUpdaterWizardPage.java
68 68
        });
69 69

  
70 70
        Button checkBoxFeatureNode = new Button(composite, SWT.CHECK);
71
        checkBoxFeatureNode.setSelection(sortIndexConfig.isDoFeatureNode());
71
        checkBoxFeatureNode.setSelection(sortIndexConfig.isDoTermNode());
72 72
        checkBoxFeatureNode.setText(Messages.DatabaseRepairPage_featureNodes);
73 73
        checkBoxFeatureNode
74 74
        .setToolTipText(Messages.DatabaseRepairPage_toolTipFeatureNodes);
75 75
        checkBoxFeatureNode.addSelectionListener(new SelectionAdapter() {
76 76
            @Override
77 77
            public void widgetSelected(SelectionEvent e) {
78
                sortIndexConfig.setDoFeatureNode(!sortIndexConfig.isDoFeatureNode());
78
                sortIndexConfig.setDoTermNode(!sortIndexConfig.isDoTermNode());
79 79
            }
80 80
        });
81 81

  
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/editor/definedterm/FeatureTreeViewerComparator.java
12 12
import org.eclipse.jface.viewers.Viewer;
13 13
import org.eclipse.jface.viewers.ViewerComparator;
14 14

  
15
import eu.etaxonomy.cdm.model.term.FeatureTree;
15
import eu.etaxonomy.cdm.model.term.TermTree;
16 16

  
17 17
/**
18 18
 *
19 19
 * @author pplitzner
20 20
 * @since May 24, 2019
21
 *
22 21
 */
23 22
public class FeatureTreeViewerComparator extends ViewerComparator {
24 23

  
25 24
    @Override
26 25
    public int compare(Viewer viewer, Object e1, Object e2) {
27
        if(e1 instanceof FeatureTree && e2 instanceof FeatureTree) {
28
            return ((FeatureTree)e1).getTitleCache().toLowerCase().compareTo(((FeatureTree) e2).getTitleCache().toLowerCase());
26
        if(e1 instanceof TermTree && e2 instanceof TermTree) {
27
            return ((TermTree<?>)e1).getTitleCache().toLowerCase().compareTo(((TermTree<?>) e2).getTitleCache().toLowerCase());
29 28
        }
30 29
        return super.compare(viewer, e1, e2);
31 30
    }
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/editor/definedterm/input/TermEditorInput.java
17 17
import eu.etaxonomy.cdm.api.service.IVocabularyService;
18 18
import eu.etaxonomy.cdm.model.description.Feature;
19 19
import eu.etaxonomy.cdm.model.term.DefinedTerm;
20
import eu.etaxonomy.cdm.model.term.FeatureTree;
20
import eu.etaxonomy.cdm.model.term.TermTree;
21 21
import eu.etaxonomy.cdm.model.term.TermType;
22 22
import eu.etaxonomy.cdm.model.term.TermVocabulary;
23 23
import eu.etaxonomy.cdm.model.term.VocabularyEnum;
......
39 39

  
40 40
	// FIXME: the default feature should be move to CdmApplicationState
41 41
	//        where it is a singleton instance variable
42
	private static FeatureTree defaultFeatureTree = null;
43
	private static FeatureTree defaultNameFeatureTree = null;
42
	private static TermTree<Feature> defaultFeatureTree = null;
43
	private static TermTree<Feature> defaultNameFeatureTree = null;
44 44

  
45 45
	private List<String> termClasses = Arrays.asList(new String[]{
46 46
			DefinedTerm.class.getName()
......
98 98
        updateDefaultFeatureTree();
99 99
    }
100 100

  
101
    public static FeatureTree getDefaultFeatureTree() {
101
    public static TermTree<Feature> getDefaultFeatureTree() {
102 102
        if(defaultFeatureTree == null) {
103 103
            List<Feature> features = TermStore.getTerms(Feature.class);
104 104
            List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null);
......
108 108
                    features.remove(feature);
109 109
                }
110 110
            }
111
            defaultFeatureTree = FeatureTree.NewInstance(features);
111
            defaultFeatureTree = TermTree.NewInstance(features);
112 112
        }
113 113
        return defaultFeatureTree;
114 114
    }
115 115

  
116
    public static FeatureTree getDefaultNameFeatureTree() {
116
    public static TermTree<Feature> getDefaultNameFeatureTree() {
117 117
        if(defaultNameFeatureTree == null) {
118 118
            List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null);
119
            defaultNameFeatureTree = FeatureTree.NewInstance(nameFeatures);
119
            defaultNameFeatureTree = TermTree.NewInstance(nameFeatures);
120 120
        }
121 121
        return defaultNameFeatureTree;
122 122
    }
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/CharacterTransfer.java
23 23
import org.eclipse.swt.dnd.TransferData;
24 24

  
25 25
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
26
import eu.etaxonomy.cdm.model.term.Representation;
27 26
import eu.etaxonomy.cdm.model.description.Character;
28
import eu.etaxonomy.cdm.model.term.FeatureNode;
27
import eu.etaxonomy.cdm.model.term.DefinedTerm;
28
import eu.etaxonomy.cdm.model.term.Representation;
29
import eu.etaxonomy.cdm.model.term.TermNode;
29 30
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
30 31
import eu.etaxonomy.taxeditor.store.CdmStore;
31 32

  
......
100 101
                        String string = in.readUTF();
101 102
                        String[] split = string.split(",");
102 103
                        IFeatureNodeService featureNodeService = CdmStore.getService(IFeatureNodeService.class);
103
                        FeatureNode structure = featureNodeService.load(UUID.fromString(split[0]));
104
                        FeatureNode property = featureNodeService.load(UUID.fromString(split[1]));
104
                        TermNode<DefinedTerm> structure = featureNodeService.load(UUID.fromString(split[0]));
105
                        TermNode<DefinedTerm> property = featureNodeService.load(UUID.fromString(split[1]));
105 106
                        Representation structureRepresentation = structure.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());
106 107
                        Representation propertyRepresentation = property.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());
107 108
                        String label = null;
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/FeatureNodeTransfer.java
12 12
import java.util.UUID;
13 13

  
14 14
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
15
import eu.etaxonomy.cdm.model.term.FeatureNode;
15
import eu.etaxonomy.cdm.model.description.Feature;
16
import eu.etaxonomy.cdm.model.term.TermNode;
16 17
import eu.etaxonomy.taxeditor.model.CdmObjectTransfer;
17 18
import eu.etaxonomy.taxeditor.store.CdmStore;
18 19

  
......
21 22
 *
22 23
 * @author n.hoffmann
23 24
 * @created Aug 5, 2010
24
 * @version 1.0
25 25
 */
26
public class FeatureNodeTransfer extends CdmObjectTransfer<FeatureNode> {
26
public class FeatureNodeTransfer extends CdmObjectTransfer<TermNode<Feature>> {
27 27

  
28 28
	private static FeatureNodeTransfer instance = new FeatureNodeTransfer();
29 29
	private static final String TYPE_NAME = "featureNode-transfer-format";
......
53 53
		return new String[] { TYPE_NAME };
54 54
	}
55 55

  
56
	/* (non-Javadoc)
57
	 * @see eu.etaxonomy.taxeditor.model.CdmObjectTransfer#loadElement(java.util.UUID)
58
	 */
59 56
	@Override
60
	public FeatureNode loadElement(UUID uuid) {
57
	public TermNode<Feature> loadElement(UUID uuid) {
61 58
		return  CdmStore.getService(IFeatureNodeService.class).load(uuid);
62 59
	}
63 60
}
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/FeatureTreeContentProvider.java
14 14
import org.eclipse.jface.viewers.ITreeContentProvider;
15 15
import org.eclipse.jface.viewers.Viewer;
16 16

  
17
import eu.etaxonomy.cdm.model.term.FeatureNode;
18
import eu.etaxonomy.cdm.model.term.FeatureTree;
17
import eu.etaxonomy.cdm.model.description.Feature;
18
import eu.etaxonomy.cdm.model.term.TermNode;
19
import eu.etaxonomy.cdm.model.term.TermTree;
19 20

  
20 21
/**
21 22
 * <p>FeatureTreeContentProvider class.</p>
......
44 45

  
45 46
	}
46 47

  
47
	/* (non-Javadoc)
48
	 * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
49
	 */
50 48
	/** {@inheritDoc} */
51 49
	@Override
52 50
	public Object[] getElements(Object inputElement) {
......
56 54
	/** {@inheritDoc} */
57 55
	@Override
58 56
	public Object[] getChildren(Object parentElement) {
59
		if(parentElement instanceof FeatureTree){
60
			List<FeatureNode> children = ((FeatureTree) parentElement).getRootChildren();
57
		if(parentElement instanceof TermTree){
58
			List<TermNode<Feature>> children = ((TermTree<Feature>) parentElement).getRootChildren();
61 59
			return children.toArray();
62
		}else if(parentElement instanceof FeatureNode){
63
			List<FeatureNode> children = ((FeatureNode) parentElement).getChildNodes();
60
		}else if(parentElement instanceof TermNode){
61
			List<TermNode<Feature>> children = ((TermNode<Feature>) parentElement).getChildNodes();
64 62
			return children.toArray();
65 63
		}else if(parentElement instanceof List){
66
			return ((List) parentElement).toArray();
64
			return ((List<TermNode<Feature>>) parentElement).toArray();
67 65
		}else{
68 66
			return new Object[]{};
69 67
		}
......
72 70
	/** {@inheritDoc} */
73 71
	@Override
74 72
	public Object getParent(Object element) {
75
	    if(element instanceof FeatureNode){
76
	        return ((FeatureNode) element).getParent();
73
	    if(element instanceof TermNode){
74
	        return ((TermNode<Feature>) element).getParent();
77 75
	    }
78 76
		return null;
79 77
	}
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/FeatureTreeLabelProvider.java
13 13

  
14 14
import org.eclipse.jface.viewers.LabelProvider;
15 15

  
16
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
17 16
import eu.etaxonomy.cdm.model.common.Language;
17
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
18 18
import eu.etaxonomy.cdm.model.term.Representation;
19
import eu.etaxonomy.cdm.model.term.FeatureNode;
20
import eu.etaxonomy.cdm.model.term.FeatureTree;
19
import eu.etaxonomy.cdm.model.term.TermNode;
20
import eu.etaxonomy.cdm.model.term.TermTree;
21 21
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
22 22

  
23 23
/**
......
31 31
	/** {@inheritDoc} */
32 32
	@Override
33 33
	public String getText(Object element) {
34
		if(element instanceof FeatureTree){
35
			return ((FeatureTree) element).getTitleCache();
36
		}else if(element instanceof FeatureNode){
37
		    DefinedTermBase term = ((FeatureNode) element).getTerm();
34
		if(element instanceof TermTree){
35
			return ((TermTree) element).getTitleCache();
36
		}else if(element instanceof TermNode){
37
		    DefinedTermBase term = ((TermNode) element).getTerm();
38 38
		    if(term!=null){
39 39
		        Representation rep = term.getRepresentation(PreferencesUtil.getGlobalLanguage());
40 40
		        if (rep == null){
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/FeatureTreePropertyTester.java
6 6
import org.eclipse.core.expressions.PropertyTester;
7 7
import org.eclipse.jface.viewers.IStructuredSelection;
8 8

  
9
import eu.etaxonomy.cdm.model.term.FeatureTree;
9
import eu.etaxonomy.cdm.model.term.TermTree;
10 10

  
11 11
/**
12 12
 * Property tester used by the feature tree menu.
......
40 40

  
41 41
	private boolean isFeatureTree(Object[] selectedElements) {
42 42
	    for (Object object : selectedElements){
43
	        if(!(object instanceof FeatureTree)){
43
	        if(!(object instanceof TermTree)){
44 44
	            return false;
45 45
	        }
46 46
	    }
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/FeatureNodeDragListener.java
13 13
import org.eclipse.swt.dnd.DragSourceAdapter;
14 14
import org.eclipse.swt.dnd.DragSourceEvent;
15 15

  
16
import eu.etaxonomy.cdm.model.term.FeatureNode;
16
import eu.etaxonomy.cdm.model.description.Feature;
17
import eu.etaxonomy.cdm.model.term.TermNode;
17 18
import eu.etaxonomy.taxeditor.featuretree.FeatureNodeTransfer;
18 19

  
19 20
public class FeatureNodeDragListener extends DragSourceAdapter {
......
31 32
    public void dragSetData(DragSourceEvent event) {
32 33
        IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
33 34
        if(selection!=null && !selection.isEmpty()){
34
            FeatureNode[] featureNodes = (FeatureNode[]) selection.toList().toArray(new FeatureNode[selection.size()]);
35
            TermNode<Feature>[] featureNodes = (TermNode<Feature>[]) selection.toList().toArray(new TermNode[selection.size()]);
35 36
            if (FeatureNodeTransfer.getInstance().isSupportedType(event.dataType)) {
36 37
                event.data = featureNodes;
37 38
            }
......
45 46
	public void dragStart(DragSourceEvent event) {
46 47
        event.doit = !viewer.getSelection().isEmpty()
47 48
                && ((IStructuredSelection) viewer.getSelection()).toList()
48
                .stream().allMatch(element -> element instanceof FeatureNode);
49
                .stream().allMatch(element -> element instanceof TermNode);
49 50
	}
50 51

  
51 52
}
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/FeatureTreeDropAdapter.java
21 21
import org.eclipse.swt.dnd.TransferData;
22 22

  
23 23
import eu.etaxonomy.cdm.model.description.Feature;
24
import eu.etaxonomy.cdm.model.term.FeatureNode;
25
import eu.etaxonomy.cdm.model.term.FeatureTree;
26 24
import eu.etaxonomy.cdm.model.term.IHasTermType;
27 25
import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;
26
import eu.etaxonomy.cdm.model.term.TermNode;
27
import eu.etaxonomy.cdm.model.term.TermTree;
28 28
import eu.etaxonomy.cdm.model.term.TermType;
29 29
import eu.etaxonomy.cdm.model.term.TermVocabulary;
30 30
import eu.etaxonomy.cdm.persistence.dto.TermDto;
......
58 58
	        return false;
59 59
	    }
60 60
		Object currentTarget = getCurrentTarget();
61
		FeatureNode target = null;
62
		if(currentTarget instanceof FeatureTree){
63
		    target = ((FeatureTree) currentTarget).getRoot();
61
		TermNode<Feature> target = null;
62
		if(currentTarget instanceof TermTree){
63
		    target = ((TermTree) currentTarget).getRoot();
64 64
		}
65
		else if(currentTarget instanceof FeatureNode){
66
		    target = (FeatureNode) currentTarget;
65
		else if(currentTarget instanceof TermNode){
66
		    target = (TermNode) currentTarget;
67 67
		}
68 68
		int position = 0;
69 69

  
70 70
		if (target != null) {
71 71
			int location = getCurrentLocation();
72
			FeatureNode parent = target.getParent();
72
			TermNode<Feature> parent = target.getParent();
73 73
			if(parent!=null){
74 74
			    if (location == LOCATION_BEFORE) {
75 75
			        position = Math.max(0, parent.getIndex(target));
......
125 125
                    continue;
126 126
                }
127 127
		    }
128
		    if(droppedObject instanceof FeatureNode){
129
		        FeatureNode droppedNode = (FeatureNode) droppedObject;
128
		    if(droppedObject instanceof TermNode){
129
		    	TermNode<Feature> droppedNode = (TermNode<Feature>) droppedObject;
130 130
		        int currentPosition = target.getIndex(droppedNode);
131 131
		        if(currentPosition<position){
132 132
		            position -= 1;
......
185 185
        isSupported |= TermTransfer.getInstance().isSupportedType(transferData);
186 186
        isSupported |= LocalSelectionTransfer.getTransfer().isSupportedType(transferData);
187 187
        isSupported &= getViewer().getInput()!=null;
188
        if(target instanceof FeatureTree && getCurrentLocation()!=ViewerDropAdapter.LOCATION_ON){
188
        if(target instanceof TermTree && getCurrentLocation()!=ViewerDropAdapter.LOCATION_ON){
189 189
            isSupported = false;
190 190
        }
191 191
        return isSupported;
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/FeatureTreeEditor.java
48 48
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
49 49
import eu.etaxonomy.cdm.api.service.ITermService;
50 50
import eu.etaxonomy.cdm.model.description.Character;
51
import eu.etaxonomy.cdm.model.term.FeatureNode;
52
import eu.etaxonomy.cdm.model.term.FeatureTree;
51
import eu.etaxonomy.cdm.model.description.Feature;
52
import eu.etaxonomy.cdm.model.term.TermNode;
53
import eu.etaxonomy.cdm.model.term.TermTree;
53 54
import eu.etaxonomy.cdm.model.term.TermType;
54 55
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
55 56
import eu.etaxonomy.taxeditor.editor.definedterm.FeatureTreeViewerComparator;
......
135 136
            }
136 137
        });
137 138

  
138
        List<FeatureTree> trees = CdmStore.getService(IFeatureTreeService.class).list(FeatureTree.class, null, null, null, null);
139
        List<TermTree> trees = CdmStore.getService(IFeatureTreeService.class).list(TermTree.class, null, null, null, null);
139 140
        viewer.setComparator(new FeatureTreeViewerComparator());
140 141
        viewer.setInput(trees);
141 142

  
......
150 151

  
151 152
        ISelection clipBoardSelection = LocalSelectionTransfer.getTransfer().getSelection();
152 153
        Object firstElement = selection.getFirstElement();
153
        FeatureNode parentNode = null;
154
        if(firstElement instanceof FeatureNode){
155
            parentNode = (FeatureNode) firstElement;
154
        TermNode<Feature> parentNode = null;
155
        if(firstElement instanceof TermNode){
156
            parentNode = (TermNode<Feature>) firstElement;
156 157
        }
157
        else if(firstElement instanceof FeatureTree){
158
            parentNode = ((FeatureTree)firstElement).getRoot();
158
        else if(firstElement instanceof TermTree){
159
            parentNode = ((TermTree<Feature>)firstElement).getRoot();
159 160
        }
160 161
        if(parentNode!=null){
161
            FeatureNode copiedNode = (FeatureNode) ((IStructuredSelection)clipBoardSelection).getFirstElement();
162
        	TermNode<Feature> copiedNode = (TermNode<Feature>) ((IStructuredSelection)clipBoardSelection).getFirstElement();
162 163

  
163 164
            AddFeatureOperation operation = new AddFeatureOperation(copiedNode.getTerm().getUuid(), parentNode, this, this);
164 165
            AbstractUtility.executeOperation(operation, sync);
......
248 249
        // commit the conversation and start a new transaction immediately
249 250
        conversation.commit(true);
250 251

  
251
        CdmStore.getService(IFeatureTreeService.class).saveOrUpdate(getRootEntities());
252
        CdmStore.getService(IFeatureTreeService.class).saveOrUpdate((List)getRootEntities());
252 253

  
253
        List<FeatureTree> rootEntities = getRootEntities();
254
        for (FeatureTree featureTree : rootEntities) {
254
        List<TermTree<Feature>> rootEntities = getRootEntities();
255
        for (TermTree featureTree : rootEntities) {
255 256
            if(featureTree.getTermType().equals(TermType.Character)){
256
                FeatureTree<Character> characterTree = featureTree;
257
                TermTree<Character> characterTree = featureTree;
257 258
                //save characters because they can be modified in this editor
258
                characterTree.getDistinctFeatures().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
259
                characterTree.getDistinctTerms().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
259 260
            }
260 261
        }
261 262

  
......
267 268
    private void initializeTrees() {
268 269
        Object[] expandedElements = viewer.getExpandedElements();
269 270
        viewer.getTree().removeAll();
270
        List<FeatureTree> trees = CdmStore.getService(IFeatureTreeService.class).list(FeatureTree.class, null, null, null, null);
271
        List<TermTree> trees = CdmStore.getService(IFeatureTreeService.class).list(TermTree.class, null, null, null, null);
271 272
        viewer.setInput(trees);
272 273
        viewer.setExpandedElements(expandedElements);
273 274
    }
......
292 293
        });
293 294
        Map<Object, List<String>> propertyPathMap =
294 295
                new HashMap<Object, List<String>>();
295
        propertyPathMap.put(FeatureNode.class,propertyPaths);
296
        propertyPathMap.put(TermNode.class,propertyPaths);
296 297
        return propertyPathMap;
297 298
    }
298 299

  
299 300
    @Override
300
    public List<FeatureTree> getRootEntities() {
301
        return (List<FeatureTree>) viewer.getInput();
301
    public List<TermTree<Feature>> getRootEntities() {
302
        return (List<TermTree<Feature>>) viewer.getInput();
302 303
    }
303 304

  
304 305
    @Override
......
347 348
    public boolean postOperation(Object objectAffectedByOperation) {
348 349
        initializeTrees();
349 350
        viewer.refresh();
350
        if(objectAffectedByOperation instanceof FeatureNode){
351
            FeatureNode node = (FeatureNode)objectAffectedByOperation;
352
            viewer.expandToLevel(node.getFeatureTree(), 1);
351
        if(objectAffectedByOperation instanceof TermNode){
352
        	TermNode<Feature> node = (TermNode)objectAffectedByOperation;
353
            viewer.expandToLevel(node.getGraph(), 1);
353 354
        }
354 355
        if(objectAffectedByOperation!=null){
355 356
            StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/FeatureTreeEditorComposite.java
29 29
import org.eclipse.swt.widgets.Tree;
30 30

  
31 31
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
32
import eu.etaxonomy.cdm.model.term.TermTree;
32 33
import eu.etaxonomy.cdm.model.term.TermType;
33
import eu.etaxonomy.cdm.model.term.FeatureTree;
34 34
import eu.etaxonomy.taxeditor.editor.definedterm.TermTransfer;
35 35
import eu.etaxonomy.taxeditor.featuretree.FeatureNodeTransfer;
36 36
import eu.etaxonomy.taxeditor.featuretree.FeatureTreeContentProvider;
......
43 43
/**
44 44
 * @author pplitzner
45 45
 * @since Jun 19, 2017
46
 *
47 46
 */
48 47
public class FeatureTreeEditorComposite <T extends DefinedTermBase> extends Composite{
49 48

  
50
    private FeatureTree<T> featureTree;
49
    private TermTree<T> featureTree;
51 50

  
52 51
    private Label label_title;
53 52
    private Text text_title;
......
181 180
            btnOpenFeatureTree.addSelectionListener(new SelectionAdapter(){
182 181
                @Override
183 182
                public void widgetSelected(SelectionEvent e) {
184
                    FeatureTree<T> tree = FeatureTreeSelectionDialog.select(getDisplay().getActiveShell(),
183
                    TermTree<T> tree = FeatureTreeSelectionDialog.select(getDisplay().getActiveShell(),
185 184
                            null, termType);
186 185
                    if(tree!=null){
187 186
                        setSelectedTree(tree);
......
194 193
        }
195 194
    }
196 195

  
197
    public void setSelectedTree(FeatureTree<T> featureTree) {
196
    public void setSelectedTree(TermTree<T> featureTree) {
198 197
        this.featureTree = featureTree;
199 198

  
200 199
        viewer.setInput(featureTree);
......
209 208
        }
210 209
    }
211 210

  
212
    public FeatureTree<T> getFeatureTree() {
211
    public TermTree<T> getFeatureTree() {
213 212
        return featureTree;
214 213
    }
215 214

  
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/handler/AddChildFeatureHandler.java
24 24
import org.eclipse.jface.wizard.WizardDialog;
25 25
import org.eclipse.swt.widgets.Shell;
26 26

  
27
import eu.etaxonomy.cdm.model.description.Feature;
27 28
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
28
import eu.etaxonomy.cdm.model.term.FeatureNode;
29
import eu.etaxonomy.cdm.model.term.TermNode;
29 30
import eu.etaxonomy.taxeditor.featuretree.AvailableFeaturesWizard;
30 31
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
31 32
import eu.etaxonomy.taxeditor.featuretree.e4.operation.AddFeatureOperation;
......
34 35

  
35 36
/**
36 37
 * @author pplitzner
37
 * @since Jul 12, 2017
38
 *
38
 * @since Jul 12, 2017 
39 39
 */
40 40
public class AddChildFeatureHandler {
41 41

  
......
48 48
        if (StoreUtil.promptCheckIsDirty(editor)) {
49 49
            return;
50 50
        }
51
        FeatureNode parent = (FeatureNode)selection.getFirstElement();
51
        TermNode<Feature> parent = (TermNode<Feature>)selection.getFirstElement();
52 52

  
53 53
//        TermChooseWizard wizard = new TermChooseWizard(parent.getTermType());
54 54
//        WizardDialog dialog = new WizardDialog(shell, wizard);
......
82 82
        canExecute = thisPart.getObject() instanceof IFeatureTreeEditor
83 83
                && selection!=null
84 84
                && selection.size()==1
85
                && selection.getFirstElement() instanceof FeatureNode;
85
                && selection.getFirstElement() instanceof TermNode;
86 86
        menuItem.setVisible(canExecute);
87 87
        return canExecute;
88 88
    }
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/handler/AddFeatureHandler.java
24 24
import org.eclipse.jface.wizard.WizardDialog;
25 25
import org.eclipse.swt.widgets.Shell;
26 26

  
27
import eu.etaxonomy.cdm.model.description.Feature;
27 28
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
28
import eu.etaxonomy.cdm.model.term.FeatureTree;
29
import eu.etaxonomy.cdm.model.term.TermTree;
29 30
import eu.etaxonomy.taxeditor.featuretree.AvailableFeaturesWizard;
30 31
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
31 32
import eu.etaxonomy.taxeditor.featuretree.e4.operation.AddFeatureOperation;
......
47 48
        if (StoreUtil.promptCheckIsDirty(editor)) {
48 49
            return;
49 50
        }
50
        FeatureTree tree = (FeatureTree) selection.getFirstElement();
51
        TermTree<Feature> tree = (TermTree<Feature>) selection.getFirstElement();
51 52
//
52 53
//        TermChooseWizard wizard = new TermChooseWizard(tree.getTermType());
53 54
//        WizardDialog dialog = new WizardDialog(shell, wizard);
......
81 82
        canExecute = thisPart.getObject() instanceof IFeatureTreeEditor
82 83
                && selection!=null
83 84
                && selection.size()==1
84
                && selection.getFirstElement() instanceof FeatureTree;
85
                && selection.getFirstElement() instanceof TermTree;
85 86
        menuItem.setVisible(canExecute);
86 87
        return canExecute;
87 88
    }
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/handler/CopyFeatureHandler.java
11 11
import org.eclipse.e4.ui.services.IServiceConstants;
12 12
import org.eclipse.jface.viewers.IStructuredSelection;
13 13

  
14
import eu.etaxonomy.cdm.model.term.FeatureNode;
14
import eu.etaxonomy.cdm.model.term.TermNode;
15 15
import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeEditor;
16 16

  
17 17
public class CopyFeatureHandler {
......
30 30
        canExecute =part.getObject() instanceof FeatureTreeEditor
31 31
                && selection!=null
32 32
                && selection.size()==1
33
                && selection.getFirstElement() instanceof FeatureNode;
33
                && selection.getFirstElement() instanceof TermNode;
34 34
        menuItem.setVisible(canExecute);
35 35
        return canExecute;
36 36
    }
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/handler/CreateFeatureTreeHandler.java
17 17
import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
18 18
import org.eclipse.e4.ui.services.IServiceConstants;
19 19

  
20
import eu.etaxonomy.cdm.model.term.FeatureTree;
20
import eu.etaxonomy.cdm.model.description.Feature;
21
import eu.etaxonomy.cdm.model.term.TermTree;
21 22
import eu.etaxonomy.cdm.model.term.TermType;
22 23
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
23 24
import eu.etaxonomy.taxeditor.featuretree.e4.operation.CreateFeatureTreeOperation;
......
39 40
            return;
40 41
        }
41 42

  
42
        FeatureTree tree = FeatureTree.NewInstance(getTermType());
43
        TermTree<Feature> tree = TermTree.NewInstance(getTermType());
43 44
        tree.setTitleCache("New feature tree", true);
44 45
        CreateFeatureTreeOperation operation = new CreateFeatureTreeOperation(tree, editor, editor);
45 46
        AbstractUtility.executeOperation(operation, sync);
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/handler/FeatureTreeExportOntologyHandler.java
28 28
import org.eclipse.ui.progress.IProgressConstants;
29 29

  
30 30
import eu.etaxonomy.cdm.io.descriptive.owl.out.StructureTreeOwlExportConfigurator;
31
import eu.etaxonomy.cdm.model.term.FeatureTree;
31
import eu.etaxonomy.cdm.model.term.TermTree;
32 32
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
33 33
import eu.etaxonomy.taxeditor.preference.IPreferenceKeys;
34 34
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
......
53 53
        }
54 54

  
55 55
        List<UUID> featureTreeUuids = new ArrayList<>();
56
        selection.toList().stream().filter(o->o instanceof FeatureTree).forEach(tree->featureTreeUuids.add(((FeatureTree)tree).getUuid()));
56
        selection.toList().stream().filter(o->o instanceof TermTree).forEach(tree->featureTreeUuids.add(((TermTree)tree).getUuid()));
57 57

  
58 58
        FileDialog dialog = new FileDialog(shell);
59 59
        String[] filterNames = {
......
90 90
        canExecute = PreferencesUtil.getBooleanValue(IPreferenceKeys.SHOW_EXPERIMENTAL_FEATURES)
91 91
                && selection!=null
92 92
                && selection.size()==1
93
                && selection.getFirstElement() instanceof FeatureTree;
93
                && selection.getFirstElement() instanceof TermTree;
94 94
        menuItem.setVisible(canExecute);
95 95
        return canExecute;
96 96
    }
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/handler/FeatureTreeExportWordHandler.java
25 25
import org.eclipse.ui.progress.IProgressConstants;
26 26

  
27 27
import eu.etaxonomy.cdm.io.descriptive.word.out.WordExportConfigurator;
28
import eu.etaxonomy.cdm.model.term.FeatureTree;
28
import eu.etaxonomy.cdm.model.description.Feature;
29
import eu.etaxonomy.cdm.model.term.TermTree;
29 30
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
30 31
import eu.etaxonomy.taxeditor.preference.IPreferenceKeys;
31 32
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
......
49 50
            return;
50 51
        }
51 52

  
52
        FeatureTree selectedFeatureTree = (FeatureTree) selection.getFirstElement();
53
        TermTree<Feature> selectedFeatureTree = (TermTree<Feature>) selection.getFirstElement();
53 54
        DirectoryDialog dialog = new DirectoryDialog(shell);
54 55
        String directoryString = dialog.open();
55 56
        if(directoryString!=null){
......
71 72
        canExecute = PreferencesUtil.getBooleanValue(IPreferenceKeys.SHOW_EXPERIMENTAL_FEATURES)
72 73
                && selection!=null
73 74
                && selection.size()==1
74
                && selection.getFirstElement() instanceof FeatureTree;
75
                && selection.getFirstElement() instanceof TermTree;
75 76
        menuItem.setVisible(canExecute);
76 77
        return canExecute;
77 78
    }
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/handler/PasteFeatureHandler.java
13 13
import org.eclipse.jface.viewers.ISelection;
14 14
import org.eclipse.jface.viewers.IStructuredSelection;
15 15

  
16
import eu.etaxonomy.cdm.model.term.FeatureNode;
16
import eu.etaxonomy.cdm.model.term.TermNode;
17 17
import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeEditor;
18 18

  
19 19
public class PasteFeatureHandler {
......
36 36
                && selection.size()==1
37 37
                && transferSelection instanceof IStructuredSelection
38 38
                && ((IStructuredSelection)transferSelection).size()==1
39
                && ((IStructuredSelection)transferSelection).getFirstElement() instanceof FeatureNode;
39
                && ((IStructuredSelection)transferSelection).getFirstElement() instanceof TermNode;
40 40
        menuItem.setVisible(canExecute);
41 41
        return canExecute;
42 42
    }
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/handler/RemoveFeatureHandler.java
19 19
import org.eclipse.e4.ui.services.IServiceConstants;
20 20
import org.eclipse.jface.viewers.IStructuredSelection;
21 21

  
22
import eu.etaxonomy.cdm.model.term.FeatureNode;
22
import eu.etaxonomy.cdm.model.description.Feature;
23
import eu.etaxonomy.cdm.model.term.TermNode;
23 24
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
24 25
import eu.etaxonomy.taxeditor.featuretree.e4.operation.RemoveFeatureOperation;
25 26
import eu.etaxonomy.taxeditor.model.AbstractUtility;
......
45 46
        }
46 47

  
47 48
        for (Object selectedObject : selection.toArray()) {
48
            FeatureNode featureNode = (FeatureNode) selectedObject;
49
        	TermNode<Feature> featureNode = (TermNode<Feature>) selectedObject;
49 50
            RemoveFeatureOperation operation = new RemoveFeatureOperation(featureNode, editor, editor);
50 51
            AbstractUtility.executeOperation(operation, sync);
51 52
        }
......
59 60
        boolean canExecute = selection!=null && !selection.isEmpty();
60 61
        if(selection!=null){
61 62
            for(Object object:selection.toArray()){
62
                canExecute &= object instanceof FeatureNode;
63
                canExecute &= object instanceof TermNode;
63 64
            }
64 65
        }
65 66
        canExecute &= thisPart.getObject() instanceof IFeatureTreeEditor;
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/handler/RemoveFeatureTreeHandler.java
19 19
import org.eclipse.e4.ui.services.IServiceConstants;
20 20
import org.eclipse.jface.viewers.IStructuredSelection;
21 21

  
22
import eu.etaxonomy.cdm.model.term.FeatureTree;
22
import eu.etaxonomy.cdm.model.description.Feature;
23
import eu.etaxonomy.cdm.model.term.TermTree;
23 24
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
24 25
import eu.etaxonomy.taxeditor.featuretree.e4.operation.RemoveFeatureTreeOperation;
25 26
import eu.etaxonomy.taxeditor.model.AbstractUtility;
......
45 46
        }
46 47

  
47 48
        for (Object selectedObject : selection.toArray()) {
48
            FeatureTree featureTree = (FeatureTree) selectedObject;
49
        	TermTree<Feature> featureTree = (TermTree<Feature>) selectedObject;
49 50
            RemoveFeatureTreeOperation operation = new RemoveFeatureTreeOperation(featureTree, editor, editor);
50 51
            AbstractUtility.executeOperation(operation, sync);
51 52
        }
......
59 60
        boolean canExecute = selection!=null && !selection.isEmpty();
60 61
        if(canExecute){
61 62
            for(Object object:selection.toArray()){
62
                canExecute &= object instanceof FeatureTree;
63
                canExecute &= object instanceof TermTree;
63 64
            }
64 65
        }
65 66
        canExecute &= thisPart.getObject() instanceof IFeatureTreeEditor;
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/operation/AddFeatureOperation.java
18 18
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
19 19
import eu.etaxonomy.cdm.api.service.UpdateResult;
20 20
import eu.etaxonomy.cdm.model.description.Feature;
21
import eu.etaxonomy.cdm.model.term.FeatureNode;
21
import eu.etaxonomy.cdm.model.term.TermNode;
22 22
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
23 23
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
24 24
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
......
32 32
 */
33 33
public class AddFeatureOperation extends AbstractPostOperation<Feature> {
34 34

  
35
    private FeatureNode node;
35
    private TermNode<Feature> node;
36 36
    private int position;
37 37
    private UUID featureUuid;
38 38

  
39
    public AddFeatureOperation(UUID featureUuid, FeatureNode node,
39
    public AddFeatureOperation(UUID featureUuid, TermNode<Feature> node,
40 40
            IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
41 41
        this(featureUuid, node, 0, postOperationEnabled, cdmEntitySessionEnabled);
42 42
    }
43
    public AddFeatureOperation(UUID featureUuid, FeatureNode node, int position,
43
    public AddFeatureOperation(UUID featureUuid, TermNode<Feature> node, int position,
44 44
            IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
45 45
        super("Add Feature", StoreUtil.getUndoContext(), null, postOperationEnabled, cdmEntitySessionEnabled);
46 46
        this.node = node;
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/operation/AddOntologyTermOperation.java
18 18
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
19 19
import eu.etaxonomy.cdm.api.service.UpdateResult;
20 20
import eu.etaxonomy.cdm.model.description.Feature;
21
import eu.etaxonomy.cdm.model.term.FeatureNode;
21
import eu.etaxonomy.cdm.model.term.TermNode;
22 22
import eu.etaxonomy.cdm.model.term.TermVocabulary;
23 23
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
24 24
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
......
32 32
 * @since Apr 30, 2018
33 33
 *
34 34
 */
35
public class AddOntologyTermOperation extends AbstractPostOperation<FeatureNode> {
35
public class AddOntologyTermOperation extends AbstractPostOperation<TermNode<Feature>> {
36 36

  
37
    private FeatureNode target;
37
    private TermNode<Feature> target;
38 38
    private OntologyTermWrapper wrapper;
39 39
    private TermVocabulary vocabulary;
40 40

  
41
    public AddOntologyTermOperation(OntologyTermWrapper wrapper, FeatureNode target, TermVocabulary vocabulary,
41
    public AddOntologyTermOperation(OntologyTermWrapper wrapper, TermNode<Feature> target, TermVocabulary vocabulary,
42 42
            IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
43 43
        super("Add ontology term", StoreUtil.getUndoContext(), target, postOperationEnabled, cdmEntitySessionEnabled);
44 44
        this.wrapper = wrapper;
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/operation/CreateFeatureTreeOperation.java
14 14
import org.eclipse.core.runtime.IStatus;
15 15

  
16 16
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
17
import eu.etaxonomy.cdm.model.term.FeatureTree;
17
import eu.etaxonomy.cdm.model.description.Feature;
18
import eu.etaxonomy.cdm.model.term.TermTree;
18 19
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
19 20
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
20 21
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
......
26 27
 * @since Apr 30, 2018
27 28
 *
28 29
 */
29
public class CreateFeatureTreeOperation extends AbstractPostOperation<FeatureTree>{
30
public class CreateFeatureTreeOperation extends AbstractPostOperation<TermTree<Feature>>{
30 31

  
31
    public CreateFeatureTreeOperation(FeatureTree element,
32
    public CreateFeatureTreeOperation(TermTree<Feature> element,
32 33
            IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
33 34
        super("Create Feature Tree", StoreUtil.getUndoContext(), element, postOperationEnabled, cdmEntitySessionEnabled);
34 35
    }
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/operation/MoveFeatureOperation.java
17 17

  
18 18
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
19 19
import eu.etaxonomy.cdm.api.service.UpdateResult;
20
import eu.etaxonomy.cdm.model.term.FeatureNode;
20
import eu.etaxonomy.cdm.model.description.Feature;
21
import eu.etaxonomy.cdm.model.term.TermNode;
21 22
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
22 23
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
23 24
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
......
30 31
 * @date 21.01.2019
31 32
 *
32 33
 */
33
public class MoveFeatureOperation extends AbstractPostOperation<FeatureNode> {
34
public class MoveFeatureOperation extends AbstractPostOperation<TermNode<Feature>> {
34 35

  
35
    private FeatureNode droppedNode;
36
    private FeatureNode target;
36
    private TermNode<Feature> droppedNode;
37
    private TermNode<Feature> target;
37 38
    private int currentOperation;
38 39
    private int position;
39 40

  
40
    public MoveFeatureOperation(FeatureNode droppedNode, FeatureNode target, int position,
41
    public MoveFeatureOperation(TermNode<Feature> droppedNode, TermNode<Feature> target, int position,
41 42
            int currentOperation,
42 43
            IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
43 44
        super(currentOperation == DND.DROP_MOVE ? "Move Feature" : "Copy Feature", StoreUtil.getUndoContext(),
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/operation/RemoveFeatureOperation.java
15 15

  
16 16
import eu.etaxonomy.cdm.api.service.DeleteResult;
17 17
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
18
import eu.etaxonomy.cdm.api.service.config.FeatureNodeDeletionConfigurator;
19
import eu.etaxonomy.cdm.model.term.FeatureNode;
18
import eu.etaxonomy.cdm.api.service.config.TermNodeDeletionConfigurator;
19
import eu.etaxonomy.cdm.model.description.Feature;
20
import eu.etaxonomy.cdm.model.term.TermNode;
20 21
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
21 22
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
22 23
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
......
28 29
 * @since Apr 30, 2018
29 30
 *
30 31
 */
31
public class RemoveFeatureOperation extends AbstractPostOperation<FeatureNode>{
32
public class RemoveFeatureOperation extends AbstractPostOperation<TermNode<Feature>>{
32 33

  
33
    public RemoveFeatureOperation(FeatureNode element,
34
    public RemoveFeatureOperation(TermNode<Feature> element,
34 35
            IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
35 36
        super("Remove Feature", StoreUtil.getUndoContext(), element, postOperationEnabled, cdmEntitySessionEnabled);
36 37
    }
37 38

  
38 39
    @Override
39 40
    public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
40
        DeleteResult result = CdmStore.getService(IFeatureNodeService.class).deleteFeatureNode(element.getUuid(), new FeatureNodeDeletionConfigurator());
41
        DeleteResult result = CdmStore.getService(IFeatureNodeService.class).deleteFeatureNode(element.getUuid(), new TermNodeDeletionConfigurator());
41 42
        return postExecute(null);
42 43
    }
43 44

  
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/e4/operation/RemoveFeatureTreeOperation.java
14 14
import org.eclipse.core.runtime.IStatus;
15 15

  
16 16
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
17
import eu.etaxonomy.cdm.model.term.FeatureTree;
17
import eu.etaxonomy.cdm.model.description.Feature;
18
import eu.etaxonomy.cdm.model.term.TermTree;
18 19
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
19 20
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
20 21
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
......
26 27
 * @since Apr 30, 2018
27 28
 *
28 29
 */
29
public class RemoveFeatureTreeOperation extends AbstractPostOperation<FeatureTree>{
30
public class RemoveFeatureTreeOperation extends AbstractPostOperation<TermTree<Feature>>{
30 31

  
31
    public RemoveFeatureTreeOperation(FeatureTree element,
32
    public RemoveFeatureTreeOperation(TermTree<Feature> element,
32 33
            IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
33 34
        super("Remove Feature Tree", StoreUtil.getUndoContext(), element, postOperationEnabled, cdmEntitySessionEnabled);
34 35
    }
eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/io/e4/out/owl/OwlTermExportWizardPage.java
24 24
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
25 25
import eu.etaxonomy.cdm.api.service.IVocabularyService;
26 26
import eu.etaxonomy.cdm.common.CdmUtils;
27
import eu.etaxonomy.cdm.model.term.FeatureTree;
27
import eu.etaxonomy.cdm.model.description.Feature;
28
import eu.etaxonomy.cdm.model.term.TermTree;
28 29
import eu.etaxonomy.cdm.model.term.TermType;
29 30
import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
30 31
import eu.etaxonomy.taxeditor.store.CdmStore;
......
32 33
/**
33 34
 * @author pplitzner
34 35
 * @since May 23, 2019
35
 *
36 36
 */
37 37
public class OwlTermExportWizardPage extends WizardPage {
38 38

  
......
58 58
        composite.getSelectVocabularyComposite().getViewer().setInput(areaVocabularies);
59 59
        composite.getSelectVocabularyComposite().getViewer().addCheckStateListener(e->updateButtons());
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Add picture from clipboard (Maximum size: 40 MB)