eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/EditorStateManager.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2007 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
  11 package eu.etaxonomy.taxeditor.editor;
  12
  13 import java.util.HashSet;
  14 import java.util.Set;
  15 import java.util.UUID;
  16
  17 import org.eclipse.core.runtime.IProgressMonitor;
  18 import org.eclipse.ui.IEditorInput;
  19 import org.eclipse.ui.IEditorPart;
  20 import org.eclipse.ui.IMemento;
  21 import org.eclipse.ui.IPersistable;
  22 import org.eclipse.ui.PartInitException;
  23
  24 import eu.etaxonomy.taxeditor.editor.view.concept.ConceptViewPart;
  25 import eu.etaxonomy.taxeditor.editor.view.descriptive.DescriptiveViewPart;
  26 import eu.etaxonomy.taxeditor.editor.view.media.MediaViewPart;
  27 import eu.etaxonomy.taxeditor.model.ContextListenerAdapter;
  28 import eu.etaxonomy.taxeditor.view.AbstractCdmEditorViewPart;
  29
  30 /**
  31  * <p>EditorStateManager class.</p>
  32  *
  33  * @author n.hoffmann
  34  * @created Sep 30, 2010
  35  * @version 1.0
  36  */
  37 public class EditorStateManager extends ContextListenerAdapter {
  38
  39         private static final String EDITORS = "editors";
  40
  41         private static final String EDITOR = "editor";
  42
  43         private TaxonEditorInputFactory inputFactory;
  44
  45         /**
  46          * <p>Constructor for EditorStateManager.</p>
  47          */
  48         public EditorStateManager() {
  49                 inputFactory = new TaxonEditorInputFactory();
  50         }
  51
  52         /* (non-Javadoc)
  53          * @see eu.etaxonomy.taxeditor.model.IContextListener#contextAboutToStop(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
  54          */
  55         /** {@inheritDoc} */
  56         @Override
  57         public void contextAboutToStop(IMemento memento, IProgressMonitor monitor) {
  58                 saveEditorState(memento);
  59         }
  60
  61         /* (non-Javadoc)
  62          * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#contextStop(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
  63          */
  64         /** {@inheritDoc} */
  65         @Override
  66         public void contextStop(IMemento memento, IProgressMonitor monitor) {
  67                 EditorUtil.closeAll();
  68                 resetConstantViews();
  69         }
  70
  71         /**
  72          *
  73          */
  74         private void resetConstantViews() {
  75                 AbstractCdmEditorViewPart descriptiveView = (AbstractCdmEditorViewPart) EditorUtil.getView(DescriptiveViewPart.ID, false);
  76                 AbstractCdmEditorViewPart mediaView = (AbstractCdmEditorViewPart) EditorUtil.getView(MediaViewPart.ID, false);
  77                 AbstractCdmEditorViewPart conceptView = (AbstractCdmEditorViewPart) EditorUtil.getView(ConceptViewPart.ID, false);
  78
  79                 if(descriptiveView != null){
  80                         descriptiveView.showEmptyPage();
  81                 }
  82                 if(mediaView != null){
  83                         mediaView.showEmptyPage();
  84                 }
  85                 if(conceptView != null){
  86                         conceptView.showEmptyPage();
  87                 }
  88         }
  89
  90         /* (non-Javadoc)
  91          * @see eu.etaxonomy.taxeditor.model.IContextListener#contextStart(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
  92          */
  93         /** {@inheritDoc} */
  94         @Override
  95         public void contextStart(IMemento memento, IProgressMonitor monitor) {
  96                 restoreEditors(memento, monitor);
  97         }
  98
  99         /* (non-Javadoc)
 100          * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#contextRefresh(org.eclipse.core.runtime.IProgressMonitor)
 101          */
 102         @Override
 103         public void contextRefresh(IProgressMonitor monitor) {
 104                 refreshEditors(monitor);
 105         }
 106
 107         /* (non-Javadoc)
 108          * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#workbenchShutdown(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 109          */
 110         /** {@inheritDoc} */
 111         @Override
 112         public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {
 113                 saveEditorState(memento);
 114         }
 115
 116         /**
 117          * Reads taxon node UUIDs from the given memento and tries to open an editor
 118          * for each of the found UUIDs.
 119          *
 120          * @param memento
 121          */
 122         private void restoreEditors(final IMemento memento, IProgressMonitor monitor){
 123                 if(memento == null){
 124                         return;
 125                 }
 126
 127                 IProgressMonitor subProgressMonitor = EditorUtil.getSubProgressMonitor(monitor, 1);
 128
 129                 IMemento editorMementos = memento.getChild(EDITORS);
 130                 IMemento[] editorInputs = editorMementos.getChildren(EDITOR);
 131
 132                 subProgressMonitor.beginTask("Restoring Editors", 1 + editorInputs.length * 2);
 133                 subProgressMonitor.subTask("Restoring Editors");
 134                 subProgressMonitor.worked(1);
 135
 136                 for(IMemento editorInput : editorInputs){
 137                         TaxonEditorInput input = (TaxonEditorInput) inputFactory.createElement(editorInput);
 138                         subProgressMonitor.worked(1);
 139                         if(!subProgressMonitor.isCanceled() && input != null){
 140                                 try {
 141                                         EditorUtil.open(input);
 142                                 } catch (PartInitException e) {
 143                                         EditorUtil.error(getClass(), "Error opening an editor window", e);
 144                                 }
 145                         }
 146                         subProgressMonitor.worked(1);
 147                 }
 148                 subProgressMonitor.done();
 149         }
 150
 151         /**
 152          * @param monitor
 153          */
 154         private void refreshEditors(IProgressMonitor monitor) {
 155                 IProgressMonitor subProgressMonitor = EditorUtil.getSubProgressMonitor(monitor, 1);
 156
 157                 Set<IEditorPart> openEditors = EditorUtil.getOpenEditors();
 158
 159
 160                 subProgressMonitor.beginTask("Refreshing Editors", openEditors.size() * 2);
 161
 162                 Set<UUID> uuids = new HashSet<UUID>();
 163
 164                 for(IEditorPart editor : openEditors){
 165                         if(editor instanceof MultiPageTaxonEditor){
 166                                 try {
 167                                         uuids.add(((TaxonEditorInput) editor.getEditorInput()).getTaxonNode().getUuid());
 168
 169 //                                      ((MultiPageTaxonEditor) editor).close(false);
 170                                         EditorUtil.close((MultiPageTaxonEditor)editor);
 171                                         subProgressMonitor.worked(1);
 172                                 } catch (Exception e) {
 173                                         // TODO Auto-generated catch block
 174                                         e.printStackTrace();
 175                                 }
 176                         }
 177                 }
 178
 179                 for(UUID uuid : uuids){
 180                         try {
 181                                 EditorUtil.openTaxonNode(uuid);
 182                         } catch (Exception e) {
 183                                 // TODO Auto-generated catch block
 184                                 e.printStackTrace();
 185                         }
 186                         subProgressMonitor.worked(1);
 187                 }
 188
 189                 subProgressMonitor.done();
 190         }
 191
 192         /**
 193          * Saves the UUIDs
 194          *
 195          * @param memento
 196          */
 197         private void saveEditorState(IMemento memento){
 198                 if(memento == null){
 199                         return;
 200                 }
 201
 202                 Set<IEditorPart> editors = EditorUtil.getOpenEditors();
 203
 204                 IMemento editorMementos = memento.createChild(EDITORS);
 205
 206                 for(IEditorPart editor : editors){
 207                         IEditorInput input = editor.getEditorInput();
 208                         if(input instanceof IPersistable){
 209                                 IMemento editorMemento = editorMementos.createChild(EDITOR);
 210                                 ((IPersistable) input).saveState(editorMemento);
 211                         }
 212                 }
 213         }
 214 }