eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/character/CharacterEditor.java

   1 /**
   2 * Copyright (C) 2017 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9 package eu.etaxonomy.taxeditor.editor.descriptiveDataSet.character;
  10
  11 import java.util.ArrayList;
  12 import java.util.Arrays;
  13 import java.util.Collection;
  14 import java.util.HashMap;
  15 import java.util.HashSet;
  16 import java.util.Iterator;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Set;
  20 import java.util.UUID;
  21
  22 import javax.annotation.PostConstruct;
  23 import javax.annotation.PreDestroy;
  24 import javax.inject.Inject;
  25
  26 import org.eclipse.core.runtime.IProgressMonitor;
  27 import org.eclipse.e4.core.di.annotations.Optional;
  28 import org.eclipse.e4.ui.di.Focus;
  29 import org.eclipse.e4.ui.di.Persist;
  30 import org.eclipse.e4.ui.di.UIEventTopic;
  31 import org.eclipse.e4.ui.di.UISynchronize;
  32 import org.eclipse.e4.ui.model.application.ui.MDirtyable;
  33 import org.eclipse.e4.ui.services.EMenuService;
  34 import org.eclipse.e4.ui.workbench.modeling.ESelectionService;
  35 import org.eclipse.jface.viewers.ISelection;
  36 import org.eclipse.jface.viewers.ISelectionChangedListener;
  37 import org.eclipse.jface.viewers.IStructuredSelection;
  38 import org.eclipse.jface.viewers.SelectionChangedEvent;
  39 import org.eclipse.jface.viewers.StructuredSelection;
  40 import org.eclipse.jface.viewers.TreeSelection;
  41 import org.eclipse.jface.viewers.TreeViewer;
  42 import org.eclipse.swt.SWT;
  43 import org.eclipse.swt.custom.SashForm;
  44 import org.eclipse.swt.dnd.DND;
  45 import org.eclipse.swt.dnd.Transfer;
  46 import org.eclipse.swt.events.ModifyEvent;
  47 import org.eclipse.swt.events.ModifyListener;
  48 import org.eclipse.swt.events.SelectionAdapter;
  49 import org.eclipse.swt.events.SelectionEvent;
  50 import org.eclipse.swt.layout.GridData;
  51 import org.eclipse.swt.layout.GridLayout;
  52 import org.eclipse.swt.widgets.Button;
  53 import org.eclipse.swt.widgets.Composite;
  54 import org.eclipse.swt.widgets.Display;
  55 import org.eclipse.swt.widgets.Label;
  56 import org.eclipse.swt.widgets.Text;
  57 import org.eclipse.ui.forms.widgets.FormToolkit;
  58
  59 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  60 import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
  61 import eu.etaxonomy.cdm.api.service.ITermNodeService;
  62 import eu.etaxonomy.cdm.api.service.ITermTreeService;
  63 import eu.etaxonomy.cdm.api.service.IVocabularyService;
  64 import eu.etaxonomy.cdm.api.service.UpdateResult;
  65 import eu.etaxonomy.cdm.model.common.Language;
  66 import eu.etaxonomy.cdm.model.description.Character;
  67 import eu.etaxonomy.cdm.model.description.Feature;
  68 import eu.etaxonomy.cdm.model.term.DefinedTerm;
  69 import eu.etaxonomy.cdm.model.term.DefinedTermBase;
  70 import eu.etaxonomy.cdm.model.term.Representation;
  71 import eu.etaxonomy.cdm.model.term.TermNode;
  72 import eu.etaxonomy.cdm.model.term.TermTree;
  73 import eu.etaxonomy.cdm.model.term.TermType;
  74 import eu.etaxonomy.cdm.model.term.TermVocabulary;
  75 import eu.etaxonomy.cdm.model.term.VocabularyEnum;
  76 import eu.etaxonomy.cdm.persistence.dto.CharacterDto;
  77 import eu.etaxonomy.cdm.persistence.dto.CharacterNodeDto;
  78 import eu.etaxonomy.cdm.persistence.dto.TermDto;
  79 import eu.etaxonomy.cdm.persistence.dto.TermNodeDto;
  80 import eu.etaxonomy.cdm.persistence.dto.TermTreeDto;
  81 import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
  82 import eu.etaxonomy.taxeditor.editor.AppModelId;
  83 import eu.etaxonomy.taxeditor.editor.definedterm.FeatureTreeViewerComparator;
  84 import eu.etaxonomy.taxeditor.editor.l10n.Messages;
  85 import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;
  86 import eu.etaxonomy.taxeditor.featuretree.CharacterTransfer;
  87 import eu.etaxonomy.taxeditor.featuretree.TermTreeContentProvider;
  88 import eu.etaxonomy.taxeditor.featuretree.TermTreeLabelProvider;
  89 import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeDtoEditorComposite;
  90 import eu.etaxonomy.taxeditor.featuretree.e4.ICharacterEditor;
  91 import eu.etaxonomy.taxeditor.featuretree.e4.TermNodeDtoDragListener;
  92 import eu.etaxonomy.taxeditor.featuretree.e4.TermTreeDtoDropAdapter;
  93 import eu.etaxonomy.taxeditor.featuretree.e4.TermTreeEditor;
  94 import eu.etaxonomy.taxeditor.model.AbstractUtility;
  95 import eu.etaxonomy.taxeditor.model.IDirtyMarkable;
  96 import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;
  97 import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;
  98 import eu.etaxonomy.taxeditor.model.ImageResources;
  99 import eu.etaxonomy.taxeditor.model.MessagingUtils;
 100 import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
 101 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
 102 import eu.etaxonomy.taxeditor.session.ICdmEntitySession;
 103 import eu.etaxonomy.taxeditor.store.CdmStore;
 104 import eu.etaxonomy.taxeditor.store.StoreUtil;
 105 import eu.etaxonomy.taxeditor.ui.dialog.selection.FeatureTreeSelectionDialog;
 106 import eu.etaxonomy.taxeditor.ui.dialog.selection.TermVocabularySelectionDialog;
 107 import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;
 108 import eu.etaxonomy.taxeditor.workbench.part.IE4ViewerPart;
 109
 110 /**
 111  * Editor for combining structure and property terms to characters.
 112  * @author pplitzner
 113  * @date 24.05.2017
 114  */
 115 public class CharacterEditor implements ICharacterEditor, IConversationEnabled, ISelectionChangedListener,
 116         ModifyListener, IE4ViewerPart, IPartContentHasDetails, IPartContentHasSupplementalData,
 117         IDirtyMarkable, IE4SavablePart {
 118
 119     private FeatureTreeDtoEditorComposite characterTreeEditorComposite;
 120     private final FormToolkit formToolkit = new FormToolkit(Display.getDefault());
 121
 122     @Inject
 123     private ESelectionService selService;
 124
 125     @Inject
 126     private UISynchronize sync;
 127
 128     @Inject
 129     private MDirtyable dirty;
 130
 131     private ConversationHolder conversation;
 132
 133     private ICdmEntitySession cdmEntitySession;
 134
 135     private TermVocabulary vocabulary;
 136     private TreeViewer structureViewer;
 137     private TreeViewer propertyViewer;
 138
 139     private List<AbstractPostOperation> operations = new ArrayList<>();
 140
 141     private List<CharacterNodeDto> nodesToUpdate = new ArrayList<>();
 142
 143     private Map<Character, CharacterNodeDto> nodesToSave = new HashMap<>();
 144
 145     public CharacterEditor() {
 146     }
 147
 148     /**
 149      * Create contents of the view part.
 150      */
 151     @PostConstruct
 152     public void createControls(Composite parent, EMenuService menuService ) {
 153         if (CdmStore.isActive()){
 154             if(conversation == null){
 155                 conversation = CdmStore.createConversation();
 156             }
 157             if(cdmEntitySession==null){
 158                 cdmEntitySession = CdmStore.getCurrentSessionManager().newSession(this, true);
 159             }
 160         }
 161         else{
 162             return;
 163         }
 164         parent.setLayout(new GridLayout(1, false));
 165
 166         Composite vocChooserComposite = new Composite(parent, SWT.NONE);
 167         vocChooserComposite.setLayout(new GridLayout(4, false));
 168         vocChooserComposite.setLayoutData(new GridData(SWT.RIGHT, SWT.FILL, false, false, 2, 1));
 169         Label lblVocImport = new Label(vocChooserComposite, SWT.NONE);
 170         lblVocImport.setText("Character vocabulary:");
 171         Text txtVocabulary = new Text(vocChooserComposite, SWT.NONE);
 172         txtVocabulary.setEditable(false);
 173         Button btnChooseVoc = new Button(vocChooserComposite, SWT.PUSH);
 174         btnChooseVoc.setImage(ImageResources.getImage(ImageResources.BROWSE_ICON));
 175         btnChooseVoc.addSelectionListener(new SelectionAdapter() {
 176
 177             @Override
 178             public void widgetSelected(SelectionEvent e) {
 179                 // hard-coded filter for "built-in" vocabularies Feature and Name Feature
 180                 Set<TermVocabulary> vocabulariesToBeFiltered = new HashSet<>();
 181                 vocabulariesToBeFiltered.add(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.Feature.getUuid()));
 182                 vocabulariesToBeFiltered.add(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()));
 183                 if(vocabulary!=null){
 184                     vocabulariesToBeFiltered.add(vocabulary);
 185                 }
 186                 vocabulary = TermVocabularySelectionDialog.select("Select vocabulary for characters", btnChooseVoc.getShell(), vocabulariesToBeFiltered, TermType.Character);
 187                 if(vocabulary!=null){
 188                     txtVocabulary.setText(vocabulary.getLabel());
 189                 }
 190             }
 191         });
 192
 193         SashForm sashForm = new SashForm(parent, SWT.NONE);
 194         sashForm.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
 195         formToolkit.adapt(sashForm);
 196         formToolkit.paintBordersFor(sashForm);
 197
 198         Composite composite = new Composite(sashForm, SWT.NONE);
 199         formToolkit.adapt(composite);
 200         formToolkit.paintBordersFor(composite);
 201         GridLayout gl_composite = new GridLayout(1, false);
 202         gl_composite.marginWidth = 0;
 203         composite.setLayout(gl_composite);
 204
 205         structureViewer = createTreeViewer(composite, TermType.Structure, Messages.CharacterEditor_STRUCTURES);
 206
 207         Composite composite_1 = new Composite(sashForm, SWT.NONE);
 208         formToolkit.adapt(composite_1);
 209         formToolkit.paintBordersFor(composite_1);
 210         GridLayout gl_composite_1 = new GridLayout(1, false);
 211         gl_composite_1.marginWidth = 0;
 212         composite_1.setLayout(gl_composite_1);
 213
 214         propertyViewer = createTreeViewer(composite_1, TermType.Property, Messages.CharacterEditor_PROPERTIES);
 215
 216         int ops = DND.DROP_COPY | DND.DROP_MOVE;
 217         Transfer[] transfers = new Transfer[] {CharacterTransfer.getInstance()};
 218         propertyViewer.addDragSupport(ops, transfers, new CharacterDragListener(structureViewer, propertyViewer));
 219
 220         Composite composite_3 = new Composite(sashForm, SWT.NONE);
 221         formToolkit.adapt(composite_3);
 222         formToolkit.paintBordersFor(composite_3);
 223         GridLayout gl_composite_3 = new GridLayout(2, false);
 224         gl_composite_3.marginWidth = 0;
 225         composite_3.setLayout(gl_composite_3);
 226
 227         Button btnAddCharacter = new Button(composite_3, SWT.NONE);
 228         btnAddCharacter.setText(">>"); //$NON-NLS-1$
 229         formToolkit.adapt(btnAddCharacter, true, true);
 230         btnAddCharacter.addSelectionListener(new SelectionAdapter() {
 231             @Override
 232             public void widgetSelected(SelectionEvent e) {
 233                 if(!isVocabularySet()){
 234                     return;
 235                 }
 236                 if (confirmSaveDirty()){
 237                     return;
 238                 }
 239                 ISelection structureTreeSelection = structureViewer.getSelection();
 240                 ISelection propertyTreeSelection = propertyViewer.getSelection();
 241                 if(structureTreeSelection==null || propertyTreeSelection==null || characterTreeEditorComposite.getFeatureTree()==null){
 242                     MessagingUtils.warningDialog(Messages.CharacterEditor_CANNOT_PERFORM_TITLE, CharacterEditor.this,
 243                             Messages.CharacterEditor_CANNOT_PERFORM_MESSAGE);
 244                     return;
 245                 }
 246                 Collection<Character> characters = createCharacters((TreeSelection)structureTreeSelection, (TreeSelection)propertyTreeSelection);
 247                 TermNodeDto parent = characterTreeEditorComposite.getFeatureTree().getRoot();
 248                 UpdateResult result = null;
 249                 TermTree tree = null;
 250                 for (Character character : characters) {
 251                     //add new Character to feature tree
 252                     CharacterNodeDto nodeDto = new CharacterNodeDto(CharacterDto.fromCharacter(character), parent, 0, parent.getTree(), null, null, null);
 253                     nodesToSave.put(character, nodeDto);
 254                     setDirty();
 255                     //                    result = CdmStore.getService(IFeatureNodeService.class).createChildFeatureNode(parent.getUuid(), character, vocabulary.getUuid());
 256
 257                 }
 258                 if (tree != null){
 259                     characterTreeEditorComposite.setSelectedTree(tree);
 260                 }
 261
 262                 refresh();
 263             }
 264         });
 265
 266         characterTreeEditorComposite = addFeatureTreeEditor(composite_3);
 267         initFeatureTreeComposite(TermType.Character, characterTreeEditorComposite, new TermNodeDtoDragListener(characterTreeEditorComposite.getViewer()),
 268                 new TermTreeDtoDropAdapter(this, characterTreeEditorComposite.getViewer(), sync),
 269                 null);
 270
 271         characterTreeEditorComposite.getLabel_title().setText(Messages.CharacterEditor_CHARACTERS);
 272
 273         //add context menu to character viewer
 274         menuService.registerContextMenu(characterTreeEditorComposite.getViewer().getControl(),
 275                 AppModelId.POPUPMENU_EU_ETAXONOMY_TAXEDITOR_EDITOR_POPUPMENU_CHARACTEREDITOR);
 276
 277     }
 278
 279     private TreeViewer createTreeViewer(Composite parent, TermType termType, String labelString) {
 280         Composite composite = new Composite(parent, SWT.NONE);
 281         composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
 282         composite.setLayout(new GridLayout(2, false));
 283         Label label = new Label(composite, SWT.NONE);
 284         label.setText(labelString);
 285         Button btnRefresh = new Button(composite, SWT.PUSH);
 286         btnRefresh.setImage(ImageResources.getImage(ImageResources.REFRESH));
 287         btnRefresh.setToolTipText("Refresh");
 288
 289
 290         TreeViewer viewer = new TreeViewer(composite);
 291         viewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));
 292         viewer.setContentProvider(new TermTreeContentProvider());
 293         viewer.setLabelProvider(new TermTreeLabelProvider());
 294         viewer.setComparator(new FeatureTreeViewerComparator());
 295         viewer.addSelectionChangedListener(this);
 296         viewer.setInput(CdmStore.getService(ITermTreeService.class).list(termType, null, null, null, TermTreeEditor.TREE_PROPERTY_PATH));
 297         btnRefresh.addSelectionListener(new SelectionAdapter() {
 298
 299             @Override
 300             public void widgetSelected(SelectionEvent e) {
 301                 viewer.setInput(CdmStore.getService(ITermTreeService.class).list(termType, null, null, null, TermTreeEditor.TREE_PROPERTY_PATH));
 302                 refresh(viewer);
 303             }
 304         });
 305         return viewer;
 306     }
 307
 308     private <T extends DefinedTermBase> FeatureTreeDtoEditorComposite<T> addFeatureTreeEditor(Composite composite_3) {
 309         FeatureTreeDtoEditorComposite<T> TermTreeEditorComposite = new FeatureTreeDtoEditorComposite<>(composite_3, SWT.NONE);
 310         TermTreeEditorComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
 311         return TermTreeEditorComposite;
 312     }
 313
 314     private void initFeatureTreeComposite(
 315             TermType termType,
 316             FeatureTreeDtoEditorComposite TermTreeEditorComposite,
 317             TermNodeDtoDragListener featureNodeDragListener,
 318             TermTreeDtoDropAdapter featureNodeDropAdapter,
 319             Transfer[] transfers) {
 320
 321         TermTreeEditorComposite.init(
 322                 featureNodeDragListener,
 323                 featureNodeDropAdapter,
 324                 transfers,
 325                 this,
 326                 new FeatureTreeChooserListener(TermTreeEditorComposite, termType),
 327                 this);
 328     }
 329
 330     @Focus
 331     public void focus(){
 332         if(characterTreeEditorComposite!=null){
 333             characterTreeEditorComposite.getViewer().getControl().setFocus();
 334         }
 335         if(conversation!=null && !conversation.isBound()){
 336             conversation.bind();
 337         }
 338         if(cdmEntitySession != null) {
 339             cdmEntitySession.bind();
 340         }
 341     }
 342
 343     public static Collection<Character> createCharacters(TreeSelection structureTreeSelection, TreeSelection propertyTreeSelection){
 344         Set<Character> characters = new HashSet<>();
 345         //get selected structures and properties
 346         Iterator<TermNode<DefinedTerm>> structureIterator = structureTreeSelection.iterator();
 347
 348         //create all combinations of structures and properties
 349         while(structureIterator.hasNext()){
 350             TermNode<DefinedTerm> structureNode = structureIterator.next();
 351             Iterator<TermNode<DefinedTerm>> propertiesIterator = propertyTreeSelection.iterator();
 352             while(propertiesIterator.hasNext()){
 353                 TermNode<DefinedTerm> propertyNode = propertiesIterator.next();
 354                 Representation structureRepresentation = structureNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());
 355                 if(structureRepresentation==null){
 356                     structureRepresentation = structureNode.getTerm().getRepresentation(Language.DEFAULT());
 357                 }
 358                 Representation propertyRepresentation = propertyNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());
 359                 if(propertyRepresentation==null){
 360                     propertyRepresentation = propertyNode.getTerm().getRepresentation(Language.DEFAULT());
 361                 }
 362                 String label = null;
 363                 String abbrevLabel = null;
 364                 if(structureRepresentation!=null && propertyRepresentation!=null){
 365                     if(structureRepresentation.getLabel()!=null && propertyRepresentation.getLabel()!=null){
 366                         label = structureRepresentation.getLabel()+" "+propertyRepresentation.getLabel();
 367                     }
 368                     if(structureRepresentation.getAbbreviatedLabel()!=null && propertyRepresentation.getAbbreviatedLabel()!=null){
 369                         abbrevLabel = structureRepresentation.getAbbreviatedLabel()+" "+propertyRepresentation.getAbbreviatedLabel();
 370                     }
 371                 }
 372                 if(label!=null){
 373                     //default label
 374                     label = structureNode.getTerm().getLabel()+" "+propertyNode.getTerm().getLabel();
 375                 }
 376                 Character character = Character.NewInstance(structureNode, propertyNode, null, label, abbrevLabel);
 377                 characters.add(character);
 378
 379             }
 380         }
 381         return characters;
 382     }
 383
 384     @Override
 385     @Persist
 386     public void save(IProgressMonitor monitor){
 387         if (!conversation.isBound()) {
 388             conversation.bind();
 389         }
 390         UpdateResult result = new UpdateResult();
 391         if (nodesToSave != null && this.getVocabulary() != null) {
 392             result.includeResult(CdmStore.getService(ITermNodeService.class).saveNewCharacterNodeDtoMap(this.nodesToSave, this.getVocabulary().getUuid()));
 393         }
 394         nodesToSave.clear();
 395         TermTreeDto featureTree = characterTreeEditorComposite.getFeatureTree();
 396         if (operations != null && !operations.isEmpty()){
 397             for (AbstractPostOperation<TermNode> operation: operations){
 398                 AbstractUtility.executeOperation(operation, sync);
 399             }
 400             operations.clear();
 401         }
 402
 403 //      TODO: implement update method for dto
 404
 405         result.includeResult(CdmStore.getService(ITermNodeService.class).saveCharacterNodeDtoList(this.nodesToUpdate));
 406         nodesToUpdate.clear();
 407         // commit the conversation and start a new transaction immediately
 408         conversation.commit(true);
 409         if (result.getUpdatedObjects() != null && !result.getUpdatedObjects().isEmpty()){
 410             Object o = result.getUpdatedObjects().iterator().next();
 411             if (o instanceof TermNode){
 412                 TermNode node = (TermNode)o;
 413                 TermTree updateTree = (TermTree)node.getGraph();
 414                 if (updateTree != null){
 415                     characterTreeEditorComposite.setSelectedTree(updateTree);
 416                 }
 417             }
 418
 419         }
 420
 421 //        initializeTrees();
 422
 423         dirty.setDirty(false);
 424     }
 425
 426     private void initializeTrees() {
 427         Object[] expandedElements = characterTreeEditorComposite.getViewer().getExpandedElements();
 428         characterTreeEditorComposite.getViewer().getTree().removeAll();
 429         characterTreeEditorComposite.getViewer().setExpandedElements(expandedElements);
 430     }
 431
 432     @Override
 433     public boolean isDirty() {
 434         return dirty.isDirty();
 435     }
 436
 437     @PreDestroy
 438     public void dispose(){
 439         if(conversation!=null){
 440             conversation.close();
 441             conversation = null;
 442         }
 443         if(cdmEntitySession != null) {
 444             cdmEntitySession.dispose();
 445             cdmEntitySession = null;
 446         }
 447         dirty.setDirty(false);
 448     }
 449
 450     public boolean isVocabularySet() {
 451         if(vocabulary==null){
 452             MessagingUtils.warningDialog("Character creation not possible", this.getClass(), "Please select a vocabulary for the characters.");
 453         }
 454         return vocabulary!=null;
 455     }
 456
 457     public boolean confirmSaveDirty(){
 458         return StoreUtil.promptCheckIsDirty(this);
 459     }
 460
 461     public TermVocabulary getVocabulary() {
 462         return vocabulary;
 463     }
 464
 465     @Override
 466     public Map<Object, List<String>> getPropertyPathsMap() {
 467         List<String> propertyPaths = Arrays.asList(new String[] {
 468                 "children", //$NON-NLS-1$
 469                 "feature", //$NON-NLS-1$
 470                 "featureTree", //$NON-NLS-1$
 471         });
 472         Map<Object, List<String>> propertyPathMap =
 473                 new HashMap<Object, List<String>>();
 474         propertyPathMap.put(TermNode.class,propertyPaths);
 475         return propertyPathMap;
 476     }
 477
 478     @Override
 479     public List<TermTreeDto> getRootEntities() {
 480         List<TermTreeDto> root = new ArrayList<>();
 481         root.add(characterTreeEditorComposite.getFeatureTree());
 482         return root;
 483     }
 484
 485     @Override
 486     public ICdmEntitySession getCdmEntitySession() {
 487         return cdmEntitySession;
 488     }
 489
 490
 491     @Focus
 492     public void setFocus() {
 493         if(conversation!=null && !conversation.isBound()){
 494             conversation.bind();
 495         }
 496     }
 497
 498     @Override
 499     public void selectionChanged(SelectionChangedEvent event) {
 500         //propagate selection
 501         selService.setSelection(event.getSelection());
 502     }
 503
 504
 505     @Override
 506     public void modifyText(ModifyEvent e) {
 507         characterTreeEditorComposite.getFeatureTree().setTitleCache(((Text) e.widget).getText());
 508         setDirty();
 509     }
 510
 511
 512
 513     @Override
 514     public void setDirty() {
 515         dirty.setDirty(true);
 516     }
 517
 518     @Override
 519     public IStructuredSelection getSelection() {
 520         return (IStructuredSelection) characterTreeEditorComposite.getViewer().getSelection();
 521     }
 522
 523
 524     @Override
 525     public TermType getTermType() {
 526         return TermType.Character;
 527     }
 528
 529     public TermTreeDto getCharacterTree(){
 530         return characterTreeEditorComposite.getFeatureTree();
 531     }
 532
 533
 534     public void refresh(TreeViewer viewer){
 535         viewer.refresh();
 536
 537         characterTreeEditorComposite.getViewer().setInput(characterTreeEditorComposite.getViewer().getInput());
 538     }
 539
 540     private class FeatureTreeChooserListener extends SelectionAdapter{
 541         private FeatureTreeDtoEditorComposite<Feature> TermTreeEditorComposite;
 542         private TermType termType;
 543
 544         public FeatureTreeChooserListener(FeatureTreeDtoEditorComposite<Feature> TermTreeEditorComposite, TermType termType) {
 545             super();
 546             this.TermTreeEditorComposite = TermTreeEditorComposite;
 547             this.termType = termType;
 548         }
 549
 550         @Override
 551         public void widgetSelected(SelectionEvent e) {
 552             TermTree tree = FeatureTreeSelectionDialog.select(TermTreeEditorComposite.getDisplay().getActiveShell(), null, termType);
 553             if(tree!=null){
 554                 cdmEntitySession.load(tree, true);
 555                 TermTreeEditorComposite.setSelectedTree(tree);
 556             }
 557         }
 558     }
 559
 560     @Override
 561     public void update(CdmDataChangeMap arg0) {
 562     }
 563
 564     @Override
 565     public ConversationHolder getConversationHolder() {
 566         return conversation;
 567     }
 568
 569     @Override
 570     public void changed(Object element) {
 571         setDirty();
 572         characterTreeEditorComposite.getViewer().refresh();
 573     }
 574
 575     @Override
 576     public void forceDirty() {
 577         setDirty();
 578     }
 579
 580     @Override
 581     public boolean postOperation(Object objectAffectedByOperation) {
 582         characterTreeEditorComposite.getViewer().refresh();
 583         if(objectAffectedByOperation instanceof TermNode){
 584             StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);
 585             characterTreeEditorComposite.getViewer().setSelection(selection);
 586         }
 587         return true;
 588     }
 589
 590     @Override
 591     public boolean onComplete() {
 592         return false;
 593     }
 594
 595     @Override
 596     public void refresh() {
 597         structureViewer.refresh();
 598         propertyViewer.refresh();
 599         characterTreeEditorComposite.refresh();
 600
 601     }
 602
 603     @Override
 604     public TermNodeDto getNodeDtoForUuid(UUID nodeUuid){
 605         return (TermNodeDto)this.characterTreeEditorComposite.getNodeUuidMap().get(nodeUuid);
 606
 607     }
 608
 609     @Override
 610     public void addOperation(AbstractPostOperation operation) {
 611         operations.add(operation);
 612
 613     }
 614
 615     @Inject
 616     @Optional
 617     private void addSaveCandidate(@UIEventTopic(WorkbenchEventConstants.ADD_SAVE_CHARACTER) CharacterNodeDto characterNodeDto) {
 618
 619         if (characterNodeDto != null){
 620             if (nodesToUpdate.contains(characterNodeDto)){
 621                 nodesToUpdate.remove(characterNodeDto);
 622             }
 623             nodesToUpdate.add(characterNodeDto);
 624         }
 625
 626     }
 627
 628     @Override
 629     public TreeViewer getViewer() {
 630         return this.characterTreeEditorComposite.getViewer();
 631     }
 632
 633     @Override
 634     public TermTreeDto getTreeDtoForUuid(UUID treeUuid) {
 635         if (this.characterTreeEditorComposite.getFeatureTree().getUuid().equals(treeUuid)){
 636             return this.characterTreeEditorComposite.getFeatureTree();
 637         }
 638         return null;
 639     }
 640
 641     @Override
 642     public boolean checkDuplicates(UUID termUuid, UUID treeUuid) {
 643         for (TermDto dto: characterTreeEditorComposite.getFeatureTree().getTerms()){
 644             if (dto != null && dto.getUuid().equals(termUuid)){
 645                 return true;
 646             }
 647         }
 648         return false;
 649     }
 650
 651     @Override
 652     public void setNodeDtoForUuid(TermNodeDto node) {
 653         // TODO Auto-generated method stub
 654
 655     }
 656
 657     @Override
 658     public void setTreeDtoForUuid(TermTreeDto tree) {
 659         // TODO Auto-generated method stub
 660
 661     }
 662
 663
 664
 665
 666 }