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