* Copyright (c) 2000, 2007 IBM Corporation and others.

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*     IBM Corporation - initial API and implementation

*******************************************************************************/

* Manage a group of element editors. Prevent the creation of two editors on the

* same element.

*

* 06/12/00 - DS - Given the ambiguous editor input type, the manager delegates

* a number of responsibilities to the editor itself.

*

* <ol>

* <li>The editor should determine its own title.</li>

* <li>The editor should listen to resource deltas and close itself if the

* input is deleted. It may also choose to stay open if the editor has dirty

* state.</li>

* <li>The editor should persist its own state plus editor input.</li>

* </ol>

*/

  EditorAreaHelper editorPresentation;

  WorkbenchWindow window;

  WorkbenchPage page;

  private Map actionCache = new HashMap();

  private static final String PIN_EDITOR_KEY = "PIN_EDITOR"; //$NON-NLS-1$

  private static final String PIN_EDITOR = "ovr16/pinned_ovr.gif"; //$NON-NLS-1$

  // When the user removes or adds the close editors automatically preference

  // the icon should be removed or added accordingly

  private IPropertyChangeListener editorPropChangeListnener = null;

  // Handler for the pin editor keyboard shortcut

  private IHandlerActivation pinEditorHandlerActivation = null;

  static final String RESOURCES_TO_SAVE_MESSAGE = WorkbenchMessages.EditorManager_saveResourcesMessage;

  static final String SAVE_RESOURCES_TITLE = WorkbenchMessages.EditorManager_saveResourcesTitle;

  /**

   * EditorManager constructor comment.

   */

  public EditorManager(WorkbenchWindow window, WorkbenchPage workbenchPage,

      EditorAreaHelper pres) {

    Assert.isNotNull(window);

    Assert.isNotNull(workbenchPage);

    Assert.isNotNull(pres);

    this.window = window;

    this.page = workbenchPage;

    this.editorPresentation = pres;

    page.getExtensionTracker().registerHandler(this, null);

  }

  /**

   * Check to determine if the editor resources are no longer needed removes

   * property change listener for editors removes pin editor keyboard shortcut

   * handler disposes cached images and clears the cached images hash table

   */

  void checkDeleteEditorResources() {

    // get the current number of editors

    IEditorReference[] editors = page.getEditorReferences();

    // If there are no editors

    if (editors.length == 0) {

      if (editorPropChangeListnener != null) {

        // remove property change listener for editors

        IPreferenceStore prefStore = WorkbenchPlugin.getDefault()

            .getPreferenceStore();

        prefStore

            .removePropertyChangeListener(editorPropChangeListnener);

        editorPropChangeListnener = null;

      }

      if (pinEditorHandlerActivation != null) {

        // remove pin editor keyboard shortcut handler

        final IHandlerService handlerService = (IHandlerService) window.getWorkbench().getService(IHandlerService.class);

        handlerService.deactivateHandler(pinEditorHandlerActivation);

        pinEditorHandlerActivation = null;

      }

    }

  }

  /**

   * Check to determine if the property change listener for editors should be

   * created

   */

  void checkCreateEditorPropListener() {

    if (editorPropChangeListnener == null) {

      // Add a property change listener for closing editors automatically

      // preference

      // Add or remove the pin icon accordingly

      editorPropChangeListnener = new IPropertyChangeListener() {

        public void propertyChange(PropertyChangeEvent event) {

          if (event.getProperty().equals(

              IPreferenceConstants.REUSE_EDITORS_BOOLEAN)) {

            IEditorReference[] editors = getEditors();

            for (int i = 0; i < editors.length; i++) {

              ((EditorReference) editors[i]).pinStatusUpdated();

            }

          }

        }

      };

      WorkbenchPlugin.getDefault().getPreferenceStore()

          .addPropertyChangeListener(editorPropChangeListnener);

    }

  }

  /**

   * Check to determine if the handler for the pin editor keyboard shortcut

   * should be created.

   */

  void checkCreatePinEditorShortcutKeyHandler() {

    if (pinEditorHandlerActivation == null) {

      final Shell shell = window.getShell();

      final IHandler pinEditorHandler = new AbstractHandler() {

        public final Object execute(final ExecutionEvent event) {

          // check if the "Close editors automatically" preference is

          // set

          IPreferenceStore store = WorkbenchPlugin.getDefault().getPreferenceStore();

          if (store

              .getBoolean(IPreferenceConstants.REUSE_EDITORS_BOOLEAN)

              || ((TabBehaviour)Tweaklets.get(TabBehaviour.KEY)).alwaysShowPinAction()) {

            IWorkbenchPartReference ref = editorPresentation

                .getVisibleEditor();

            if (ref instanceof WorkbenchPartReference) {

              WorkbenchPartReference concreteRef = (WorkbenchPartReference) ref;

              concreteRef.setPinned(concreteRef.isPinned());

            }

          }

          return null;

        }

      };

      // Assign the handler for the pin editor keyboard shortcut.

      final IHandlerService handlerService = (IHandlerService) window.getWorkbench().getService(IHandlerService.class);

      pinEditorHandlerActivation = handlerService.activateHandler(

          "org.eclipse.ui.window.pinEditor", pinEditorHandler, //$NON-NLS-1$

          new ActiveShellExpression(shell));

    }

  }

  /**

   * Method to create the editor's pin ImageDescriptor

   *

   * @return the single image descriptor for the editor's pin icon

   */

  ImageDescriptor getEditorPinImageDesc() {

    ImageRegistry registry = JFaceResources.getImageRegistry();

    ImageDescriptor pinDesc = registry.getDescriptor(PIN_EDITOR_KEY);

    // Avoid registering twice

    if (pinDesc == null) {

      pinDesc = WorkbenchImages.getWorkbenchImageDescriptor(PIN_EDITOR);

      registry.put(PIN_EDITOR_KEY, pinDesc);

    }

    return pinDesc;

  }

  /**

   * Answer a list of dirty editors.

   */

  private List collectDirtyEditors() {

    List result = new ArrayList(3);

    IEditorReference[] editors = page.getEditorReferences();

    for (int i = 0; i < editors.length; i++) {

      IEditorPart part = (IEditorPart) editors[i].getPart(false);

      if (part != null && part.isDirty()) {

        result.add(part);

      }

    }

    return result;

  }

  /**

   * Returns whether the manager contains an editor.

   */

  public boolean containsEditor(IEditorReference ref) {

    IEditorReference[] editors = page.getEditorReferences();

    for (int i = 0; i < editors.length; i++) {

      if (ref == editors[i]) {

        return true;

      }

    }

    return false;

  }

  /*

   * Creates the action bars for an editor. Editors of the same type should

   * share a single editor action bar, so this implementation may return an

   * existing action bar vector.

   */

  private EditorActionBars createEditorActionBars(EditorDescriptor desc,

      final IEditorSite site) {

    // Get the editor type.

    String type = desc.getId();

    // If an action bar already exists for this editor type return it.

    EditorActionBars actionBars = (EditorActionBars) actionCache.get(type);

    if (actionBars != null) {

      actionBars.addRef();

      return actionBars;

    }

    // Create a new action bar set.

    actionBars = new EditorActionBars(page, site.getWorkbenchWindow(), type);

    actionBars.addRef();

    actionCache.put(type, actionBars);

    // Read base contributor.

    IEditorActionBarContributor contr = desc.createActionBarContributor();

    if (contr != null) {

      actionBars.setEditorContributor(contr);

      contr.init(actionBars, page);

    }

    // Read action extensions.

    EditorActionBuilder builder = new EditorActionBuilder();

    contr = builder.readActionExtensions(desc);

    if (contr != null) {

      actionBars.setExtensionContributor(contr);

      contr.init(actionBars, page);

    }

    // Return action bars.

    return actionBars;

  }

  /*

   * Creates the action bars for an editor.

   */

  private EditorActionBars createEmptyEditorActionBars(final IEditorSite site) {

    // Get the editor type.

    String type = String.valueOf(System.currentTimeMillis());

    // Create a new action bar set.

    // Note: It is an empty set.

    EditorActionBars actionBars = new EditorActionBars(page, site.getWorkbenchWindow(), type);

    actionBars.addRef();

    actionCache.put(type, actionBars);

    // Return action bars.

    return actionBars;

  }

  /*

   * Dispose

   */

  void disposeEditorActionBars(EditorActionBars actionBars) {

    actionBars.removeRef();

    if (actionBars.getRef() <= 0) {

      String type = actionBars.getEditorType();

      actionCache.remove(type);

      // refresh the cool bar manager before disposing of a cool item

      ICoolBarManager2 coolBar = (ICoolBarManager2) window.getCoolBarManager2();

            if (coolBar != null) {

              coolBar.refresh();

      }

      actionBars.dispose();

    }

  }

  /**

   * Returns an open editor matching the given editor input. If none match,

   * returns <code>null</code>.

   *

   * @param input

   *            the editor input

   * @return the matching editor, or <code>null</code> if no match fond

   */

  public IEditorPart findEditor(IEditorInput input) {

    return findEditor(null, input, IWorkbenchPage.MATCH_INPUT);

  }

  /**

   * Returns an open editor matching the given editor input and/or editor id,

   * as specified by matchFlags. If none match, returns <code>null</code>.

   *

   * @param editorId

   *            the editor id

   * @param input

   *            the editor input

   * @param matchFlags

   *            flags specifying which aspects to match

   * @return the matching editor, or <code>null</code> if no match fond

   * @since 3.1

   */

  public IEditorPart findEditor(String editorId, IEditorInput input,

      int matchFlags) {

    IEditorReference[] refs = findEditors(input, editorId, matchFlags);

    if (refs.length == 0) {

      return null;

    }

    return refs[0].getEditor(true);

  }

  /**

   * Returns the open editor references matching the given editor input and/or

   * editor id, as specified by matchFlags. If none match, returns an empty

   * array.

   *

   * @param editorId

   *            the editor id

   * @param input

   *            the editor input

   * @param matchFlags

   *            flags specifying which aspects to match

   * @return the matching editor, or <code>null</code> if no match fond

   * @since 3.1

   */

  public IEditorReference[] findEditors(IEditorInput input, String editorId,

      int matchFlags) {

    if (matchFlags == IWorkbenchPage.MATCH_NONE) {

      return new IEditorReference[0];

    }

    List result = new ArrayList();

    ArrayList othersList = new ArrayList(Arrays.asList(page

        .getEditorReferences()));

    if (!othersList.isEmpty()) {

      IEditorReference active = page.getActiveEditorReference();

      if (active != null) {

        othersList.remove(active);

        ArrayList activeList = new ArrayList(1);

        activeList.add(active);

        findEditors(activeList, input, editorId, matchFlags, result);

      }

      findEditors(othersList, input, editorId, matchFlags, result);

    }

    return (IEditorReference[]) result.toArray(new IEditorReference[result

        .size()]);

  }

  /**

   * Returns an open editor matching the given editor id and/or editor input.

   * Returns <code>null</code> if none match.

   *

   * @param editorId

   *            the editor id

   * @param input

   *            the editor input

   * @param editorList

   *            a mutable list containing the references for the editors to

   *            check (warning: items may be removed)

   * @param result

   *            the list to which matching editor references should be added

   * @since 3.1

   */

  private void findEditors(List editorList, IEditorInput input,

      String editorId, int matchFlags, List result) {

    if (matchFlags == IWorkbenchPage.MATCH_NONE) {

      return;

    }

    // Phase 0: Remove editors whose ids don't match (if matching by id)

    if (((matchFlags & IWorkbenchPage.MATCH_ID) != 0) && editorId != null) {

      for (Iterator i = editorList.iterator(); i.hasNext();) {

        EditorReference editor = (EditorReference) i.next();

        if (!editorId.equals(editor.getId())) {

          i.remove();

        }

      }

    }

    // If not matching on editor input, just return the remaining editors.

    // In practice, this case is never used.

    if ((matchFlags & IWorkbenchPage.MATCH_INPUT) == 0) {

      result.addAll(editorList);

      return;

    }

    // Phase 1: check editors that have their own matching strategy

    for (Iterator i = editorList.iterator(); i.hasNext();) {

      EditorReference editor = (EditorReference) i.next();

      IEditorDescriptor desc = editor.getDescriptor();

      if (desc != null) {

        IEditorMatchingStrategy matchingStrategy = desc

            .getEditorMatchingStrategy();

        if (matchingStrategy != null) {

          i.remove(); // We're handling this one here, so remove it

          // from the list.

          if (matchingStrategy.matches(editor, input)) {

            result.add(editor);

          }

        }

      }

    }

    // Phase 2: check materialized editors (without their own matching

    // strategy)

    for (Iterator i = editorList.iterator(); i.hasNext();) {

      IEditorReference editor = (IEditorReference) i.next();

      IEditorPart part = (IEditorPart) editor.getPart(false);

      if (part != null) {

        i.remove(); // We're handling this one here, so remove it from

        // the list.

        if (part.getEditorInput() != null

            && part.getEditorInput().equals(input)) {

          result.add(editor);

        }

      }

    }

    // Phase 3: check unmaterialized editors for input equality,

    // delaying plug-in activation further by only restoring the editor

    // input

    // if the editor reference's factory id and name match.

    String name = input.getName();

    IPersistableElement persistable = input.getPersistable();

    if (name == null || persistable == null) {

      return;

    }

    String id = persistable.getFactoryId();

    if (id == null) {

      return;

    }

    for (Iterator i = editorList.iterator(); i.hasNext();) {

      EditorReference editor = (EditorReference) i.next();

      if (name.equals(editor.getName())

          && id.equals(editor.getFactoryId())) {

        IEditorInput restoredInput;

        try {

          restoredInput = editor.getEditorInput();

          if (Util.equals(restoredInput, input)) {

            result.add(editor);

          }

        } catch (PartInitException e1) {

          WorkbenchPlugin.log(e1);

        }

      }

    }

  }

  /**

   * Returns the SWT Display.

   */

  private Display getDisplay() {

    return window.getShell().getDisplay();

  }

  /**

   * Answer the number of editors.

   */

  public int getEditorCount() {

    return page.getEditorReferences().length;

  }

  /*

   * Answer the editor registry.

   */

  private IEditorRegistry getEditorRegistry() {

    return WorkbenchPlugin.getDefault().getEditorRegistry();

  }

  /*

   * See IWorkbenchPage.

   */

  public IEditorPart[] getDirtyEditors() {

    List dirtyEditors = collectDirtyEditors();

    return (IEditorPart[]) dirtyEditors

        .toArray(new IEditorPart[dirtyEditors.size()]);

  }

  /*

   * See IWorkbenchPage.

   */

  public IEditorReference[] getEditors() {

    return page.getEditorReferences();

  }

  /*

   * See IWorkbenchPage#getFocusEditor

   */

  public IEditorPart getVisibleEditor() {

    IEditorReference ref = editorPresentation.getVisibleEditor();

    if (ref == null) {

      return null;

    }

    return (IEditorPart) ref.getPart(true);

  }

  /**

   * Answer true if save is needed in any one of the editors.

   */

  public boolean isSaveAllNeeded() {

    IEditorReference[] editors = page.getEditorReferences();

    for (int i = 0; i < editors.length; i++) {

      IEditorReference ed = editors[i];

      if (ed.isDirty()) {

        return true;

      }

    }

    return false;

  }

  /*

   * Prompt the user to save the reusable editor. Return false if a new editor

   * should be opened.

   */

  private IEditorReference findReusableEditor(EditorDescriptor desc) {

    return ((TabBehaviour)Tweaklets.get(TabBehaviour.KEY)).findReusableEditor(page);

  }

  /**

   * @param editorId

   *            the editor part id

   * @param input

   *            the input

   * @param setVisible

   *            if this is to be created visible ... not used

   * @param editorState

   *            an {@link IMemento} &lt;editorState&gt; for persistable

   *            editors. Can be <code>null</code>.

   * @return a created editor reference

   * @throws PartInitException

   */

  public IEditorReference openEditor(String editorId, IEditorInput input,

      boolean setVisible, IMemento editorState) throws PartInitException {

    if (editorId == null || input == null) {

      throw new IllegalArgumentException();

    }

    IEditorRegistry reg = getEditorRegistry();

    EditorDescriptor desc = (EditorDescriptor) reg.findEditor(editorId);

    if (desc == null) {

      throw new PartInitException(NLS.bind(

          WorkbenchMessages.EditorManager_unknownEditorIDMessage,

          editorId));

    }

    IEditorReference result = openEditorFromDescriptor(desc, input, editorState);

    return result;

  }

  /*

   * Open a new editor

   */

  public IEditorReference openEditorFromDescriptor(EditorDescriptor desc,

      IEditorInput input, IMemento editorState) throws PartInitException {

    IEditorReference result = null;

    if (desc.isInternal()) {

      result = reuseInternalEditor(desc, input);

      if (result == null) {

        result = new EditorReference(this, input, desc, editorState);

      }

    } else if (desc.getId()

        .equals(IEditorRegistry.SYSTEM_INPLACE_EDITOR_ID)) {

      if (ComponentSupport.inPlaceEditorSupported()) {

        result = new EditorReference(this, input, desc);

      }

    } else if (desc.getId().equals(

        IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID)) {

      IPathEditorInput pathInput = getPathEditorInput(input);

      if (pathInput != null) {

        result = openSystemExternalEditor(pathInput.getPath());

      } else {

        throw new PartInitException(

            WorkbenchMessages.EditorManager_systemEditorError);

      }

    } else if (desc.isOpenExternal()) {

      result = openExternalEditor(desc, input);

    } else {

      // this should never happen

      throw new PartInitException(NLS.bind(

          WorkbenchMessages.EditorManager_invalidDescriptor, desc

              .getId()));

    }

    if (result != null) {

      createEditorTab((EditorReference) result, ""); //$NON-NLS-1$

    }

    Workbench wb = (Workbench) window.getWorkbench();

    wb.getEditorHistory().add(input, desc);

    return result;

  }

  /**

   * Open a specific external editor on an file based on the descriptor.

   */

  private IEditorReference openExternalEditor(final EditorDescriptor desc,

      IEditorInput input) throws PartInitException {

    final CoreException ex[] = new CoreException[1];

    final IPathEditorInput pathInput = getPathEditorInput(input);

    if (pathInput != null && pathInput.getPath() != null) {

      BusyIndicator.showWhile(getDisplay(), new Runnable() {

        public void run() {

          try {

            if (desc.getLauncher() != null) {

              // open using launcher

              Object launcher = WorkbenchPlugin.createExtension(

                  desc.getConfigurationElement(), "launcher"); //$NON-NLS-1$

              ((IEditorLauncher) launcher).open(pathInput

                  .getPath());

            } else {

              // open using command

              ExternalEditor oEditor = new ExternalEditor(

                  pathInput.getPath(), desc);

              oEditor.open();

            }

          } catch (CoreException e) {

            ex[0] = e;

          }

        }

      });

    } else {

      throw new PartInitException(NLS.bind(

          WorkbenchMessages.EditorManager_errorOpeningExternalEditor,

          desc.getFileName(), desc.getId()));

    }

    if (ex[0] != null) {

      throw new PartInitException(NLS.bind(

          WorkbenchMessages.EditorManager_errorOpeningExternalEditor,

          desc.getFileName(), desc.getId()), ex[0]);

    }

    // we do not have an editor part for external editors

    return null;

  }

  /**

   * Create the part and reference for each inner editor.

   *

   * @param ref

   *            the MultiEditor reference

   * @param part

   *            the part

   * @param input

   *            the MultiEditor input

   * @return the array of inner references to store in the MultiEditor reference

   */

  IEditorReference[] openMultiEditor(final IEditorReference ref,

      final MultiEditor part, final MultiEditorInput input)

      throws PartInitException {

    String[] editorArray = input.getEditors();

    IEditorInput[] inputArray = input.getInput();

    // find all descriptors

    EditorDescriptor[] descArray = new EditorDescriptor[editorArray.length];

    IEditorReference refArray[] = new IEditorReference[editorArray.length];

    IEditorPart partArray[] = new IEditorPart[editorArray.length];

    IEditorRegistry reg = getEditorRegistry();

    for (int i = 0; i < editorArray.length; i++) {

      EditorDescriptor innerDesc = (EditorDescriptor) reg

          .findEditor(editorArray[i]);

      if (innerDesc == null) {

        throw new PartInitException(NLS.bind(

            WorkbenchMessages.EditorManager_unknownEditorIDMessage,

            editorArray[i]));

      }

      descArray[i] = innerDesc;

      InnerEditor innerRef = new InnerEditor(ref, inputArray[i],

          descArray[i]);

      refArray[i] = innerRef;

      partArray[i] = innerRef.getEditor(true);

    }

    part.setChildren(partArray);

    return refArray;

  }

  /*

   * Opens an editor part.

   */

  private void createEditorTab(final EditorReference ref,

      final String workbookId) throws PartInitException {

    editorPresentation.addEditor(ref, workbookId);

  }

  /*

   * Create the site and initialize it with its action bars.

   */

  EditorSite createSite(final IEditorReference ref, final IEditorPart part,

      final EditorDescriptor desc, final IEditorInput input)

      throws PartInitException {

    EditorSite site = new EditorSite(ref, part, page, desc);

    if (desc != null) {

      site.setActionBars(createEditorActionBars(desc, site));

    } else {

      site.setActionBars(createEmptyEditorActionBars(site));

    }

    final String label = part.getTitle(); // debugging only

    try {

      try {

        UIStats.start(UIStats.INIT_PART, label);

        part.init(site, input);

      } finally {

        UIStats.end(UIStats.INIT_PART, part, label);

      }

      // Sanity-check the site

      if (part.getSite() != site || part.getEditorSite() != site) {

        throw new PartInitException(NLS.bind(

            WorkbenchMessages.EditorManager_siteIncorrect, desc

                .getId()));

      }

    } catch (Exception e) {

      disposeEditorActionBars((EditorActionBars) site.getActionBars());

      site.dispose();

      if (e instanceof PartInitException) {

        throw (PartInitException) e;

      }

      throw new PartInitException(

          WorkbenchMessages.EditorManager_errorInInit, e);

    }

    return site;

  }

  /*

   * See IWorkbenchPage.

   */

  private IEditorReference reuseInternalEditor(EditorDescriptor desc,

      IEditorInput input) throws PartInitException {

    Assert.isNotNull(desc, "descriptor must not be null"); //$NON-NLS-1$

    Assert.isNotNull(input, "input must not be null"); //$NON-NLS-1$

    IEditorReference reusableEditorRef = findReusableEditor(desc);

    if (reusableEditorRef != null) {

      return ((TabBehaviour) Tweaklets.get(TabBehaviour.KEY))

          .reuseInternalEditor(page, this, editorPresentation, desc,

              input, reusableEditorRef);

    }

    return null;

  }

  IEditorPart createPart(final EditorDescriptor desc)

      throws PartInitException {

    try {

      IEditorPart result = desc.createEditor();

      IConfigurationElement element = desc.getConfigurationElement();

      if (element != null) {

        page.getExtensionTracker().registerObject(

            element.getDeclaringExtension(), result,

            IExtensionTracker.REF_WEAK);

      }

      return result;

    } catch (CoreException e) {

      throw new PartInitException(StatusUtil.newStatus(

          desc.getPluginID(),

          WorkbenchMessages.EditorManager_instantiationError, e));

    }

  }

  /**

   * Open a system external editor on the input path.

   */

  private IEditorReference openSystemExternalEditor(final IPath location)

      throws PartInitException {

    if (location == null) {

      throw new IllegalArgumentException();

    }

    final boolean result[] = { false };

    BusyIndicator.showWhile(getDisplay(), new Runnable() {

      public void run() {

        if (location != null) {

          result[0] = Program.launch(location.toOSString());

        }

      }

    });

    if (!result[0]) {

      throw new PartInitException(NLS.bind(

          WorkbenchMessages.EditorManager_unableToOpenExternalEditor,

          location));

    }

    // We do not have an editor part for external editors

    return null;

  }

  ImageDescriptor findImage(EditorDescriptor desc, IPath path) {

    if (desc == null) {

      // @issue what should be the default image?

      return ImageDescriptor.getMissingImageDescriptor();

    }

    if (desc.isOpenExternal() && path != null) {

      return PlatformUI.getWorkbench().getEditorRegistry()

          .getImageDescriptor(path.toOSString());

    }

    return desc.getImageDescriptor();

  }

  /**

   * @see org.eclipse.ui.IPersistable

   */

  public IStatus restoreState(IMemento memento) {

    // Restore the editor area workbooks layout/relationship

    final MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID,

        IStatus.OK,

        WorkbenchMessages.EditorManager_problemsRestoringEditors, null);

    final String activeWorkbookID[] = new String[1];

    final ArrayList visibleEditors = new ArrayList(5);

    final IEditorReference activeEditor[] = new IEditorReference[1];

    IMemento areaMem = memento.getChild(IWorkbenchConstants.TAG_AREA);

    if (areaMem != null) {

      result.add(editorPresentation.restoreState(areaMem));

      activeWorkbookID[0] = areaMem

          .getString(IWorkbenchConstants.TAG_ACTIVE_WORKBOOK);

    }

    // Loop through the editors.

    IMemento[] editorMems = memento

        .getChildren(IWorkbenchConstants.TAG_EDITOR);

    for (int x = 0; x < editorMems.length; x++) {

      // for dynamic UI - call restoreEditorState to replace code which is

      // commented out

      restoreEditorState(editorMems[x], visibleEditors, activeEditor,

          result);

    }

    // restore the presentation

    if (areaMem != null) {

      result.add(editorPresentation.restorePresentationState(areaMem));

    }

    try {

      StartupThreading.runWithThrowable(new StartupRunnable(){

        public void runWithException() throws Throwable {

          // Update each workbook with its visible editor.

          for (int i = 0; i < visibleEditors.size(); i++) {

            setVisibleEditor((IEditorReference) visibleEditors.get(i),

                false);

          }

          // Update the active workbook

          if (activeWorkbookID[0] != null) {

            editorPresentation

                .setActiveEditorWorkbookFromID(activeWorkbookID[0]);

          }

          if (activeEditor[0] != null) {

            IWorkbenchPart editor = activeEditor[0].getPart(true);

            if (editor != null) {

              page.activate(editor);

            }

          }

        }});

    }

    catch (Throwable t) {

      // The exception is already logged.

      result

          .add(new Status(

              IStatus.ERROR,

              PlatformUI.PLUGIN_ID,

              0,

              WorkbenchMessages.EditorManager_exceptionRestoringEditor,

              t));

    }

   

    return result;

  }

  /**

   * Save all of the editors in the workbench. Return true if successful.

   * Return false if the user has canceled the command.

   * @param confirm true if the user should be prompted before the save

   * @param closing true if the page is being closed

   * @param addNonPartSources true if saveables from non-part sources should be saved too.

   * @return false if the user canceled or an error occurred while saving

   */

  public boolean saveAll(boolean confirm, boolean closing, boolean addNonPartSources) {

    // Get the list of dirty editors and views. If it is

    // empty just return.

    ISaveablePart[] parts = page.getDirtyParts();

    if (parts.length == 0) {

      return true;

    }

    // saveAll below expects a mutable list

    List dirtyParts = new ArrayList(parts.length);

    for (int i = 0; i < parts.length; i++) {

      dirtyParts.add(parts[i]);

    }

    // If confirmation is required ..

    return saveAll(dirtyParts, confirm, closing, addNonPartSources, window);

  }

  /**

   * Saves the given dirty editors and views, optionally prompting the user.

   *

   * @param dirtyParts

   *            the dirty views and editors

   * @param confirm

   *            <code>true</code> to prompt whether to save, <code>false</code>

   *            to save without prompting

   * @param closing

   *            <code>true</code> if the parts are being closed,

   *            <code>false</code> if just being saved without closing

   * @param addNonPartSources true if non-part sources should be saved too

   * @param window

   *            the window to use as the parent for the dialog that prompts to

   *            save multiple dirty editors and views

   * @return <code>true</code> on success, <code>false</code> if the user

   *         canceled the save or an error occurred while saving

   */

  public static boolean saveAll(List dirtyParts, boolean confirm, boolean closing,

      boolean addNonPartSources, final IWorkbenchWindow window) {

    return saveAll(dirtyParts, confirm, closing, addNonPartSources, window, window);

  }

 

  /**

   * Saves the given dirty editors and views, optionally prompting the user.

   *

   * @param dirtyParts

   *            the dirty views and editors

   * @param confirm

   *            <code>true</code> to prompt whether to save,

   *            <code>false</code> to save without prompting

   * @param closing

   *            <code>true</code> if the parts are being closed,

   *            <code>false</code> if just being saved without closing

   * @param addNonPartSources

   *            true if non-part sources should be saved too

   * @param runnableContext

   *            the context in which to run long-running operations

   * @param shellProvider

   *            providing the shell to use as the parent for the dialog that

   *            prompts to save multiple dirty editors and views

   * @return <code>true</code> on success, <code>false</code> if the user

   *         canceled the save

   */

  public static boolean saveAll(List dirtyParts, final boolean confirm, final boolean closing,

        boolean addNonPartSources, final IRunnableContext runnableContext, final IShellProvider shellProvider) {

    // clone the input list

    dirtyParts = new ArrayList(dirtyParts);

      List modelsToSave;

    if (confirm) {

      boolean saveable2Processed = false;

      // Process all parts that implement ISaveablePart2.

      // These parts are removed from the list after saving

      // them. We then need to restore the workbench to

      // its previous state, for now this is just last

      // active perspective.

      // Note that the given parts may come from multiple

      // windows, pages and perspectives.

      ListIterator listIterator = dirtyParts.listIterator();

      WorkbenchPage currentPage = null;

      Perspective currentPageOriginalPerspective = null;

      while (listIterator.hasNext()) {

        IWorkbenchPart part = (IWorkbenchPart) listIterator.next();

        if (part instanceof ISaveablePart2) {

          WorkbenchPage page = (WorkbenchPage) part.getSite()

              .getPage();

          if (!Util.equals(currentPage, page)) {

            if (currentPage != null

                && currentPageOriginalPerspective != null) {

              if (!currentPageOriginalPerspective

                  .equals(currentPage.getActivePerspective())) {

                currentPage

                    .setPerspective(currentPageOriginalPerspective

                        .getDesc());

              }

            }

            currentPage = page;

            currentPageOriginalPerspective = page

                .getActivePerspective();

          }

          if (confirm) {

            if (part instanceof IViewPart) {

              Perspective perspective = page

                  .getFirstPerspectiveWithView((IViewPart) part);

              if (perspective != null) {

                page.setPerspective(perspective.getDesc());

              }

            }

            // show the window containing the page?

            IWorkbenchWindow partsWindow = page

                .getWorkbenchWindow();

            if (partsWindow != partsWindow.getWorkbench()

                .getActiveWorkbenchWindow()) {

              Shell shell = partsWindow.getShell();

              if (shell.getMinimized()) {

                shell.setMinimized(false);

              }

              shell.setActive();

            }

            page.bringToTop(part);

          }

          // try to save the part

          int choice = SaveableHelper.savePart((ISaveablePart2) part,

              page.getWorkbenchWindow(), confirm);

          if (choice == ISaveablePart2.CANCEL) {

            // If the user cancels, don't restore the previous

            // workbench state, as that will

            // be an unexpected switch from the current state.

            return false;

          } else if (choice != ISaveablePart2.DEFAULT) {

            saveable2Processed = true;

            listIterator.remove();

          }

        }

      }

      // try to restore the workbench to its previous state

      if (currentPage != null && currentPageOriginalPerspective != null) {

        if (!currentPageOriginalPerspective.equals(currentPage

            .getActivePerspective())) {

          currentPage.setPerspective(currentPageOriginalPerspective

              .getDesc());

        }

      }

      // if processing a ISaveablePart2 caused other parts to be

      // saved, remove them from the list presented to the user.

      if (saveable2Processed) {

        listIterator = dirtyParts.listIterator();

        while (listIterator.hasNext()) {

          ISaveablePart part = (ISaveablePart) listIterator.next();

          if (!part.isDirty()) {

            listIterator.remove();

          }

        }

      }

            modelsToSave = convertToSaveables(dirtyParts, closing, addNonPartSources);

           

            // If nothing to save, return.

            if (modelsToSave.isEmpty()) {

        return true;

      }

      boolean canceled = SaveableHelper.waitForBackgroundSaveJobs(modelsToSave);

      if (canceled) {

        return false;

      }

            // Use a simpler dialog if there's only one

            if (modelsToSave.size() == 1) {

              Saveable model = (Saveable) modelsToSave.get(0);

        String message = NLS.bind(WorkbenchMessages.EditorManager_saveChangesQuestion, model.getName());

        // Show a dialog.

        String[] buttons = new String[] { IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL, IDialogConstants.CANCEL_LABEL };

        MessageDialog d = new MessageDialog(

          shellProvider.getShell(), WorkbenchMessages.Save_Resource,

          null, message, MessageDialog.QUESTION, buttons, 0);

       

        int choice = SaveableHelper.testGetAutomatedResponse();

        if (SaveableHelper.testGetAutomatedResponse() == SaveableHelper.USER_RESPONSE) {

          choice = d.open();

        }

        // Branch on the user choice.

        // The choice id is based on the order of button labels

        // above.

        switch (choice) {

        case ISaveablePart2.YES: // yes

          break;

        case ISaveablePart2.NO: // no

          return true;

        default:

        case ISaveablePart2.CANCEL: // cancel

          return false;

        }

            }

            else {

              ListSelectionDialog dlg = new ListSelectionDialog(

                      shellProvider.getShell(), modelsToSave,

                      new ArrayContentProvider(),

                      new WorkbenchPartLabelProvider(), RESOURCES_TO_SAVE_MESSAGE);

              dlg.setInitialSelections(modelsToSave.toArray());

              dlg.setTitle(SAVE_RESOURCES_TITLE);

 

              // this "if" statement aids in testing.

              if (SaveableHelper.testGetAutomatedResponse()==SaveableHelper.USER_RESPONSE) {

                int result = dlg.open();

                  //Just return false to prevent the operation continuing

                  if (result == IDialogConstants.CANCEL_ID) {

            return false;

          }

 

                  modelsToSave = Arrays.asList(dlg.getResult());

              }

            }

        }

        else {

          modelsToSave = convertToSaveables(dirtyParts, closing, addNonPartSources);

    }

        // If the editor list is empty return.

        if (modelsToSave.isEmpty()) {

      return true;

    }

   

    // Create save block.

        final List finalModels = modelsToSave;

    IRunnableWithProgress progressOp = new IRunnableWithProgress() {

      public void run(IProgressMonitor monitor) {

        IProgressMonitor monitorWrap = new EventLoopProgressMonitor(

            monitor);

        monitorWrap.beginTask("", finalModels.size()); //$NON-NLS-1$

        for (Iterator i = finalModels.iterator(); i.hasNext();) {

          Saveable model = (Saveable) i.next();

          // handle case where this model got saved as a result of saving another

          if (!model.isDirty()) {

            monitor.worked(1);

            continue;

          }

          SaveableHelper.doSaveModel(model, new SubProgressMonitor(monitorWrap, 1), shellProvider, closing || confirm);

          if (monitorWrap.isCanceled()) {

            break;

          }

        }

        monitorWrap.done();

      }

    };

    // Do the save.

    return SaveableHelper.runProgressMonitorOperation(

        WorkbenchMessages.Save_All, progressOp, runnableContext, shellProvider);

  }

  /**

   * For each part (view or editor) in the given list, attempts to convert it

   * to one or more saveable models. Duplicate models are removed. If closing

   * is true, then models that will remain open in parts other than the given

   * parts are removed.

   *

   * @param parts

   *            the parts (list of IViewPart or IEditorPart)

   * @param closing

   *            whether the parts are being closed

   * @param addNonPartSources

   *            whether non-part sources should be added (true for the Save

   *            All action, see bug 139004)

   * @return the dirty models

   */

  private static List convertToSaveables(List parts, boolean closing, boolean addNonPartSources) {

    ArrayList result = new ArrayList();

    HashSet seen = new HashSet();

    for (Iterator i = parts.iterator(); i.hasNext();) {

      IWorkbenchPart part = (IWorkbenchPart) i.next();

      Saveable[] saveables = getSaveables(part);

      for (int j = 0; j < saveables.length; j++) {

        Saveable saveable = saveables[j];

        if (saveable.isDirty() && !seen.contains(saveable)) {

          seen.add(saveable);

          if (!closing

              || closingLastPartShowingModel(saveable, parts, part

                  .getSite().getPage())) {

            result.add(saveable);

          }

        }

      }

    }

    if (addNonPartSources) {

      SaveablesList saveablesList = (SaveablesList) PlatformUI

          .getWorkbench().getService(

              ISaveablesLifecycleListener.class);

      ISaveablesSource[] nonPartSources = saveablesList

          .getNonPartSources();

      for (int i = 0; i < nonPartSources.length; i++) {

        Saveable[] saveables = nonPartSources[i].getSaveables();

        for (int j = 0; j < saveables.length; j++) {

          Saveable saveable = saveables[j];

          if (saveable.isDirty() && !seen.contains(saveable)) {

            seen.add(saveable);

            result.add(saveable);

          }

        }

      }

    }

    return result;

  }

  /**

   * Returns the saveable models provided by the given part.

   * If the part does not provide any models, a default model

   * is returned representing the part.

   *

   * @param part the workbench part

   * @return the saveable models

   */

  private static Saveable[] getSaveables(IWorkbenchPart part) {

    if (part instanceof ISaveablesSource) {

      ISaveablesSource source = (ISaveablesSource) part;

      return source.getSaveables();

    }

    return new Saveable[] { new DefaultSaveable(part) };

  }

  /**

   * Returns true if, in the given page, no more parts will reference the

   * given model if the given parts are closed.

   *

   * @param model

   *            the model

   * @param closingParts

   *            the parts being closed (list of IViewPart or IEditorPart)

   * @param page

   *            the page

   * @return <code>true</code> if no more parts in the page will reference