/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *******************************************************************************/
package org.eclipse.ui.internal;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.IHandler;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler;
import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.program.Program;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.ActiveShellExpression;
import org.eclipse.ui.IEditorActionBarContributor;
import org.eclipse.ui.IEditorDescriptor;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorLauncher;
import org.eclipse.ui.IEditorMatchingStrategy;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IEditorRegistry;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPathEditorInput;
import org.eclipse.ui.IPersistableElement;
import org.eclipse.ui.IReusableEditor;
import org.eclipse.ui.ISaveablePart;
import org.eclipse.ui.ISaveablePart2;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.ListSelectionDialog;
import org.eclipse.ui.handlers.IHandlerActivation;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.internal.dialogs.EventLoopProgressMonitor;
import org.eclipse.ui.internal.editorsupport.ComponentSupport;
import org.eclipse.ui.internal.misc.Assert;
import org.eclipse.ui.internal.misc.ExternalEditor;
import org.eclipse.ui.internal.misc.StatusUtil;
import org.eclipse.ui.internal.misc.UIStats;
import org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog;
import org.eclipse.ui.internal.registry.EditorDescriptor;
import org.eclipse.ui.internal.util.Util;
import org.eclipse.ui.model.AdaptableList;
import org.eclipse.ui.model.BaseWorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchPartLabelProvider;
import org.eclipse.ui.part.MultiEditor;
import org.eclipse.ui.part.MultiEditorInput;

/**
 * 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 responsabilities to the editor itself.
 *
 * <ol>
 * <li>The editor should determine its own title.</li>
 * <li>The editor shoudl 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>
 */
public class EditorManager implements IExtensionChangeHandler {
    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;

    private static final String RESOURCES_TO_SAVE_MESSAGE = WorkbenchMessages.EditorManager_saveResourcesMessage; 

    private 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().getAdapter(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
					if (WorkbenchPlugin.getDefault().getPreferenceStore()
							.getBoolean(
									IPreferenceConstants.REUSE_EDITORS_BOOLEAN)) {
                        
                        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().getAdapter(IHandlerService.class);
			pinEditorHandlerActivation = handlerService.activateHandler(
					"org.eclipse.ui.window.pinEditor", pinEditorHandler, //$NON-NLS-1$
					new ActiveShellExpression(shell),
					ActiveShellExpression.SOURCES);
        }
    }

    /**
	 * 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) {
        // 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(
                (WWinActionBars) page.getActionBars(), 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() {
        // 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(
                (WWinActionBars) page.getActionBars(), 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
            if (window.getCoolBarManager() != null) {
                window.getCoolBarManager().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, WorkbenchPage.MATCH_INPUT);
    }
    
    /**
     * Returns an open editor matching the given editor input.  
     * If none match, returns <code>null</code>.
     * 
     * @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) {
    	if (matchFlags == WorkbenchPage.MATCH_NONE) {
    		return null;
    	}
    	ArrayList othersList = new ArrayList(Arrays.asList(page.getEditorReferences()));
    	if (othersList.isEmpty()) {
    		return null;
    	}
    	IEditorReference active = page.getActiveEditorReference();
    	if (active != null) {
	    	othersList.remove(active);
	    	ArrayList activeList = new ArrayList(1);
	    	activeList.add(active);
    		IEditorPart match = findEditor(editorId, input, activeList, matchFlags);
    		if (match != null) {
    			return match;
    		}
    	}
    	return findEditor(editorId, input, othersList, matchFlags);
    }
    
    /**
     * 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) 
     * @return the matching editor, or <code>null</code> if no match fond
     * @since 3.1
     */
    private IEditorPart findEditor(String editorId, IEditorInput input, ArrayList editorList, int matchFlags) {

    	// Phase 0: Remove editors whose ids don't match (if matching by id)
        if (((matchFlags & WorkbenchPage.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 first match, or null if none.  
        // In practice, this case is never used.
        if ((matchFlags & WorkbenchPage.MATCH_INPUT) == 0) {
        	return editorList.isEmpty() ? null : ((IEditorReference) editorList.get(0)).getEditor(true);
        }

        // 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)) {
                        return editor.getEditor(true);
                    }
                }
            }
        }
        
        // Phase 2: check materialized editors (without their own matching strategy)
        for (Iterator i = editorList.iterator(); i.hasNext();) {
            EditorReference editor = (EditorReference) 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)) {
                    return part;
                }
            }
        }
        
        // 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 null;
        String id = persistable.getFactoryId();
        if (id == null)
            return null;
        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)) {
                        return editor.getEditor(true);
                    }
                } catch (PartInitException e1) {
                    WorkbenchPlugin.log(e1);
                }
            }
        }
        return null;
    }

    /**
     * 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) {

        IEditorReference editors[] = page.getSortedEditors();
        IPreferenceStore store = WorkbenchPlugin.getDefault()
                .getPreferenceStore();
        boolean reuse = store
                .getBoolean(IPreferenceConstants.REUSE_EDITORS_BOOLEAN);
        if (!reuse)
            return null;

        if (editors.length < page.getEditorReuseThreshold())
            return null;

        IEditorReference dirtyEditor = null;

        //Find a editor to be reused
        for (int i = 0; i < editors.length; i++) {
            IEditorReference editor = editors[i];
            //		if(editor == activePart)
            //			continue;
            if (editor.isPinned())
                continue;
            if (editor.isDirty()) {
                if (dirtyEditor == null) //ensure least recently used
                    dirtyEditor = editor;
                continue;
            }
            return editor;
        }
        if (dirtyEditor == null)
            return null;

        /*fix for 11122*/
        boolean reuseDirty = store
                .getBoolean(IPreferenceConstants.REUSE_DIRTY_EDITORS);
        if (!reuseDirty)
            return null;

        MessageDialog dialog = new MessageDialog(
                window.getShell(),
                WorkbenchMessages.EditorManager_reuseEditorDialogTitle, null, // accept the default window icon
                NLS.bind(WorkbenchMessages.EditorManager_saveChangesQuestion, dirtyEditor.getName()), 
                MessageDialog.QUESTION,
                new String[] {
                        IDialogConstants.YES_LABEL,
                        IDialogConstants.NO_LABEL,
                        WorkbenchMessages.EditorManager_openNewEditorLabel }, 
                0);
        int result = dialog.open();
        if (result == 0) { //YES
            ProgressMonitorDialog pmd = new ProgressMonitorJobsDialog(dialog
                    .getShell());
            pmd.open();
            dirtyEditor.getEditor(true).doSave(pmd.getProgressMonitor());
            pmd.close();
        } else if ((result == 2) || (result == -1)) {
            return null;
        }
        return dirtyEditor;
    }

    /*
     * See IWorkbenchPage.
     */
    public IEditorReference openEditor(String editorId, IEditorInput input,
            boolean setVisible) 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);
        return result;
    }

    /*
     * Open a new editor
     */
    private IEditorReference openEditorFromDescriptor(
            EditorDescriptor desc, IEditorInput input) throws PartInitException {
        IEditorReference result = null;
        if (desc.isInternal()) {
            result = reuseInternalEditor(desc, input);
            if (result == null) {
                result = new EditorReference(this, input, desc);
            }
        } 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) {
            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 ref
     * @param part the part
     * @param input the MultiEditor input
     * @return the array of inner references to store in the MultiEditor ref
     */
    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));
        else
            site.setActionBars(createEmptyEditorActionBars());

        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) {
            IEditorPart reusableEditor = reusableEditorRef.getEditor(false);
            if (reusableEditor == null) {
                IEditorReference result = new EditorReference(this, input, desc);
                page.closeEditor(reusableEditorRef, false);
                return result;
            }

            EditorSite site = (EditorSite) reusableEditor.getEditorSite();
            EditorDescriptor oldDesc = site.getEditorDescriptor();
            if ((desc.getId().equals(oldDesc.getId()))
                    && (reusableEditor instanceof IReusableEditor)) {
                Workbench wb = (Workbench) window.getWorkbench();
                editorPresentation.moveEditor(reusableEditor, -1);
                wb.getEditorHistory().add(reusableEditor.getEditorInput(),
                        site.getEditorDescriptor());
                page.reuseEditor((IReusableEditor) reusableEditor, input);
                return reusableEditorRef;
            } else {
                //findReusableEditor(...) checks pinned and saves editor if necessary
                IEditorReference ref = new EditorReference(this, input, desc);
                reusableEditor.getEditorSite().getPage().closeEditor(
                        reusableEditor, false);
                return ref;
            }
        }
        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;
    }

    /**
     * Opens a system in place editor on the input.
     */
    private IEditorReference openSystemInPlaceEditor(IEditorReference ref,
            EditorDescriptor desc, IEditorInput input) throws PartInitException {
        IEditorPart cEditor = ComponentSupport.getSystemInPlaceEditor();
        if (cEditor == null) {
            return null;
        } else {
            return ref;
        }
    }

    ImageDescriptor findImage(EditorDescriptor desc, IPath path) {
        if (desc == null) {
            // @issue what should be the default image?
            return ImageDescriptor.getMissingImageDescriptor();
        } else {
            if (desc.isOpenExternal() && path != null) {
                return PlatformUI.getWorkbench().getEditorRegistry()
                        .getImageDescriptor(path.toOSString());
            } else {
                return desc.getImageDescriptor();
            }
        }
    }

    /**
     * @see IPersistablePart
     */
    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];
        final ArrayList errorWorkbooks = new ArrayList(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));
        }

        Platform.run(new SafeRunnable() {
            public void run() {
                // 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);
                    }
                }
            }

            public void handleException(Throwable e) {
                //The exception is already logged.
                result
                        .add(new Status(
                                IStatus.ERROR,
                                PlatformUI.PLUGIN_ID,
                                0,
                                WorkbenchMessages.EditorManager_exceptionRestoringEditor, e));
            }
        });
        return result;
    }

    /**
     * Save all of the editors in the workbench.  
     * Return true if successful.  Return false if the
     * user has cancelled the command.
     */
    public boolean saveAll(boolean confirm, boolean closing) {
        // 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, window);
    }

    /**
     * Saves the given dirty editors and views, optionally prompting the user.
     * 
     * @param dirtyParts the dirty views and editors
     * @param confirm <code>true</code> prompt whether to save, <code>false</code> to save without prompting 
     * @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
     */
    public static boolean saveAll(List dirtyParts, boolean confirm,
            final IWorkbenchWindow window) {
        if (confirm) {
         	// 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
					if (!SaveableHelper.savePart((ISaveablePart2) part, part, page.getWorkbenchWindow(), confirm)) {
						// If the user cancels, don't restore the previous workbench state, as that will
						// be an unexpected switch from the current state.
						return false;
					}
                	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 the editor list is empty return.
            if (dirtyParts.isEmpty())
            	return true;
            
            // Convert the list into an element collection.
            AdaptableList input = new AdaptableList(dirtyParts);

            ListSelectionDialog dlg = new ListSelectionDialog(
                    window.getShell(), input,
                    new BaseWorkbenchContentProvider(),
                    new WorkbenchPartLabelProvider(), RESOURCES_TO_SAVE_MESSAGE);

            dlg.setInitialSelections(dirtyParts
                    .toArray(new Object[dirtyParts.size()]));
            dlg.setTitle(SAVE_RESOURCES_TITLE);
            int result = dlg.open();

            //Just return false to prevent the operation continuing
            if (result == IDialogConstants.CANCEL_ID)
                return false;

            dirtyParts = Arrays.asList(dlg.getResult());
            if (dirtyParts == null)
                return false;

            // If the editor list is empty return.
            if (dirtyParts.isEmpty())
                return true;
        }

        // Create save block.
        // @issue reference to workspace runnable!
        final List finalParts = dirtyParts;
        /*		final IWorkspaceRunnable workspaceOp = new IWorkspaceRunnable() {
         public void run(IProgressMonitor monitor) {
         monitor.beginTask("", finalEditors.size()); //$NON-NLS-1$
         Iterator enum = finalEditors.iterator();
         while (enum.hasNext()) {
         IEditorPart part = (IEditorPart) enum.next();
         part.doSave(new SubProgressMonitor(monitor, 1));
         if (monitor.isCanceled())
         break;
         }
         }
         };
         */
        IRunnableWithProgress progressOp = new IRunnableWithProgress() {
            public void run(IProgressMonitor monitor) {
                //				try {
                // @issue reference to workspace to run runnable
                IProgressMonitor monitorWrap = new EventLoopProgressMonitor(
                        monitor);
                //					ResourcesPlugin.getWorkspace().run(workspaceOp, monitorWrap);

                //--------- This code was in the IWorkspaceRunnable above
                monitorWrap.beginTask("", finalParts.size()); //$NON-NLS-1$
                Iterator itr = finalParts.iterator();
                while (itr.hasNext()) {
                    ISaveablePart part = (ISaveablePart) itr.next();
                    part.doSave(new SubProgressMonitor(monitorWrap, 1));
                    if (monitorWrap.isCanceled())
                        break;
                }
                //-----------
                monitorWrap.done();
                /*				} catch (CoreException e) {
                 IStatus status = new Status(Status.WARNING, PlatformUI.PLUGIN_ID, 0, WorkbenchMessages.getString("EditorManager.saveFailed"), e); //$NON-NLS-1$
                 WorkbenchPlugin.log(WorkbenchMessages.getString("EditorManager.saveFailed"), status); //$NON-NLS-1$
                 ErrorDialog.openError(
                 window.getShell(), 
                 WorkbenchMessages.getString("Error"), //$NON-NLS-1$
                 WorkbenchMessages.format("EditorManager.saveFailedMessage", new Object[] { e.getMessage()}), //$NON-NLS-1$
                 e.getStatus());
                 }
                 */
            }
        };

        // Do the save.
        return SaveableHelper.runProgressMonitorOperation(WorkbenchMessages.Save_All, progressOp, window);
    }

    /*
     * Saves the workbench part.
     */
    public boolean savePart(final ISaveablePart saveable, IWorkbenchPart part,
            boolean confirm) {
		return SaveableHelper.savePart(saveable, part, window, confirm);
    }

    /**
     * Save and close an editor.
     * Return true if successful.  Return false if the
     * user has cancelled the command.
     */
    public boolean saveEditor(IEditorPart part, boolean confirm) {
        return savePart(part, part, confirm);
    }

    /**
     * @see IPersistablePart
     */
    public IStatus saveState(final IMemento memento) {

        final MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID,
                IStatus.OK, WorkbenchMessages.EditorManager_problemsSavingEditors, null); 

        // Save the editor area workbooks layout/relationship
        IMemento editorAreaMem = memento
                .createChild(IWorkbenchConstants.TAG_AREA);
        result.add(editorPresentation.saveState(editorAreaMem));

        // Save the active workbook id
        editorAreaMem.putString(IWorkbenchConstants.TAG_ACTIVE_WORKBOOK,
                editorPresentation.getActiveEditorWorkbookID());

        // Get each workbook
        ArrayList workbooks = editorPresentation.getWorkbooks();

        for (Iterator iter = workbooks.iterator(); iter.hasNext();) {
            EditorStack workbook = (EditorStack) iter.next();

            // Use the list of editors found in EditorStack; fix for 24091
            EditorPane editorPanes[] = workbook.getEditors();

            for (int i = 0; i < editorPanes.length; i++) {
                // Save each open editor.
                IEditorReference editorReference = editorPanes[i]
                        .getEditorReference();
                EditorReference e = (EditorReference) editorReference;
                final IEditorPart editor = editorReference.getEditor(false);
                if (editor == null) {
                    if (e.getMemento() != null) {
                        IMemento editorMem = memento
                                .createChild(IWorkbenchConstants.TAG_EDITOR);
                        editorMem.putMemento(e.getMemento());
                    }
                    continue;
                }

                //for dynamic UI - add the next line to replace the subsequent code which is commented out
                saveEditorState(memento, e, result);
            }
        }
        return result;
    }

    /**
     * Shows an editor.  If <code>setFocus == true</code> then
     * give it focus, too.
     *
     * @return true if the active editor was changed, false if not.
     */
    public boolean setVisibleEditor(IEditorReference newEd, boolean setFocus) {
        return editorPresentation.setVisibleEditor(newEd, setFocus);
    }

    private IPathEditorInput getPathEditorInput(IEditorInput input) {
        if (input instanceof IPathEditorInput) {
            return (IPathEditorInput) input;
        }

        return (IPathEditorInput) input.getAdapter(IPathEditorInput.class);
    }

    private class InnerEditor extends EditorReference {
        
        private IEditorReference outerEditor;
        
        public InnerEditor(IEditorReference outerEditor, IEditorInput input, EditorDescriptor desc) {
            super(EditorManager.this, input, desc);
            this.outerEditor = outerEditor;
        }
        
        protected PartPane createPane() {
            return new MultiEditorInnerPane((EditorPane)((EditorReference)outerEditor).getPane(),
                    this, page, editorPresentation.getActiveWorkbook());
        }
       
    }

    protected void restoreEditorState(IMemento editorMem,
            ArrayList visibleEditors, IEditorReference[] activeEditor,
            MultiStatus result) {
//        String strFocus = editorMem.getString(IWorkbenchConstants.TAG_FOCUS);
//        boolean visibleEditor = "true".equals(strFocus); //$NON-NLS-1$
        EditorReference e = new EditorReference(this, editorMem);
        
        //if the editor is not visible, ensure it is put in the correct workbook. PR 24091
        
        String workbookID = editorMem.getString(IWorkbenchConstants.TAG_WORKBOOK);
        
        try {
            createEditorTab(e, workbookID);
        } catch (PartInitException ex) {
            result.add(ex.getStatus());
        }
        
      String strActivePart = editorMem.getString(IWorkbenchConstants.TAG_ACTIVE_PART);
      if ("true".equals(strActivePart)) //$NON-NLS-1$
          activeEditor[0] = e;
     
      String strFocus = editorMem.getString(IWorkbenchConstants.TAG_FOCUS);
      boolean visibleEditor = "true".equals(strFocus); //$NON-NLS-1$
      if (visibleEditor) {
          visibleEditors.add(e);
      }      
    }

    //for dynamic UI
    protected void saveEditorState(IMemento mem, IEditorReference ed,
            MultiStatus res) {
        final EditorReference editorRef = (EditorReference) ed;
        final IEditorPart editor = ed.getEditor(false);
        final IMemento memento = mem;
        final MultiStatus result = res;
        final EditorSite site = (EditorSite) editor.getEditorSite();
        if (site.getPane() instanceof MultiEditorInnerPane)
            return;

        Platform.run(new SafeRunnable() {
            public void run() {
                // Get the input.
                IEditorInput input = editor.getEditorInput();
                IPersistableElement persistable = input.getPersistable();
                if (persistable == null)
                    return;

                // Save editor.
                IMemento editorMem = memento
                        .createChild(IWorkbenchConstants.TAG_EDITOR);
                editorMem.putString(IWorkbenchConstants.TAG_TITLE, editorRef
                        .getTitle());
                editorMem.putString(IWorkbenchConstants.TAG_NAME, editorRef
                        .getName());
                editorMem.putString(IWorkbenchConstants.TAG_ID, editorRef
                        .getId());
                editorMem.putString(IWorkbenchConstants.TAG_TOOLTIP, editorRef
                        .getTitleToolTip());

                editorMem.putString(IWorkbenchConstants.TAG_PART_NAME,
                        editorRef.getPartName());

                if (editorRef.isPinned())
                    editorMem.putString(IWorkbenchConstants.TAG_PINNED, "true"); //$NON-NLS-1$

                EditorPane editorPane = (EditorPane) ((EditorSite) editor
                        .getEditorSite()).getPane();
                editorMem.putString(IWorkbenchConstants.TAG_WORKBOOK,
                        editorPane.getWorkbook().getID());

                if (editor == page.getActivePart())
                    editorMem.putString(IWorkbenchConstants.TAG_ACTIVE_PART,
                            "true"); //$NON-NLS-1$

                if (editorPane == editorPane.getWorkbook().getSelection())
                    editorMem.putString(IWorkbenchConstants.TAG_FOCUS, "true"); //$NON-NLS-1$

                // TODO - DDW - dynamic UI - a check for a null input was deliberately removed here.
                if (input instanceof IPathEditorInput) {
                    editorMem.putString(IWorkbenchConstants.TAG_PATH,
                            ((IPathEditorInput) input).getPath().toString());
                }

                // Save input.
                IMemento inputMem = editorMem
                        .createChild(IWorkbenchConstants.TAG_INPUT);
                inputMem.putString(IWorkbenchConstants.TAG_FACTORY_ID,
                        persistable.getFactoryId());
                persistable.saveState(inputMem);
            }

            public void handleException(Throwable e) {
                result
                        .add(new Status(
                                IStatus.ERROR,
                                PlatformUI.PLUGIN_ID,
                                0,
                                NLS.bind(WorkbenchMessages.EditorManager_unableToSaveEditor, editorRef.getTitle() ), e));
            }
        });
    }

    //for dynamic UI
    public IMemento getMemento(IEditorReference e) {
        if (e instanceof EditorReference)
            return ((EditorReference) e).getMemento();
        return null;
    }
	
    /* (non-Javadoc)
     * @see org.eclipse.core.runtime.dynamicHelpers.IExtensionChangeHandler#removeExtension(org.eclipse.core.runtime.IExtension, java.lang.Object[])
     */
    public void removeExtension(IExtension source, Object[] objects) {
        for (int i = 0; i < objects.length; i++) {
            if (objects[i] instanceof IEditorPart) {
                // close the editor and clean up the editor history

                IEditorPart editor = (IEditorPart) objects[i];
                IEditorInput input = editor.getEditorInput();
                page.closeEditor(editor, true);
                ((Workbench) window.getWorkbench()).getEditorHistory().remove(input);
            }
        }
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.core.runtime.dynamicHelpers.IExtensionChangeHandler#addExtension(org.eclipse.core.runtime.dynamicHelpers.IExtensionTracker, org.eclipse.core.runtime.IExtension)
     */
    public void addExtension(IExtensionTracker tracker,IExtension extension) {
        //Nothing to do
    }
}