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