EDIT

/**

* Copyright (C) 2017 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.editor.descriptiveDataSet.character;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.e4.core.di.annotations.Optional;

import org.eclipse.e4.ui.di.Focus;

import org.eclipse.e4.ui.di.Persist;

import org.eclipse.e4.ui.di.UIEventTopic;

import org.eclipse.e4.ui.di.UISynchronize;

import org.eclipse.e4.ui.model.application.ui.MDirtyable;

import org.eclipse.e4.ui.services.EMenuService;

import org.eclipse.e4.ui.workbench.modeling.ESelectionService;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreeSelection;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.SashForm;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.events.ModifyEvent;

import org.eclipse.swt.events.ModifyListener;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Text;

import org.eclipse.ui.forms.widgets.FormToolkit;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;

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

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

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

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

import eu.etaxonomy.cdm.model.common.Language;

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

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

import eu.etaxonomy.cdm.model.term.DefinedTerm;

import eu.etaxonomy.cdm.model.term.DefinedTermBase;

import eu.etaxonomy.cdm.model.term.Representation;

import eu.etaxonomy.cdm.model.term.TermNode;

import eu.etaxonomy.cdm.model.term.TermTree;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.cdm.model.term.TermVocabulary;

import eu.etaxonomy.cdm.model.term.VocabularyEnum;

import eu.etaxonomy.cdm.persistence.dto.CharacterDto;

import eu.etaxonomy.cdm.persistence.dto.CharacterNodeDto;

import eu.etaxonomy.cdm.persistence.dto.TermDto;

import eu.etaxonomy.cdm.persistence.dto.TermNodeDto;

import eu.etaxonomy.cdm.persistence.dto.TermTreeDto;

import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;

import eu.etaxonomy.taxeditor.editor.AppModelId;

import eu.etaxonomy.taxeditor.editor.definedterm.TermTreeViewerComparator;

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

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.model.ImageResources;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.StoreUtil;

import eu.etaxonomy.taxeditor.termtree.CharacterTransfer;

import eu.etaxonomy.taxeditor.termtree.TermTreeContentProvider;

import eu.etaxonomy.taxeditor.termtree.TermTreeLabelProvider;

import eu.etaxonomy.taxeditor.termtree.e4.ICharacterEditor;

import eu.etaxonomy.taxeditor.termtree.e4.TermNodeDtoDragListener;

import eu.etaxonomy.taxeditor.termtree.e4.TermTreeDtoDropAdapter;

import eu.etaxonomy.taxeditor.termtree.e4.TermTreeDtoEditorComposite;

import eu.etaxonomy.taxeditor.termtree.e4.TermTreeEditor;

import eu.etaxonomy.taxeditor.ui.dialog.selection.FeatureTreeSelectionDialog;

import eu.etaxonomy.taxeditor.ui.dialog.selection.TermVocabularySelectionDialog;

import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;

import eu.etaxonomy.taxeditor.workbench.part.IE4ViewerPart;

/**

 * Editor for combining structure and property terms to characters.

 * @author pplitzner

 * @date 24.05.2017

 */

public class CharacterEditor implements ICharacterEditor, IConversationEnabled, ISelectionChangedListener,

        ModifyListener, IE4ViewerPart, IPartContentHasDetails, IPartContentHasSupplementalData,

        IDirtyMarkable, IE4SavablePart {

    private TermTreeDtoEditorComposite characterTreeEditorComposite;

    private final FormToolkit formToolkit = new FormToolkit(Display.getDefault());

    @Inject

    private ESelectionService selService;

    @Inject

    private UISynchronize sync;

    @Inject

    private MDirtyable dirty;

    private ConversationHolder conversation;

    private ICdmEntitySession cdmEntitySession;

    private TermVocabulary vocabulary;

    private TreeViewer structureViewer;

    private TreeViewer propertyViewer;

    private List<AbstractPostOperation> operations = new ArrayList<>();

    private List<CharacterNodeDto> nodesToUpdate = new ArrayList<>();

    private Map<Character, CharacterNodeDto> nodesToSave = new HashMap<>();

    public CharacterEditor() {

    }

    /**

     * Create contents of the view part.

     */

    @PostConstruct

    public void createControls(Composite parent, EMenuService menuService ) {

        if (CdmStore.isActive()){

            if(conversation == null){

                conversation = CdmStore.createConversation();

            }

            if(cdmEntitySession==null){

                cdmEntitySession = CdmStore.getCurrentSessionManager().newSession(this, true);

            }

        }

        else{

            return;

        }

        parent.setLayout(new GridLayout(1, false));

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

        vocChooserComposite.setLayout(new GridLayout(4, false));

        vocChooserComposite.setLayoutData(new GridData(SWT.RIGHT, SWT.FILL, false, false, 2, 1));

        Label lblVocImport = new Label(vocChooserComposite, SWT.NONE);

        lblVocImport.setText("Character vocabulary:");

        Text txtVocabulary = new Text(vocChooserComposite, SWT.NONE);

        txtVocabulary.setEditable(false);

        Button btnChooseVoc = new Button(vocChooserComposite, SWT.PUSH);

        btnChooseVoc.setImage(ImageResources.getImage(ImageResources.BROWSE_ICON));

        btnChooseVoc.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                // hard-coded filter for "built-in" vocabularies Feature and Name Feature

                Set<TermVocabulary> vocabulariesToBeFiltered = new HashSet<>();

                vocabulariesToBeFiltered.add(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.Feature.getUuid()));

                vocabulariesToBeFiltered.add(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()));

                if(vocabulary!=null){

                    vocabulariesToBeFiltered.add(vocabulary);

                }

                vocabulary = TermVocabularySelectionDialog.select("Select vocabulary for characters", btnChooseVoc.getShell(), vocabulariesToBeFiltered, TermType.Character);

                if(vocabulary!=null){

                    txtVocabulary.setText(vocabulary.getLabel());

                }

            }

        });

        SashForm sashForm = new SashForm(parent, SWT.NONE);

        sashForm.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));

        formToolkit.adapt(sashForm);

        formToolkit.paintBordersFor(sashForm);

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

        formToolkit.adapt(composite);

        formToolkit.paintBordersFor(composite);

        GridLayout gl_composite = new GridLayout(1, false);

        gl_composite.marginWidth = 0;

        composite.setLayout(gl_composite);

        structureViewer = createTreeViewer(composite, TermType.Structure, Messages.CharacterEditor_STRUCTURES);

        Composite composite_1 = new Composite(sashForm, SWT.NONE);

        formToolkit.adapt(composite_1);

        formToolkit.paintBordersFor(composite_1);

        GridLayout gl_composite_1 = new GridLayout(1, false);

        gl_composite_1.marginWidth = 0;

        composite_1.setLayout(gl_composite_1);

        propertyViewer = createTreeViewer(composite_1, TermType.Property, Messages.CharacterEditor_PROPERTIES);

        int ops = DND.DROP_COPY | DND.DROP_MOVE;

        Transfer[] transfers = new Transfer[] {CharacterTransfer.getInstance()};

        propertyViewer.addDragSupport(ops, transfers, new CharacterDragListener(structureViewer, propertyViewer));

        Composite composite_3 = new Composite(sashForm, SWT.NONE);

        formToolkit.adapt(composite_3);

        formToolkit.paintBordersFor(composite_3);

        GridLayout gl_composite_3 = new GridLayout(2, false);

        gl_composite_3.marginWidth = 0;

        composite_3.setLayout(gl_composite_3);

        Button btnAddCharacter = new Button(composite_3, SWT.NONE);

        btnAddCharacter.setText(">>"); //$NON-NLS-1$

        formToolkit.adapt(btnAddCharacter, true, true);

        btnAddCharacter.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                if(!isVocabularySet()){

                    return;

                }

                if (confirmSaveDirty()){

                    return;

                }

                ISelection structureTreeSelection = structureViewer.getSelection();

                ISelection propertyTreeSelection = propertyViewer.getSelection();

                if(structureTreeSelection==null || propertyTreeSelection==null || characterTreeEditorComposite.getFeatureTree()==null){

                    MessagingUtils.warningDialog(Messages.CharacterEditor_CANNOT_PERFORM_TITLE, CharacterEditor.this,

                            Messages.CharacterEditor_CANNOT_PERFORM_MESSAGE);

                    return;

                }

                Collection<Character> characters = createCharacters((TreeSelection)structureTreeSelection, (TreeSelection)propertyTreeSelection);

                TermNodeDto parent = characterTreeEditorComposite.getFeatureTree().getRoot();

                for (Character character : characters) {

                    //add new Character to feature tree

                    CharacterNodeDto nodeDto = new CharacterNodeDto(CharacterDto.fromCharacter(character), parent, 0, parent.getTree(), null, null, null);

                    nodesToSave.put(character, nodeDto);

                    setDirty();

                    //                    result = CdmStore.getService(IFeatureNodeService.class).createChildFeatureNode(parent.getUuid(), character, vocabulary.getUuid());

                }

                refresh();

            }

        });

        characterTreeEditorComposite = addFeatureTreeEditor(composite_3);

        initFeatureTreeComposite(TermType.Character, characterTreeEditorComposite, new TermNodeDtoDragListener(characterTreeEditorComposite.getViewer()),

                new TermTreeDtoDropAdapter(this, characterTreeEditorComposite.getViewer(), sync),

                null);

        characterTreeEditorComposite.getLabel_title().setText(Messages.CharacterEditor_CHARACTERS);

        //add context menu to character viewer

        menuService.registerContextMenu(characterTreeEditorComposite.getViewer().getControl(),

                AppModelId.POPUPMENU_EU_ETAXONOMY_TAXEDITOR_EDITOR_POPUPMENU_CHARACTEREDITOR);

    }

    private TreeViewer createTreeViewer(Composite parent, TermType termType, String labelString) {

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

        composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));

        composite.setLayout(new GridLayout(2, false));

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

        label.setText(labelString);

        Button btnRefresh = new Button(composite, SWT.PUSH);

        btnRefresh.setImage(ImageResources.getImage(ImageResources.REFRESH));

        btnRefresh.setToolTipText("Refresh");

        TreeViewer viewer = new TreeViewer(composite);

        viewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));

        viewer.setContentProvider(new TermTreeContentProvider());

        viewer.setLabelProvider(new TermTreeLabelProvider());

        viewer.setComparator(new TermTreeViewerComparator());

        viewer.addSelectionChangedListener(this);

        viewer.setInput(CdmStore.getService(ITermTreeService.class).list(termType, null, null, null, TermTreeEditor.TREE_PROPERTY_PATH));

        btnRefresh.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                viewer.setInput(CdmStore.getService(ITermTreeService.class).list(termType, null, null, null, TermTreeEditor.TREE_PROPERTY_PATH));

                refresh(viewer);

            }

        });

        return viewer;

    }

    private <T extends DefinedTermBase> TermTreeDtoEditorComposite<T> addFeatureTreeEditor(Composite composite_3) {

        TermTreeDtoEditorComposite<T> TermTreeEditorComposite = new TermTreeDtoEditorComposite<>(composite_3, SWT.NONE);

        TermTreeEditorComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));

        return TermTreeEditorComposite;

    }

    private void initFeatureTreeComposite(

            TermType termType,

            TermTreeDtoEditorComposite TermTreeEditorComposite,

            TermNodeDtoDragListener featureNodeDragListener,

            TermTreeDtoDropAdapter featureNodeDropAdapter,

            Transfer[] transfers) {

        TermTreeEditorComposite.init(

                featureNodeDragListener,

                featureNodeDropAdapter,

                transfers,

                this,

                new FeatureTreeChooserListener(TermTreeEditorComposite, termType),

                this);

    }

    @Focus

    public void focus(){

        if(characterTreeEditorComposite!=null){

            characterTreeEditorComposite.getViewer().getControl().setFocus();

        }

        if(conversation!=null && !conversation.isBound()){

            conversation.bind();

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.bind();

        }

    }

    public static Collection<Character> createCharacters(TreeSelection structureTreeSelection, TreeSelection propertyTreeSelection){

        Set<Character> characters = new HashSet<>();

        //get selected structures and properties

        Iterator<TermNode<DefinedTerm>> structureIterator = structureTreeSelection.iterator();

        //create all combinations of structures and properties

        while(structureIterator.hasNext()){

            TermNode<DefinedTerm> structureNode = structureIterator.next();

            Iterator<TermNode<DefinedTerm>> propertiesIterator = propertyTreeSelection.iterator();

            while(propertiesIterator.hasNext()){

                TermNode<DefinedTerm> propertyNode = propertiesIterator.next();

                Representation structureRepresentation = structureNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());

                if(structureRepresentation==null){

                    structureRepresentation = structureNode.getTerm().getRepresentation(Language.DEFAULT());

                }

                Representation propertyRepresentation = propertyNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());

                if(propertyRepresentation==null){

                    propertyRepresentation = propertyNode.getTerm().getRepresentation(Language.DEFAULT());

                }

                String label = null;

                String abbrevLabel = null;

                if(structureRepresentation!=null && propertyRepresentation!=null){

                    if(structureRepresentation.getLabel()!=null && propertyRepresentation.getLabel()!=null){

                        label = structureRepresentation.getLabel()+" "+propertyRepresentation.getLabel();

                    }

                    if(structureRepresentation.getAbbreviatedLabel()!=null && propertyRepresentation.getAbbreviatedLabel()!=null){

                        abbrevLabel = structureRepresentation.getAbbreviatedLabel()+" "+propertyRepresentation.getAbbreviatedLabel();

                    }

                }

                if(label!=null){

                    //default label

                    label = structureNode.getTerm().getLabel()+" "+propertyNode.getTerm().getLabel();

                }

                Character character = Character.NewInstance(structureNode, propertyNode, null, label, abbrevLabel);

                characters.add(character);

            }

        }

        return characters;

    }

    @Override

    @Persist

    public void save(IProgressMonitor monitor){

        if (!conversation.isBound()) {

            conversation.bind();

        }

        UpdateResult result = new UpdateResult();

        if (nodesToSave != null && this.getVocabulary() != null) {

            result.includeResult(CdmStore.getService(ITermNodeService.class).saveNewCharacterNodeDtoMap(this.nodesToSave, this.getVocabulary().getUuid()));

        }

        nodesToSave.clear();

        TermTreeDto featureTree = characterTreeEditorComposite.getFeatureTree();

        if (operations != null && !operations.isEmpty()){

            for (AbstractPostOperation<TermNode> operation: operations){

                AbstractUtility.executeOperation(operation, sync);

            }

            operations.clear();

        }

//      TODO: implement update method for dto

        result.includeResult(CdmStore.getService(ITermNodeService.class).saveCharacterNodeDtoList(this.nodesToUpdate));

        nodesToUpdate.clear();

        // commit the conversation and start a new transaction immediately

        conversation.commit(true);

        if (result.getUpdatedObjects() != null && !result.getUpdatedObjects().isEmpty()){

            Object o = result.getUpdatedObjects().iterator().next();

            if (o instanceof TermNode){

                TermNode node = (TermNode)o;

                TermTree updateTree = (TermTree)node.getGraph();

                if (updateTree != null){

                    characterTreeEditorComposite.setSelectedTree(updateTree);

                }

            }

        }

//        initializeTrees();

        dirty.setDirty(false);

    }

    private void initializeTrees() {

        Object[] expandedElements = characterTreeEditorComposite.getViewer().getExpandedElements();

        characterTreeEditorComposite.getViewer().getTree().removeAll();

        characterTreeEditorComposite.getViewer().setExpandedElements(expandedElements);

    }

    @Override

    public boolean isDirty() {

        return dirty.isDirty();

    }

    @PreDestroy

    public void dispose(){

        if(conversation!=null){

            conversation.close();

            conversation = null;

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.dispose();

            cdmEntitySession = null;

        }

        dirty.setDirty(false);

    }

    public boolean isVocabularySet() {

        if(vocabulary==null){

            MessagingUtils.warningDialog("Character creation not possible", this.getClass(), "Please select a vocabulary for the characters.");

        }

        return vocabulary!=null;

    }

    public boolean confirmSaveDirty(){

        return StoreUtil.promptCheckIsDirty(this);

    }

    public TermVocabulary getVocabulary() {

        return vocabulary;

    }

    @Override

    public Map<Object, List<String>> getPropertyPathsMap() {

        List<String> propertyPaths = Arrays.asList(new String[] {

                "children", //$NON-NLS-1$

                "feature", //$NON-NLS-1$

                "featureTree", //$NON-NLS-1$

        });

        Map<Object, List<String>> propertyPathMap =

                new HashMap<Object, List<String>>();

        propertyPathMap.put(TermNode.class,propertyPaths);

        return propertyPathMap;

    }

    @Override

    public List<TermTreeDto> getRootEntities() {

        List<TermTreeDto> root = new ArrayList<>();

        root.add(characterTreeEditorComposite.getFeatureTree());

        return root;

    }

    @Override

    public ICdmEntitySession getCdmEntitySession() {

        return cdmEntitySession;

    }

    @Focus

    public void setFocus() {

        if(conversation!=null && !conversation.isBound()){

            conversation.bind();

        }

    }

    @Override

    public void selectionChanged(SelectionChangedEvent event) {

        //propagate selection

        selService.setSelection(event.getSelection());

    }

    @Override

    public void modifyText(ModifyEvent e) {

        characterTreeEditorComposite.getFeatureTree().setTitleCache(((Text) e.widget).getText());

        setDirty();

    }

    @Override

    public void setDirty() {

        dirty.setDirty(true);

    }

    @Override

    public IStructuredSelection getSelection() {

        return (IStructuredSelection) characterTreeEditorComposite.getViewer().getSelection();

    }

    @Override

    public TermType getTermType() {

        return TermType.Character;

    }

    public TermTreeDto getCharacterTree(){

        return characterTreeEditorComposite.getFeatureTree();

    }

    public void refresh(TreeViewer viewer){

        viewer.refresh();

        characterTreeEditorComposite.getViewer().setInput(characterTreeEditorComposite.getViewer().getInput());

    }

    private class FeatureTreeChooserListener extends SelectionAdapter{

        private TermTreeDtoEditorComposite<Feature> TermTreeEditorComposite;

        private TermType termType;

        public FeatureTreeChooserListener(TermTreeDtoEditorComposite<Feature> TermTreeEditorComposite, TermType termType) {

            super();

            this.TermTreeEditorComposite = TermTreeEditorComposite;

            this.termType = termType;

        }

        @Override

        public void widgetSelected(SelectionEvent e) {

            TermTree tree = FeatureTreeSelectionDialog.select(TermTreeEditorComposite.getDisplay().getActiveShell(), null, termType);

            if(tree!=null){

                cdmEntitySession.load(tree, true);

                TermTreeEditorComposite.setSelectedTree(tree);

            }

        }

    }

    @Override

    public void update(CdmDataChangeMap arg0) {

    }

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    @Override

    public void changed(Object element) {

        setDirty();

        characterTreeEditorComposite.getViewer().refresh();

    }

    @Override

    public void forceDirty() {

        setDirty();

    }

    @Override

    public boolean postOperation(Object objectAffectedByOperation) {

        characterTreeEditorComposite.getViewer().refresh();

        if(objectAffectedByOperation instanceof TermNode){

            StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);

            characterTreeEditorComposite.getViewer().setSelection(selection);

        }

        return true;

    }

    @Override

    public boolean onComplete() {

        return false;

    }

    @Override

    public void refresh() {

        structureViewer.refresh();

        propertyViewer.refresh();

        characterTreeEditorComposite.refresh();

    }

    @Override

    public TermNodeDto getNodeDtoForUuid(UUID nodeUuid){

        return (TermNodeDto)this.characterTreeEditorComposite.getNodeUuidMap().get(nodeUuid);

    }

    @Override

    public void addOperation(AbstractPostOperation operation) {

        operations.add(operation);

    }

    @Inject

    @Optional

    private void addSaveCandidate(@UIEventTopic(WorkbenchEventConstants.ADD_SAVE_CHARACTER) CharacterNodeDto characterNodeDto) {

        if (characterNodeDto != null){

            if (nodesToUpdate.contains(characterNodeDto)){

                nodesToUpdate.remove(characterNodeDto);

            }

            nodesToUpdate.add(characterNodeDto);

        }

    }

    @Override

    public TreeViewer getViewer() {

        return this.characterTreeEditorComposite.getViewer();

    }

    @Override

    public TermTreeDto getTreeDtoForUuid(UUID treeUuid) {

        if (this.characterTreeEditorComposite.getFeatureTree().getUuid().equals(treeUuid)){

            return this.characterTreeEditorComposite.getFeatureTree();

        }

        return null;

    }

    @Override

    public boolean checkDuplicates(UUID termUuid, UUID treeUuid) {

        for (TermDto dto: characterTreeEditorComposite.getFeatureTree().getTerms()){

            if (dto != null && dto.getUuid().equals(termUuid)){

                return true;

            }

        }

        return false;

    }

    @Override

    public void setNodeDtoForUuid(TermNodeDto node) {

        // TODO Auto-generated method stub

    }

    @Override

    public void setTreeDtoForUuid(TermTreeDto tree) {

        // TODO Auto-generated method stub

    }

}