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
  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.ui.di.Focus;
  28 import org.eclipse.e4.ui.di.Persist;
  29 import org.eclipse.e4.ui.di.UISynchronize;
  30 import org.eclipse.e4.ui.model.application.ui.MDirtyable;
  31 import org.eclipse.e4.ui.services.EMenuService;
  32 import org.eclipse.e4.ui.workbench.modeling.ESelectionService;
  33 import org.eclipse.jface.viewers.ISelection;
  34 import org.eclipse.jface.viewers.ISelectionChangedListener;
  35 import org.eclipse.jface.viewers.IStructuredSelection;
  36 import org.eclipse.jface.viewers.SelectionChangedEvent;
  37 import org.eclipse.jface.viewers.StructuredSelection;
  38 import org.eclipse.jface.viewers.TreeSelection;
  39 import org.eclipse.swt.SWT;
  40 import org.eclipse.swt.custom.SashForm;
  41 import org.eclipse.swt.dnd.Transfer;
  42 import org.eclipse.swt.events.ModifyEvent;
  43 import org.eclipse.swt.events.ModifyListener;
  44 import org.eclipse.swt.events.SelectionAdapter;
  45 import org.eclipse.swt.events.SelectionEvent;
  46 import org.eclipse.swt.layout.GridData;
  47 import org.eclipse.swt.layout.GridLayout;
  48 import org.eclipse.swt.widgets.Button;
  49 import org.eclipse.swt.widgets.Composite;
  50 import org.eclipse.swt.widgets.Display;
  51 import org.eclipse.swt.widgets.Label;
  52 import org.eclipse.swt.widgets.Text;
  53 import org.eclipse.ui.forms.widgets.FormToolkit;
  54
  55 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  56 import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
  57 import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
  58 import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
  59 import eu.etaxonomy.cdm.api.service.ITermService;
  60 import eu.etaxonomy.cdm.model.common.Representation;
  61 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  62 import eu.etaxonomy.cdm.model.description.Character;
  63 import eu.etaxonomy.cdm.model.description.FeatureNode;
  64 import eu.etaxonomy.cdm.model.description.FeatureTree;
  65 import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
  66 import eu.etaxonomy.taxeditor.editor.AppModelId;
  67 import eu.etaxonomy.taxeditor.editor.l10n.Messages;
  68 import eu.etaxonomy.taxeditor.featuretree.CharacterTransfer;
  69 import eu.etaxonomy.taxeditor.featuretree.FeatureNodeTransfer;
  70 import eu.etaxonomy.taxeditor.featuretree.e4.FeatureNodeDragListener;
  71 import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeDropAdapter;
  72 import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeEditorComposite;
  73 import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
  74 import eu.etaxonomy.taxeditor.model.IDirtyMarkable;
  75 import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;
  76 import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;
  77 import eu.etaxonomy.taxeditor.model.ImageResources;
  78 import eu.etaxonomy.taxeditor.model.MessagingUtils;
  79 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
  80 import eu.etaxonomy.taxeditor.session.ICdmEntitySession;
  81 import eu.etaxonomy.taxeditor.store.CdmStore;
  82 import eu.etaxonomy.taxeditor.ui.dialog.selection.FeatureTreeSelectionDialog;
  83 import eu.etaxonomy.taxeditor.ui.dialog.selection.TermVocabularySelectionDialog;
  84 import eu.etaxonomy.taxeditor.workbench.part.IE4ViewerPart;
  85
  86 /**
  87  * Editor for combining structure and property terms to characters.
  88  * @author pplitzner
  89  * @date 24.05.2017
  90  *
  91  */
  92 public class CharacterEditor implements IFeatureTreeEditor,IConversationEnabled, ISelectionChangedListener,
  93         ModifyListener, IE4ViewerPart, IPartContentHasDetails, IPartContentHasSupplementalData, IDirtyMarkable {
  94
  95     private FeatureTreeEditorComposite characterTreeEditorComposite;
  96     private FeatureTreeEditorComposite propertiesTreeEditorComposite;
  97     private FeatureTreeEditorComposite structuresTreeEditorComposite;
  98     private final FormToolkit formToolkit = new FormToolkit(Display.getDefault());
  99
 100     @Inject
 101     private ESelectionService selService;
 102
 103     @Inject
 104     private UISynchronize sync;
 105
 106     @Inject
 107     private MDirtyable dirty;
 108
 109     private ConversationHolder conversation;
 110
 111     private ICdmEntitySession cdmEntitySession;
 112     private Composite composite;
 113
 114     private TermVocabulary vocabulary;
 115
 116     public CharacterEditor() {
 117     }
 118
 119     /**
 120      * Create contents of the view part.
 121      */
 122     @PostConstruct
 123     public void createControls(Composite parent, EMenuService menuService ) {
 124         if (CdmStore.isActive()){
 125             if(conversation == null){
 126                 conversation = CdmStore.createConversation();
 127             }
 128             if(cdmEntitySession!=null){
 129                 cdmEntitySession = CdmStore.getCurrentSessionManager().newSession(this, true);
 130             }
 131         }
 132         else{
 133             return;
 134         }
 135         parent.setLayout(new GridLayout(1, false));
 136
 137         Composite vocChooserComposite = new Composite(parent, SWT.NONE);
 138         vocChooserComposite.setLayout(new GridLayout(3, false));
 139         vocChooserComposite.setLayoutData(new GridData(SWT.RIGHT, SWT.FILL, false, false, 2, 1));
 140         Label lblVocImport = new Label(vocChooserComposite, SWT.NONE);
 141         lblVocImport.setText("Character vocabulary");
 142         Text txtVocabulary = new Text(vocChooserComposite, SWT.NONE);
 143         Button btnChooseVoc = new Button(vocChooserComposite, SWT.PUSH);
 144         btnChooseVoc.setImage(ImageResources.getImage(ImageResources.BROWSE_ICON));
 145         btnChooseVoc.addSelectionListener(new SelectionAdapter() {
 146
 147             @Override
 148             public void widgetSelected(SelectionEvent e) {
 149                 vocabulary = TermVocabularySelectionDialog.select("Select vocabulary for characters", btnChooseVoc.getShell(), null);
 150                 if(vocabulary!=null){
 151                     txtVocabulary.setText(vocabulary.getLabel());
 152                 }
 153             }
 154         });
 155
 156         SashForm sashForm = new SashForm(parent, SWT.NONE);
 157         sashForm.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
 158         formToolkit.adapt(sashForm);
 159         formToolkit.paintBordersFor(sashForm);
 160
 161         composite = new Composite(sashForm, SWT.NONE);
 162         formToolkit.adapt(composite);
 163         formToolkit.paintBordersFor(composite);
 164         GridLayout gl_composite = new GridLayout(1, false);
 165         gl_composite.marginWidth = 0;
 166         composite.setLayout(gl_composite);
 167
 168         structuresTreeEditorComposite = addFeatureTreeEditor(composite);
 169
 170         initFeatureTreeComposite(structuresTreeEditorComposite,
 171                 new FeatureNodeDragListener(structuresTreeEditorComposite.getViewer()), null, null, null, null);
 172
 173         structuresTreeEditorComposite.getLabel_title().setText(Messages.CharacterEditor_STRUCTURES);
 174
 175         Composite composite_1 = new Composite(sashForm, SWT.NONE);
 176         formToolkit.adapt(composite_1);
 177         formToolkit.paintBordersFor(composite_1);
 178         GridLayout gl_composite_1 = new GridLayout(1, false);
 179         gl_composite_1.marginWidth = 0;
 180         composite_1.setLayout(gl_composite_1);
 181
 182         propertiesTreeEditorComposite = addFeatureTreeEditor(composite_1);
 183         initFeatureTreeComposite(propertiesTreeEditorComposite,
 184
 185                 new CharacterDragListener(structuresTreeEditorComposite.getViewer(), propertiesTreeEditorComposite.getViewer()),
 186                 null,
 187                 new Transfer[] {CharacterTransfer.getInstance()},
 188                 null,
 189                 null
 190
 191         );
 192         propertiesTreeEditorComposite.getLabel_title().setText(Messages.CharacterEditor_PROPERTIES);
 193
 194         Composite composite_3 = new Composite(sashForm, SWT.NONE);
 195         formToolkit.adapt(composite_3);
 196         formToolkit.paintBordersFor(composite_3);
 197         GridLayout gl_composite_3 = new GridLayout(2, false);
 198         gl_composite_3.marginWidth = 0;
 199         composite_3.setLayout(gl_composite_3);
 200
 201         Button btnAddCharacter = new Button(composite_3, SWT.NONE);
 202         btnAddCharacter.setText(">>"); //$NON-NLS-1$
 203         formToolkit.adapt(btnAddCharacter, true, true);
 204         btnAddCharacter.addSelectionListener(new SelectionAdapter() {
 205             @Override
 206             public void widgetSelected(SelectionEvent e) {
 207                 if(!isVocabularySet()){
 208                     return;
 209                 }
 210                 ISelection structureTreeSelection = structuresTreeEditorComposite.getViewer().getSelection();
 211                 ISelection propertyTreeSelection = propertiesTreeEditorComposite.getViewer().getSelection();
 212                 if(structureTreeSelection==null || propertyTreeSelection==null || characterTreeEditorComposite.getFeatureTree()==null){
 213                     MessagingUtils.warningDialog(Messages.CharacterEditor_CANNOT_PERFORM_TITLE, CharacterEditor.this,
 214                             Messages.CharacterEditor_CANNOT_PERFORM_MESSAGE);
 215                     return;
 216                 }
 217                 Collection<Character> characters = createCharacters((TreeSelection)structureTreeSelection, (TreeSelection)propertyTreeSelection);
 218                 for (Character character : characters) {
 219                     //add new Character to feature tree
 220                     FeatureNode parent = ((FeatureTree) characterTreeEditorComposite.getViewer().getInput()).getRoot();
 221                     vocabulary.addTerm(character);
 222                     CdmStore.getService(IFeatureNodeService.class).createChildFeatureNode(parent, character);
 223                 }
 224                 characterTreeEditorComposite.getViewer().refresh();
 225             }
 226         });
 227
 228         characterTreeEditorComposite = addFeatureTreeEditor(composite_3);
 229         initFeatureTreeComposite(characterTreeEditorComposite, new FeatureNodeDragListener(characterTreeEditorComposite.getViewer()),
 230                 new CharacterDropAdapter(this, characterTreeEditorComposite.getViewer(), sync),
 231
 232                 new Transfer[] {FeatureNodeTransfer.getInstance(), CharacterTransfer.getInstance()},
 233                 this,
 234                 this);
 235
 236         characterTreeEditorComposite.getLabel_title().setText(Messages.CharacterEditor_CHARACTERS);
 237
 238         //add context menu to character viewer
 239         menuService.registerContextMenu(characterTreeEditorComposite.getViewer().getControl(),
 240                 AppModelId.POPUPMENU_EU_ETAXONOMY_TAXEDITOR_EDITOR_POPUPMENU_CHARACTEREDITOR);
 241
 242     }
 243
 244     private FeatureTreeEditorComposite addFeatureTreeEditor(Composite composite_3) {
 245         FeatureTreeEditorComposite featureTreeEditorComposite = new FeatureTreeEditorComposite(composite_3, SWT.NONE);
 246         featureTreeEditorComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
 247         return featureTreeEditorComposite;
 248     }
 249
 250     private void initFeatureTreeComposite(
 251             FeatureTreeEditorComposite featureTreeEditorComposite,
 252             FeatureNodeDragListener featureNodeDragListener,
 253             FeatureTreeDropAdapter featureNodeDropAdapter,
 254             Transfer[] transfers,
 255             ISelectionChangedListener viewerSelectionChangedListener,
 256             ModifyListener modifyListener) {
 257
 258         featureTreeEditorComposite.init(
 259                 featureNodeDragListener,
 260                 featureNodeDropAdapter,
 261                 transfers,
 262                 viewerSelectionChangedListener,
 263                 new FeatureTreeChooserListener(featureTreeEditorComposite),
 264                 modifyListener);
 265     }
 266
 267     @Focus
 268     public void focus(){
 269         if(characterTreeEditorComposite!=null){
 270             characterTreeEditorComposite.getViewer().getControl().setFocus();
 271         }
 272         if(conversation!=null && !conversation.isBound()){
 273             conversation.bind();
 274         }
 275         if(cdmEntitySession != null) {
 276             cdmEntitySession.bind();
 277         }
 278     }
 279
 280     public static Collection<Character> createCharacters(TreeSelection structureTreeSelection, TreeSelection propertyTreeSelection){
 281         Set<Character> characters = new HashSet<>();
 282         //get selected structures and properties
 283         Iterator<FeatureNode> structureIterator = structureTreeSelection.iterator();
 284
 285         //create all combinations of structures and properties
 286         while(structureIterator.hasNext()){
 287             FeatureNode structureNode = structureIterator.next();
 288             Iterator<FeatureNode> propertiesIterator = propertyTreeSelection.iterator();
 289             while(propertiesIterator.hasNext()){
 290                 FeatureNode propertyNode = propertiesIterator.next();
 291                 Representation structureRepresentation = structureNode.getFeature().getRepresentation(PreferencesUtil.getGlobalLanguage());
 292                 Representation propertyRepresentation = propertyNode.getFeature().getRepresentation(PreferencesUtil.getGlobalLanguage());
 293                 String label = null;
 294                 String abbrevLabel = null;
 295                 if(structureRepresentation.getLabel()!=null && propertyRepresentation.getLabel()!=null){
 296                     label = structureRepresentation.getLabel()+" "+propertyRepresentation.getLabel();
 297                 }
 298                 if(structureRepresentation.getAbbreviatedLabel()!=null && propertyRepresentation.getAbbreviatedLabel()!=null){
 299                     abbrevLabel = structureRepresentation.getAbbreviatedLabel()+" "+propertyRepresentation.getAbbreviatedLabel();
 300                 }
 301                 //create new Character
 302                 Character character = Character.NewInstance(structureNode, propertyNode, null, label, abbrevLabel);
 303                 characters.add(character);
 304             }
 305         }
 306         return characters;
 307     }
 308
 309     @Override
 310     @Persist
 311     public void save(IProgressMonitor monitor){
 312         if (!conversation.isBound()) {
 313             conversation.bind();
 314         }
 315
 316         // commit the conversation and start a new transaction immediately
 317         conversation.commit(true);
 318
 319         FeatureTree featureTree = characterTreeEditorComposite.getFeatureTree();
 320         if(featureTree!=null){
 321             //save characters because they can be modified in this editor
 322             featureTree.getDistinctFeatures().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
 323         }
 324         CdmStore.getService(IFeatureTreeService.class).saveOrUpdate(featureTree);
 325
 326
 327         dirty.setDirty(false);
 328     }
 329
 330     @Override
 331     public boolean isDirty() {
 332         return dirty.isDirty();
 333     }
 334
 335     @PreDestroy
 336     public void dispose(){
 337         if(conversation!=null){
 338             conversation.close();
 339             conversation = null;
 340         }
 341         if(cdmEntitySession != null) {
 342             cdmEntitySession.dispose();
 343             cdmEntitySession = null;
 344         }
 345         dirty.setDirty(false);
 346     }
 347
 348     public boolean isVocabularySet() {
 349         if(vocabulary==null){
 350             MessagingUtils.warningDialog("Character creation not possible", this.getClass(), "Please select a vocabulary for the characters.");
 351         }
 352         return vocabulary!=null;
 353     }
 354
 355     public TermVocabulary getVocabulary() {
 356         return vocabulary;
 357     }
 358
 359     @Override
 360     public Map<Object, List<String>> getPropertyPathsMap() {
 361         List<String> propertyPaths = Arrays.asList(new String[] {
 362                 "children", //$NON-NLS-1$
 363                 "feature", //$NON-NLS-1$
 364                 "featureTree", //$NON-NLS-1$
 365         });
 366         Map<Object, List<String>> propertyPathMap =
 367                 new HashMap<Object, List<String>>();
 368         propertyPathMap.put(FeatureNode.class,propertyPaths);
 369         return propertyPathMap;
 370     }
 371
 372     @Override
 373     public List<FeatureTree> getRootEntities() {
 374         List<FeatureTree> root = new ArrayList<>();
 375         root.add(characterTreeEditorComposite.getFeatureTree());
 376         return root;
 377     }
 378
 379     @Override
 380     public ICdmEntitySession getCdmEntitySession() {
 381         return cdmEntitySession;
 382     }
 383
 384     @Focus
 385     public void setFocus() {
 386         if(conversation!=null && !conversation.isBound()){
 387             conversation.bind();
 388         }
 389     }
 390
 391     @Override
 392     public void selectionChanged(SelectionChangedEvent event) {
 393         //propagate selection
 394         selService.setSelection(event.getSelection());
 395     }
 396
 397
 398     @Override
 399     public void modifyText(ModifyEvent e) {
 400         characterTreeEditorComposite.getFeatureTree().setTitleCache(((Text) e.widget).getText(), true);
 401         setDirty();
 402     }
 403
 404
 405     private void setDirty() {
 406         dirty.setDirty(true);
 407     }
 408
 409     @Override
 410     public IStructuredSelection getSelection() {
 411         return (IStructuredSelection) characterTreeEditorComposite.getViewer().getSelection();
 412     }
 413
 414     public FeatureTree getCharacterTree(){
 415         return characterTreeEditorComposite.getFeatureTree();
 416     }
 417
 418     @Override
 419     public void refresh(){
 420         structuresTreeEditorComposite.getViewer().refresh();
 421         propertiesTreeEditorComposite.getViewer().refresh();
 422         characterTreeEditorComposite.getViewer().refresh();
 423     }
 424
 425     private class FeatureTreeChooserListener extends SelectionAdapter{
 426         FeatureTreeEditorComposite featureTreeEditorComposite;
 427
 428         public FeatureTreeChooserListener(FeatureTreeEditorComposite featureTreeEditorComposite) {
 429             super();
 430             this.featureTreeEditorComposite = featureTreeEditorComposite;
 431         }
 432
 433         @Override
 434         public void widgetSelected(SelectionEvent e) {
 435             FeatureTree tree = FeatureTreeSelectionDialog.select(featureTreeEditorComposite.getDisplay().getActiveShell(), //conversation,
 436                     null);
 437             if(tree!=null){
 438                 featureTreeEditorComposite.setSelectedTree(tree);
 439                 featureTreeEditorComposite.getText_title().setEnabled(false);
 440             }
 441         }
 442     }
 443
 444     @Override
 445     public void update(CdmDataChangeMap arg0) {
 446     }
 447
 448     @Override
 449     public ConversationHolder getConversationHolder() {
 450         return conversation;
 451     }
 452
 453     @Override
 454     public void changed(Object element) {
 455         setDirty();
 456     }
 457
 458     @Override
 459     public void forceDirty() {
 460         setDirty();
 461     }
 462
 463     @Override
 464     public boolean postOperation(Object objectAffectedByOperation) {
 465         characterTreeEditorComposite.getViewer().refresh();
 466         if(objectAffectedByOperation instanceof FeatureNode){
 467             StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);
 468             characterTreeEditorComposite.getViewer().setSelection(selection);
 469         }
 470         return true;
 471     }
 472
 473     @Override
 474     public boolean onComplete() {
 475         return false;
 476     }
 477
 478 }