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