eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/EditorUtil.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;
  11
  12 import java.util.Collection;
  13 import java.util.UUID;
  14
  15 import org.eclipse.core.commands.ExecutionEvent;
  16 import org.eclipse.core.commands.operations.IOperationHistory;
  17 import org.eclipse.core.commands.operations.IUndoContext;
  18 import org.eclipse.e4.ui.model.application.MApplication;
  19 import org.eclipse.e4.ui.model.application.ui.basic.MPart;
  20 import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
  21 import org.eclipse.e4.ui.workbench.modeling.EModelService;
  22 import org.eclipse.e4.ui.workbench.modeling.EPartService;
  23 import org.eclipse.e4.ui.workbench.modeling.EPartService.PartState;
  24 import org.eclipse.jface.dialogs.MessageDialog;
  25 import org.eclipse.jface.viewers.ISelection;
  26 import org.eclipse.jface.viewers.IStructuredSelection;
  27 import org.eclipse.jface.viewers.TreeNode;
  28 import org.eclipse.swt.widgets.Shell;
  29 import org.eclipse.ui.IEditorPart;
  30 import org.eclipse.ui.handlers.HandlerUtil;
  31
  32 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  33 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  34 import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
  35 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  36 import eu.etaxonomy.cdm.model.taxon.Synonym;
  37 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  38 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  39 import eu.etaxonomy.taxeditor.editor.e4.TaxonEditorInputE4;
  40 import eu.etaxonomy.taxeditor.editor.group.authority.CdmAuthorityEditorInput;
  41 import eu.etaxonomy.taxeditor.editor.group.authority.e4.CdmAuthorityEditorE4;
  42 import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin;
  43 import eu.etaxonomy.taxeditor.editor.l10n.Messages;
  44 import eu.etaxonomy.taxeditor.editor.name.e4.TaxonNameEditorE4;
  45 import eu.etaxonomy.taxeditor.editor.view.derivate.DerivateView;
  46 import eu.etaxonomy.taxeditor.editor.view.derivate.DerivateViewEditorInput;
  47 import eu.etaxonomy.taxeditor.editor.workingSet.WorkingSetEditor;
  48 import eu.etaxonomy.taxeditor.editor.workingSet.matrix.CharacterMatrixPart;
  49 import eu.etaxonomy.taxeditor.model.AbstractUtility;
  50 import eu.etaxonomy.taxeditor.model.MessagingUtils;
  51 import eu.etaxonomy.taxeditor.workbench.WorkbenchUtility;
  52
  53 /**
  54  * Utility for the editor package
  55  *
  56  * @author n.hoffmann
  57  * @created 20.01.2009
  58  * @version 1.0
  59  */
  60 public class EditorUtil extends AbstractUtility {
  61
  62     private static final String NAME_EDITOR_ID = "eu.etaxonomy.taxeditor.editor.name.e4.TaxonNameEditorE4";
  63     private static boolean isSaving = false;
  64
  65     public static void openWorkingSetEditor(UUID workingSetUuid, EModelService modelService, EPartService partService, MApplication application){
  66         String partId = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_VIEW_WORKINGSET_WORKINGSETEDITOR;
  67         MPart part = showPart(partId, modelService, partService, application);
  68         WorkingSetEditor editor = (WorkingSetEditor) part.getObject();
  69         editor.init(workingSetUuid);
  70     }
  71
  72     public static void openCharacterMatrix(UUID workingSetUuid, EModelService modelService, EPartService partService, MApplication application){
  73         String partId = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_WORKINGSET_MATRIX_CHARACTERMATRIXPART;
  74         MPart part = showPart(partId, modelService, partService, application);
  75         CharacterMatrixPart editor = (CharacterMatrixPart) part.getObject();
  76         editor.init(workingSetUuid, true);
  77     }
  78
  79     public static void openSpecimenEditor(DerivateViewEditorInput input, EModelService modelService, EPartService partService, MApplication application){
  80         String partId = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_VIEW_DERIVATE_DERIVATEVIEW;
  81         MPart part = showPart(partId, modelService, partService, application);
  82         DerivateView derivateView = (DerivateView) part.getObject();
  83         derivateView.init(input);
  84     }
  85
  86     public static void openRightsEditor(CdmAuthorityEditorInput input, EModelService modelService, EPartService partService, MApplication application){
  87         String partId = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_GROUP_AUTHORITY_E4_CDMAUTHORITYEDITORE4;
  88         MPart part = showPart(partId, modelService, partService, application);
  89         CdmAuthorityEditorE4 authorityView = (CdmAuthorityEditorE4) part.getObject();
  90         authorityView.init(input);
  91     }
  92
  93     private static MPart showPart(String partId, EModelService modelService, EPartService partService, MApplication application){
  94         MPart part = partService.findPart(partId);
  95         if(part==null || modelService.getPartDescriptor(partId).isAllowMultiple()){
  96             part = partService.createPart(partId);
  97         }
  98         MPartStack editorAreaPartStack = WorkbenchUtility.getEditorAreaPartStack(application, modelService);
  99         if(editorAreaPartStack!=null){
 100             editorAreaPartStack.getChildren().add(part);
 101         }
 102         return partService.showPart(part, PartState.ACTIVATE);
 103     }
 104
 105         public static void openTaxonNodeE4(UUID taxonNodeUuid, EModelService modelService, EPartService partService, MApplication application) {
 106             TaxonEditorInputE4 input = TaxonEditorInputE4.NewInstance(taxonNodeUuid);
 107             openNameEditor_internal(input, modelService, partService, application);
 108         }
 109
 110         public static void openTaxonBaseE4(UUID taxonBaseUuid, EModelService modelService, EPartService partService, MApplication application) {
 111             TaxonEditorInputE4 input = TaxonEditorInputE4.NewInstanceFromTaxonBase(taxonBaseUuid);
 112             openNameEditor_internal(input, modelService, partService, application);
 113         }
 114
 115     public static void openTaxonBaseE4(UUID taxonBaseUuid) {
 116         //FIXME E4 this can probably be removed when fully migrated
 117         TaxonEditorInputE4 input = TaxonEditorInputE4.NewInstanceFromTaxonBase(taxonBaseUuid);
 118
 119         EPartService partService = TaxeditorEditorPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getService(EPartService.class);
 120         EModelService modelService = TaxeditorEditorPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getService(EModelService.class);
 121         openNameEditor_internal(input, modelService, partService, null);
 122     }
 123
 124     private static void openNameEditor_internal(TaxonEditorInputE4 input, EModelService modelService, EPartService partService, MApplication application) {
 125         TaxonBase taxonBase = input.getTaxon();
 126         if(taxonBase==null){
 127             return;
 128         }
 129         if (taxonBase.isOrphaned()) {
 130             if(taxonBase.isInstanceOf(Synonym.class)){
 131                 MessagingUtils.warningDialog(Messages.EditorUtil_ORPHAN_ACCEPTED_TAXON, TaxonEditorInputE4.class, Messages.EditorUtil_ORPHAN_ACCEPTED_TAXON_MESSAGE);
 132                 return;
 133             }
 134             else{
 135                 MessagingUtils.warningDialog(Messages.EditorUtil_ORPHAN_TAXON, TaxonEditorInputE4.class, Messages.EditorUtil_ORPHAN_TAXON_MESSAGE);
 136                 return;
 137             }
 138         }
 139
 140         Collection<MPart> parts = partService.getParts();
 141         //check if part is already opened
 142         for (MPart part : parts) {
 143                 if(part.getObject() instanceof TaxonNameEditorE4
 144                     && ((TaxonNameEditorE4) part.getObject()).getTaxon()!=null
 145                     && ((TaxonNameEditorE4) part.getObject()).getTaxon().getUuid().equals(input.getTaxon().getUuid())){
 146                 partService.hidePart(part);
 147                 break;
 148             }
 149         }
 150         MPart part = showPart(NAME_EDITOR_ID, modelService, partService, application);
 151         TaxonNameEditorE4 editor = (TaxonNameEditorE4) part.getObject();
 152         editor.init(input);
 153     }
 154
 155         /**
 156          * An uninitialized taxon is one that hasn't been saved yet. As such, it
 157          * should appear in neither the list of recent names nor in the taxonomic
 158          * tree when opened.
 159          *
 160          * @param parentNodeUuid
 161          *            a {@link java.util.UUID} object.
 162          */
 163         public static void openEmptyE4(UUID parentNodeUuid) {
 164                 TaxonEditorInputE4 input = TaxonEditorInputE4
 165                                 .NewEmptyInstance(parentNodeUuid);
 166         EPartService partService = TaxeditorEditorPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getService(EPartService.class);
 167         MPart part = partService.createPart(NAME_EDITOR_ID);
 168         part = partService.showPart(part, PartState.ACTIVATE);
 169         TaxonNameEditorE4 editor = (TaxonNameEditorE4) part.getObject();
 170         editor.init(input);
 171         }
 172
 173         /**
 174          * <p>
 175          * setSaving
 176          * </p>
 177          *
 178          * @param isSaving
 179          *            a boolean.
 180          */
 181         public static void setSaving(boolean isSaving) {
 182                 EditorUtil.isSaving = isSaving;
 183         }
 184
 185         /**
 186          * <p>
 187          * isSaving
 188          * </p>
 189          *
 190          * @return a boolean.
 191          */
 192         public static boolean isSaving() {
 193                 return isSaving;
 194         }
 195
 196         /**
 197          * <p>
 198          * getUndoContext
 199          * </p>
 200          *
 201          * @return a {@link org.eclipse.core.commands.operations.IUndoContext}
 202          *         object.
 203          */
 204         public static IUndoContext getUndoContext() {
 205                 return IOperationHistory.GLOBAL_UNDO_CONTEXT;
 206         }
 207
 208         /**
 209          * <p>
 210          * forceUserSave
 211          * </p>
 212          *
 213          * @param editor
 214          *            a {@link org.eclipse.ui.IEditorPart} object.
 215          * @param shell
 216          *            a {@link org.eclipse.swt.widgets.Shell} object.
 217          * @return a boolean.
 218          */
 219         public static boolean forceUserSave(IEditorPart editor, Shell shell) {
 220                 if (editor.isDirty()) {
 221
 222                         boolean doSave = MessageDialog
 223                                         .openConfirm(shell, Messages.EditorUtil_COMFIRM_SAVE,
 224                                                         Messages.EditorUtil_CONFIRM_SAVE_MESSAGE);
 225
 226                         if (!doSave) {
 227                                 return false;
 228                         }
 229
 230                         editor.doSave(AbstractUtility.getMonitor());
 231                 }
 232                 return true;
 233         }
 234
 235         public static boolean forceUserSaveE4Editor(TaxonNameEditorE4 editor, Shell shell) {
 236             if (editor.isDirty()) {
 237
 238                 boolean doSave = MessageDialog
 239                         .openConfirm(shell, Messages.EditorUtil_COMFIRM_SAVE,
 240                                 Messages.EditorUtil_CONFIRM_SAVE_MESSAGE);
 241
 242                 if (!doSave) {
 243                     return false;
 244                 }
 245
 246                 editor.save(AbstractUtility.getMonitor());
 247             }
 248             return true;
 249         }
 250
 251         /**
 252          * <p>
 253          * getSelection
 254          * </p>
 255          *
 256          * @param event
 257          *            a {@link org.eclipse.core.commands.ExecutionEvent} object.
 258          * @return a {@link org.eclipse.jface.viewers.IStructuredSelection} object.
 259          */
 260         public static IStructuredSelection getSelection(ExecutionEvent event) {
 261                 IEditorPart activeEditor = HandlerUtil.getActiveEditor(event);
 262
 263                 return (IStructuredSelection) activeEditor.getSite()
 264                                 .getSelectionProvider().getSelection();
 265         }
 266
 267         /**
 268          * <p>
 269          * getPluginId
 270          * </p>
 271          *
 272          * @return a {@link java.lang.String} object.
 273          */
 274         public static String getPluginId() {
 275                 return TaxeditorEditorPlugin.PLUGIN_ID;
 276         }
 277
 278         /**
 279          * Iterates recursively over all originals having the given specimen as a derivate.
 280          * The first {@link DerivedUnit} with no more originals or the first {@link FieldUnit} is returned
 281          * @param specimen the start element for which the originals are iterated recursively
 282          * @return either a FieldUnit or a the topmost DerivedUnit (which can be itself)
 283          */
 284         public static SpecimenOrObservationBase<?> getTopMostDerivate(SpecimenOrObservationBase<?> specimen){
 285             if(specimen==null){
 286                 return null;
 287             }
 288             if(specimen.isInstanceOf(FieldUnit.class)){
 289                 return specimen;
 290             }
 291             else if(specimen.isInstanceOf(DerivedUnit.class)){
 292                 DerivedUnit derivedUnit = HibernateProxyHelper.deproxy(specimen, DerivedUnit.class);
 293                 if(derivedUnit.getOriginals()!=null
 294                         && !(derivedUnit.getOriginals().isEmpty())){
 295                     for(SpecimenOrObservationBase<?> original:((DerivedUnit) specimen).getOriginals()){
 296                         return getTopMostDerivate(original);
 297                     }
 298                 }
 299             }
 300             return specimen;
 301         }
 302
 303     /**
 304      * If the current selection is a single {@link TreeNode} it will be returned.
 305      * @param selection the selection to check
 306      * @return the selected TreeNode or <code>null</code> if no TreeNode selected
 307      */
 308     public static TreeNode getTreeNodeOfSelection(ISelection selection){
 309         if(selection instanceof IStructuredSelection
 310                 && ((IStructuredSelection) selection).size()==1
 311                 && ((IStructuredSelection) selection).getFirstElement() instanceof TreeNode){
 312             return (TreeNode) ((IStructuredSelection) selection).getFirstElement();
 313
 314         }
 315         return null;
 316     }
 317
 318     public static void closeObsoleteEditor(TaxonNode taxonNode, EPartService partService){
 319         String treeIndex = taxonNode.treeIndex();
 320         Collection<MPart> parts = partService.getParts();
 321         for (MPart part : parts) {
 322             Object object = part.getObject();
 323             if(object instanceof TaxonNameEditorE4){
 324                 TaxonNameEditorE4 taxonEditor = (TaxonNameEditorE4)object;
 325                 TaxonNode node = taxonEditor.getEditorInput().getTaxonNode();
 326                 if (node.treeIndex()!= null){
 327                         if(node.treeIndex().startsWith(treeIndex)){
 328                             partService.hidePart(part);
 329                         }
 330                 }else{
 331                         logger.debug("The taxonnode of taxon " + node.getTaxon().getTitleCache() + " uuid: " + node.getUuid() + " has no treeindex");;
 332                 }
 333             }
 334         }
 335     }
 336
 337     public static void updateEditor(TaxonNode taxonNode, TaxonNameEditorE4 editor){
 338         String treeIndex = taxonNode.treeIndex();
 339         TaxonNode node = editor.getEditorInput().getTaxonNode();
 340         if(node.treeIndex().equals(treeIndex)){
 341                 TaxonEditorInputE4 input = TaxonEditorInputE4.NewInstance(node.getUuid());
 342                 editor.init(input);
 343
 344
 345         }
 346     }
 347 }