eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/editor/name/TaxonNameEditor.java

   1 /**
   2 * Copyright (C) 2007 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
  10 package eu.etaxonomy.taxeditor.editor.name;
  11
  12 import java.beans.PropertyChangeEvent;
  13 import java.beans.PropertyChangeListener;
  14 import java.util.Set;
  15
  16 import org.apache.log4j.Logger;
  17 import org.eclipse.core.commands.operations.IUndoContext;
  18 import org.eclipse.core.commands.operations.IUndoableOperation;
  19 import org.eclipse.core.runtime.IProgressMonitor;
  20 import org.eclipse.swt.dnd.DND;
  21 import org.eclipse.swt.dnd.DropTarget;
  22 import org.eclipse.swt.dnd.DropTargetAdapter;
  23 import org.eclipse.swt.dnd.DropTargetEvent;
  24 import org.eclipse.swt.dnd.Transfer;
  25 import org.eclipse.swt.widgets.Composite;
  26 import org.eclipse.swt.widgets.Event;
  27 import org.eclipse.swt.widgets.Listener;
  28 import org.eclipse.ui.IEditorInput;
  29 import org.eclipse.ui.IEditorSite;
  30 import org.eclipse.ui.PartInitException;
  31
  32 import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
  33 import eu.etaxonomy.cdm.model.taxon.Synonym;
  34 import eu.etaxonomy.cdm.model.taxon.Taxon;
  35 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  36 import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
  37 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  38 import eu.etaxonomy.taxeditor.ITaxEditorConstants;
  39 import eu.etaxonomy.taxeditor.actions.WidgetTransfer;
  40 import eu.etaxonomy.taxeditor.controller.EditorController;
  41 import eu.etaxonomy.taxeditor.controller.GlobalController;
  42 import eu.etaxonomy.taxeditor.editor.AbstractTaxonEditor;
  43 import eu.etaxonomy.taxeditor.editor.FreeTextElementFactory;
  44 import eu.etaxonomy.taxeditor.editor.GroupedComposite;
  45 import eu.etaxonomy.taxeditor.operations.name.ChangeHomotypicGroupOperation;
  46 import eu.etaxonomy.taxeditor.operations.name.ChangeMisappliedNameToSynonymOperation;
  47
  48 /**
  49  * @author p.ciardelli
  50  * @created 15.05.2008
  51  * @version 1.0
  52  */
  53 public class TaxonNameEditor extends AbstractTaxonEditor
  54                 implements INameEditorCompositeRepository {
  55         private static final Logger logger = Logger.getLogger(TaxonNameEditor.class);
  56
  57         /**
  58          * Shared listener that sets dirty state to true
  59          *  when any registered property changes
  60          */
  61         private PropertyChangeListener taxonChangeListener = new PropertyChangeListener() {
  62                 public void propertyChange(PropertyChangeEvent event) {
  63                         if (event.getPropertyName().equals(ITaxEditorConstants.PROPERTY_SHEET_CHANGE)) {
  64                                 firePropertyChange(PROP_DIRTY);
  65                         }
  66                 }
  67         };
  68
  69         @Override
  70         public void doSave(IProgressMonitor monitor) {}
  71
  72         @Override
  73         public void doSaveAs() {}
  74
  75         @Override
  76         public void init(IEditorSite site, IEditorInput input)
  77                         throws PartInitException {
  78
  79                 super.init(site, input);
  80
  81                 Taxon taxon = getTaxon();
  82                 EditorController.addNameEditor(taxon, this);
  83
  84                 // Register listeners for any change in accepted name or set of relations
  85                 taxon.getName().addPropertyChangeListener(taxonChangeListener);
  86                 taxon.addPropertyChangeListener(taxonChangeListener);
  87         }
  88
  89         @Override
  90         public boolean isDirty() {
  91                 return false;
  92         }
  93
  94         @Override
  95         public boolean isSaveAsAllowed() {
  96                 return false;
  97         }
  98
  99         @Override
 100         protected void createManagedForm(Composite composite) {
 101
 102                 super.createManagedForm(composite);
 103
 104                 Taxon taxon = getTaxon();
 105
 106                 firstGroupedComposite = (NameComposite) FreeTextElementFactory.getDefault().
 107                                 createAcceptedTaxon(managedForm, taxon);
 108
 109                 // Draw synonym and misapplied name elements
 110                 for (TaxonBase taxonBase : new IterableSynonymyList(taxon)) {
 111                         if (taxonBase instanceof Synonym) {
 112                                 FreeTextElementFactory.getDefault().createSynonym(taxon, (Synonym) taxonBase);
 113                         } else {
 114                                 FreeTextElementFactory.getDefault().createMisappliedName(taxon, (Taxon) taxonBase);
 115                         }
 116                 }
 117
 118                 // Draw concept relation elements
 119                 Set<TaxonRelationship> taxonRelations = taxon.getTaxonRelations();
 120                 for (TaxonRelationship relationship : taxonRelations) {
 121
 122                         if (relationship.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR()) ||
 123                                         relationship.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())) {
 124                                 continue;
 125                         }
 126
 127                         FreeTextElementFactory.getDefault().createConcept(taxon, relationship);
 128                 }
 129
 130                 // Listen for names being dragged outside of existing homotypic groups -
 131                 //  user wants to create a new group
 132                 Transfer[] types = new Transfer[] {WidgetTransfer.getInstance()};
 133                 int operations = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_DEFAULT;
 134                 DropTarget target = new DropTarget(parent, operations);
 135                 target.setTransfer(types);
 136                 target.addDropListener(new DropTargetAdapter() {
 137
 138                         public void drop(DropTargetEvent event) {
 139
 140                                 if (event.data instanceof GroupedComposite) {
 141                                         final GroupedComposite composite = (GroupedComposite) event.data;
 142                                         if (composite.getDragSource() != null) {
 143
 144                                                         // Execute operations at end of drag event
 145                                                         composite.getDragSource().addListener(DND.DragEnd, new Listener() {
 146
 147                                                                 public void handleEvent(Event event) {
 148                                                                         IUndoContext undoContext = EditorController.getUndoContext(getTaxon());
 149                                                                         IUndoableOperation operation = null;
 150
 151                                                                         // Synonym being dropped
 152                                                                         if(composite instanceof SynonymComposite){
 153                                                                                 Synonym synonym = ((SynonymComposite)composite).getSynonym();
 154                                                                                 operation = new ChangeHomotypicGroupOperation
 155                                                                                                 ("change type", undoContext,
 156                                                                                                                 getTaxon(), synonym, HomotypicalGroup.NewInstance());
 157                                                                         }
 158
 159                                                                         // Misapplied name being dropped
 160                                                                         if(composite instanceof MisappliedNameComposite){
 161                                                                                         Taxon misapplication = ((MisappliedNameComposite)composite).getMisappliedName();
 162                                                                                         operation = new ChangeMisappliedNameToSynonymOperation
 163                                                                                                         ("change misapplied name to synonym", undoContext,
 164                                                                                                                         getTaxon(), misapplication, HomotypicalGroup.NewInstance());
 165                                                                         }
 166
 167                                                                         // Execute operation if it's been init'ed
 168                                                                         if (operation == null) {
 169                                                                                 logger.warn("User unsuccessfully tried to drop " + composite.getClass());
 170                                                                         } else {
 171                                                                                 GlobalController.executeOperation(operation);
 172                                                                         }
 173                                                                 }
 174                                                         });
 175                                         }
 176                                 }
 177
 178
 179                         }
 180                 });
 181                 setFocus();
 182
 183                 // Redraw composite
 184                 composite.layout();
 185         }
 186
 187
 188         public Composite getAcceptedName() {
 189                 for(Composite c : getAllComposites()){
 190                         if(c instanceof AcceptedNameComposite){
 191                                 return c;
 192                         }
 193                 }
 194                 return null;
 195         }
 196
 197
 198         public Composite getHomotypicGroup(HomotypicalGroup group) {
 199                 for(Composite c : getAllComposites()){
 200                         if(c instanceof HomotypicalGroupComposite){
 201                                 if (group.equals(
 202                                                 ((HomotypicalGroupComposite) c).getGroup())) {
 203                                         return c;
 204                                 }
 205                         }
 206                 }
 207                 return null;
 208         }
 209
 210
 211         public Composite getMisappliedGroup() {
 212                 for(Composite c : getAllComposites()){
 213                         if(c instanceof MisappliedGroupComposite){
 214                                 return c;
 215                         }
 216                 }
 217                 return null;
 218         }
 219
 220
 221         public Composite getMisappliedName(Taxon misappliedName) {
 222                 for(Composite c : getAllComposites()){
 223                         if(c instanceof MisappliedNameComposite){
 224                                 if (misappliedName.equals(
 225                                                 ((MisappliedNameComposite) c).getMisappliedName())) {
 226                                         return c;
 227                                 }
 228                         }
 229                 }
 230                 return null;
 231         }
 232
 233
 234         public Composite getSynonym(Synonym synonym) {
 235                 for(Composite c : getAllComposites()){
 236                         if(c instanceof SynonymComposite){
 237                                 if (synonym.equals
 238                                                 (((SynonymComposite) c).getSynonym())) {
 239                                         return c;
 240                                 }
 241                         }
 242                 }
 243                 return null;
 244         }
 245
 246
 247         public Composite getConceptGroup() {
 248                 for(Composite c : getAllComposites()){
 249                         if(c instanceof ConceptGroupComposite){
 250                                 return c;
 251                         }
 252                 }
 253                 return null;
 254         }
 255
 256
 257         public Composite getConcept(Taxon relatedConcept) {
 258                 for(Composite c : getAllComposites()){
 259                         if(c instanceof ConceptComposite){
 260                                 if (relatedConcept.equals
 261                                                 (((ConceptComposite) c).getRelatedTaxon())) {
 262                                         return c;
 263                                 }
 264                         }
 265                 }
 266                 return null;
 267         }
 268 }