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

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