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

package org.eclipse.ui.internal;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.Geometry;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IPerspectiveFactory;
import org.eclipse.ui.IPlaceholderFolderLayout;
import org.eclipse.ui.IViewLayout;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchPreferenceConstants;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.XMLMemento;
import org.eclipse.ui.contexts.IContextService;
import org.eclipse.ui.internal.StartupThreading.StartupRunnable;
import org.eclipse.ui.internal.contexts.ContextAuthority;
import org.eclipse.ui.internal.intro.IIntroConstants;
import org.eclipse.ui.internal.layout.ITrimManager;
import org.eclipse.ui.internal.layout.IWindowTrim;
import org.eclipse.ui.internal.layout.TrimLayout;
import org.eclipse.ui.internal.misc.StatusUtil;
import org.eclipse.ui.internal.registry.ActionSetRegistry;
import org.eclipse.ui.internal.registry.IActionSetDescriptor;
import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;
import org.eclipse.ui.internal.registry.PerspectiveDescriptor;
import org.eclipse.ui.internal.registry.PerspectiveExtensionReader;
import org.eclipse.ui.internal.registry.PerspectiveRegistry;
import org.eclipse.ui.internal.registry.StickyViewDescriptor;
import org.eclipse.ui.internal.util.PrefUtil;
import org.eclipse.ui.presentations.AbstractPresentationFactory;
import org.eclipse.ui.presentations.IStackPresentationSite;
import org.eclipse.ui.statushandlers.StatusManager;
import org.eclipse.ui.views.IStickyViewDescriptor;
import org.eclipse.ui.views.IViewDescriptor;
import org.eclipse.ui.views.IViewRegistry;

/**
 * The ViewManager is a factory for workbench views.  
 */
public class Perspective {
    protected PerspectiveDescriptor descriptor;

    protected WorkbenchPage page;

    // Editor Area management
    protected LayoutPart editorArea;
    protected PartPlaceholder editorHolder;
    protected boolean editorHidden = false;
    protected boolean editorAreaRestoreOnUnzoom = false;
    protected int editorAreaState = IStackPresentationSite.STATE_RESTORED;

    private ViewFactory viewFactory;
    
    protected ArrayList alwaysOnActionSets;

    protected ArrayList alwaysOffActionSets;

    protected ArrayList newWizardShortcuts;

    protected ArrayList showViewShortcuts;

    protected ArrayList perspectiveShortcuts;

    //private List fastViews;
    protected FastViewManager fastViewManager = null;

    private Map mapIDtoViewLayoutRec;

    protected boolean fixed;

    protected ArrayList showInPartIds;

    protected HashMap showInTimes = new HashMap();

    private IViewReference activeFastView;

    protected IMemento memento;

    protected PerspectiveHelper presentation;

    final static private String VERSION_STRING = "0.016";//$NON-NLS-1$

    private FastViewPane fastViewPane = new FastViewPane();

    // fields used by fast view resizing via a sash
    private static final int FASTVIEW_HIDE_STEPS = 5;

    /**
     * Reference to the part that was previously active
     * when this perspective was deactivated.
     */
    private IWorkbenchPartReference oldPartRef = null;

    protected boolean shouldHideEditorsOnActivate = false;

	protected PageLayout layout;

    /**
     * ViewManager constructor comment.
     */
    public Perspective(PerspectiveDescriptor desc, WorkbenchPage page)
            throws WorkbenchException {
        this(page);
        descriptor = desc;
        if (desc != null) {
			createPresentation(desc);
		}
    }

    /**
     * ViewManager constructor comment.
     */
    protected Perspective(WorkbenchPage page) throws WorkbenchException {
        this.page = page;
        this.editorArea = page.getEditorPresentation().getLayoutPart();
        this.viewFactory = page.getViewFactory();
        alwaysOnActionSets = new ArrayList(2);
        alwaysOffActionSets = new ArrayList(2);
        
        // We'll only make a FastView Manager if there's a
        // Trim manager in the WorkbenchWindow
        IWorkbenchWindow wbw = page.getWorkbenchWindow();
        if (wbw instanceof WorkbenchWindow) {
        	if (((WorkbenchWindow)wbw).getTrimManager() != null)
        		fastViewManager = new FastViewManager(this, page);        	
        }
        
        mapIDtoViewLayoutRec = new HashMap();
    }

	/**
	 * Sets the fast view attribute. Note: The page is expected to update action
	 * bars.
	 */
	public void makeFastView(IViewReference ref) {
		addFastView(ref, true);
	}
	
	/**
	 * Sets the fast view attribute. Note: The page is expected to update action
	 * bars.
	 */
	public void addFastView(IViewReference ref, boolean handleLayout) {
		ViewPane pane = (ViewPane) ((WorkbenchPartReference) ref).getPane();
		if (!isFastView(ref)) {
			if (handleLayout) {
				// Only remove the part from the presentation if it
				// is actually in the presentation.
				if (presentation.hasPlaceholder(ref.getId(), ref.getSecondaryId())
						|| pane.getContainer() != null) {
					presentation.removePart(pane);
				}
			}
			
			// We are drag-enabling the pane because it has been disabled
			// when it was removed from the perspective presentation.
			pane.setFast(true);
			Control ctrl = pane.getControl();
			if (ctrl != null) {
				ctrl.setEnabled(false); // Remove focus support.
			}
		}
	}

    /**
     * Moves a part forward in the Z order of a perspective so it is visible.
     *
     * @param part the part to bring to move forward
     * @return true if the part was brought to top, false if not.
     */
    public boolean bringToTop(IViewReference ref) {
        if (isFastView(ref)) {
            setActiveFastView(ref);
            return true;
        } else {
            return presentation.bringPartToTop(getPane(ref));
        }
    }

    /**
     * Returns whether a view exists within the perspective.
     */
    public boolean containsView(IViewPart view) {
        IViewSite site = view.getViewSite();
        IViewReference ref = findView(site.getId(), site.getSecondaryId());
        if (ref == null) {
			return false;
		}
        return (view == ref.getPart(false));
    }

    /**
     * Create the initial list of action sets.
     */
    protected void createInitialActionSets(List outputList, List stringList) {
        ActionSetRegistry reg = WorkbenchPlugin.getDefault()
                .getActionSetRegistry();
        Iterator iter = stringList.iterator();
        while (iter.hasNext()) {
            String id = (String) iter.next();
            IActionSetDescriptor desc = reg.findActionSet(id);
            if (desc != null) {
				outputList.add(desc);
			} else {
				WorkbenchPlugin.log("Unable to find Action Set: " + id);//$NON-NLS-1$
			}
        }
    }

    /**
     * Create a presentation for a perspective.
     */
    private void createPresentation(PerspectiveDescriptor persp)
            throws WorkbenchException {
        if (persp.hasCustomDefinition()) {
            loadCustomPersp(persp);
        } else {
            loadPredefinedPersp(persp);
        }
    }

    /**
     * Dispose the perspective and all views contained within.
     */
    public void dispose() {
        // Get rid of presentation.
        if (presentation == null) {
			return;
		}

        presentation.deactivate();
        presentation.dispose();

        fastViewPane.dispose();
        
        // Release each view.
        IViewReference refs[] = getViewReferences();
        for (int i = 0, length = refs.length; i < length; i++) {
            getViewFactory().releaseView(refs[i]);
        }

        mapIDtoViewLayoutRec.clear();
    }

    /**
     * Finds the view with the given ID that is open in this page, or <code>null</code>
     * if not found.
     * 
     * @param viewId the view ID
     */
    public IViewReference findView(String viewId) {
        return findView(viewId, null);
    }

    /**
     * Finds the view with the given id and secondary id that is open in this page, 
     * or <code>null</code> if not found.
     * 
     * @param viewId the view ID
     * @param secondaryId the secondary ID
     */
    public IViewReference findView(String id, String secondaryId) {
        IViewReference refs[] = getViewReferences();
        for (int i = 0; i < refs.length; i++) {
            IViewReference ref = refs[i];
            if (id.equals(ref.getId())
                    && (secondaryId == null ? ref.getSecondaryId() == null
                            : secondaryId.equals(ref.getSecondaryId()))) {
				return ref;
			}
        }
        return null;
    }

    /**
     * Returns the window's client composite widget
     * which views and editor area will be parented.
     */
    public Composite getClientComposite() {
        return page.getClientComposite();
    }

    /**
     * Returns the perspective.
     */
    public IPerspectiveDescriptor getDesc() {
        return descriptor;
    }

    /**
     * Returns the bounds of the given fast view.
     */
    /*package*/Rectangle getFastViewBounds(IViewReference ref) {
        // Copy the bounds of the page composite
        Rectangle bounds = page.getClientComposite().getBounds();
        // get the width ratio of the fast view
        float ratio = getFastViewWidthRatio(ref);
        // Compute the actual width of the fast view.
        bounds.width = (int) (ratio * getClientComposite().getSize().x);
        return bounds;
    }

    /**
     * Returns the docked views.
     */
    public IViewReference[] getFastViews() {
    	if (fastViewManager == null)
    		return new IViewReference[0];
    	
    	List trueFVBRefs = fastViewManager.getFastViews(FastViewBar.FASTVIEWBAR_ID);
        IViewReference array[] = new IViewReference[trueFVBRefs.size()];
        trueFVBRefs.toArray(array);
        return array;
    }

    /**
     * Returns the new wizard shortcuts associated with this perspective.
     * 
     * @return an array of new wizard identifiers
     */
    public String[] getNewWizardShortcuts() {
        return (String[]) newWizardShortcuts.toArray(new String[newWizardShortcuts.size()]);
    }

    /**
     * Returns the pane for a view reference.
     */
    protected ViewPane getPane(IViewReference ref) {
        return (ViewPane) ((WorkbenchPartReference) ref).getPane();
    }

    /**
     * Returns the perspective shortcuts associated with this perspective.
     * 
     * @return an array of perspective identifiers
     */
    public String[] getPerspectiveShortcuts() {
        return (String[]) perspectiveShortcuts.toArray(new String[perspectiveShortcuts.size()]);
    }

    /**
     * Returns the presentation.
     */
    public PerspectiveHelper getPresentation() {
        return presentation;
    }

    /**
     * Retrieves the fast view width ratio for the given view. 
     * If the ratio is not known, the default ratio for the view is assigned and returned.
     */
    public float getFastViewWidthRatio(IViewReference ref) {
        ViewLayoutRec rec = getViewLayoutRec(ref, true);
        if (rec.fastViewWidthRatio == IPageLayout.INVALID_RATIO) {
            IViewRegistry reg = WorkbenchPlugin.getDefault().getViewRegistry();
            IViewDescriptor desc = reg.find(ref.getId());
            rec.fastViewWidthRatio = 
                (desc != null 
                    ? desc.getFastViewWidthRatio()
                    : IPageLayout.DEFAULT_FASTVIEW_RATIO);
        }
        return rec.fastViewWidthRatio;
    }

    /**
     * Returns the ids of the parts to list in the Show In... dialog.
     * This is a List of Strings.
     */
    public ArrayList getShowInPartIds() {
        return showInPartIds;
    }

    /**
     * Returns the time at which the last Show In was performed
     * for the given target part, or 0 if unknown.
     */
    public long getShowInTime(String partId) {
        Long t = (Long) showInTimes.get(partId);
        return t == null ? 0L : t.longValue();
    }

    /**
     * Returns the show view shortcuts associated with this perspective.
     * 
     * @return an array of view identifiers
     */
    public String[] getShowViewShortcuts() {
        return (String[]) showViewShortcuts.toArray(new String[showViewShortcuts.size()]);
    }

    /**
     * Returns the view factory.
     */
    public ViewFactory getViewFactory() {
        return viewFactory;
    }

    /**
     * See IWorkbenchPage.
     */
    public IViewReference[] getViewReferences() {
        // Get normal views.
        if (presentation == null) {
			return new IViewReference[0];
		}

        List panes = new ArrayList(5);
        presentation.collectViewPanes(panes);

        List fastViews = (fastViewManager != null) ? 
        					fastViewManager.getFastViews(null)
        					: new ArrayList();
        IViewReference[] resultArray = new IViewReference[panes.size()
                + fastViews.size()];

        // Copy fast views.
        int nView = 0;
        for (int i = 0; i < fastViews.size(); i++) {
            resultArray[nView] = (IViewReference) fastViews.get(i);
            ++nView;
        }

        // Copy normal views.
        for (int i = 0; i < panes.size(); i++) {
            ViewPane pane = (ViewPane) panes.get(i);
            resultArray[nView] = pane.getViewReference();
            ++nView;
        }

        return resultArray;
    }


    /**
     * Hide the editor area if visible
     */
    protected void hideEditorArea() {
        if (!isEditorAreaVisible()) {
			return;
		}
        
        // Show the editor in the appropriate location
        if (useNewMinMax(this)) {
        	// If it's the currently maximized part we have to restore first
        	if (getPresentation().getMaximizedStack() instanceof EditorStack) {
        		getPresentation().getMaximizedStack().setState(IStackPresentationSite.STATE_RESTORED);
        	}
        	
        	boolean isMinimized = editorAreaState == IStackPresentationSite.STATE_MINIMIZED;
        	if (!isMinimized)
        		hideEditorAreaLocal();
        	else
        		setEditorAreaTrimVisibility(false);
        }
        else {
        	hideEditorAreaLocal();
        }
        
        editorHidden = true;
    }

    /**
     * Hide the editor area if visible
     */
    protected void hideEditorAreaLocal() {
        if (editorHolder != null) {
			return;
		}

        // Replace the editor area with a placeholder so we
        // know where to put it back on show editor area request.
        editorHolder = new PartPlaceholder(editorArea.getID());
        presentation.getLayout().replace(editorArea, editorHolder);
    }

    /**
     * Hides a fast view. The view shrinks equally <code>steps</code> times
     * before disappearing completely.
     */
    private void hideFastView(IViewReference ref, int steps) {
        setFastViewIconSelection(ref, false);

        // Note: We always do at least one step of the animation.
        // Note: This doesn't take into account the overhead of doing
        if (ref == activeFastView) {
            saveFastViewWidthRatio();
            fastViewPane.hideView();
        }
    }

    /**
     * Hides the fast view sash for zooming in a fast view.
     */
    void hideFastViewSash() {
        fastViewPane.hideFastViewSash();
    }

    public boolean hideView(IViewReference ref) {
        // If the view is locked just return.
        ViewPane pane = getPane(ref);

        // Remove the view from the current presentation.
        if (isFastView(ref)) {
            if (pane != null) {
				pane.setFast(false); //force an update of the toolbar
			}
            if (activeFastView == ref) {
				setActiveFastView(null);
			}
            if (pane != null) {
				pane.getControl().setEnabled(true);
			}
        } else {
            presentation.removePart(pane);
        }

        // Dispose view if ref count == 0.
        getViewFactory().releaseView(ref);
        return true;
    }

    /*
     * Return whether the editor area is visible or not.
     */
    protected boolean isEditorAreaVisible() {
        return !editorHidden;
    }

    /**
     * Returns true if a view is fast.
     */
    public boolean isFastView(IViewReference ref) {
    	if (fastViewManager == null)
    		return false;
    	
        return fastViewManager.isFastView(ref);
    }

    /**
     * Returns the view layout rec for the given view reference,
     * or null if not found.  If create is true, it creates the record
     * if not already created.
     */
    public ViewLayoutRec getViewLayoutRec(IViewReference ref, boolean create) {
        ViewLayoutRec result = getViewLayoutRec(ViewFactory.getKey(ref), create);
        if (result == null && create==false) {
        	result = getViewLayoutRec(ref.getId(), false);
        }
        return result;
    }

    /**
     * Returns the view layout record for the given view id
     * or null if not found.  If create is true, it creates the record
     * if not already created.
     */
    private ViewLayoutRec getViewLayoutRec(String viewId, boolean create) {
        ViewLayoutRec rec = (ViewLayoutRec) mapIDtoViewLayoutRec.get(viewId);
        if (rec == null && create) {
            rec = new ViewLayoutRec();
            mapIDtoViewLayoutRec.put(viewId, rec);
        }
        return rec;
    }

    /**
     * Returns true if a layout or perspective is fixed.
     */
    public boolean isFixedLayout() {
        //@issue is there a difference between a fixed
        //layout and a fixed perspective?? If not the API
        //may need some polish, WorkbenchPage, PageLayout
        //and Perspective all have isFixed methods.  
        //PageLayout and Perspective have their own fixed
        //attribute, we are assuming they are always in sync.
        //WorkbenchPage delegates to the perspective.
        return fixed;
    }

    /**
     * Returns true if a view is standalone.
     * 
     * @since 3.0
     */
    public boolean isStandaloneView(IViewReference ref) {
        ViewLayoutRec rec = getViewLayoutRec(ref, false);
        return rec != null && rec.isStandalone;
    }

    /**
     * Returns whether the title for a view should
     * be shown.  This applies only to standalone views.
     * 
     * @since 3.0
     */
    public boolean getShowTitleView(IViewReference ref) {
        ViewLayoutRec rec = getViewLayoutRec(ref, false);
        return rec != null && rec.showTitle;
    }

    /**
     * Creates a new presentation from a persistence file.
     * Note: This method should not modify the current state of the perspective.
     */
    private void loadCustomPersp(PerspectiveDescriptor persp) {
        //get the layout from the registry	
        PerspectiveRegistry perspRegistry = (PerspectiveRegistry) WorkbenchPlugin
                .getDefault().getPerspectiveRegistry();
        try {
            IMemento memento = perspRegistry.getCustomPersp(persp.getId());
            // Restore the layout state.
            MultiStatus status = new MultiStatus(
                    PlatformUI.PLUGIN_ID,
                    IStatus.OK,
                    NLS.bind(WorkbenchMessages.Perspective_unableToRestorePerspective, persp.getLabel()),
                    null);
            status.merge(restoreState(memento));
            status.merge(restoreState());
            if (status.getSeverity() != IStatus.OK) {
                unableToOpenPerspective(persp, status);
            }
        } catch (IOException e) {
            unableToOpenPerspective(persp, null);
        } catch (WorkbenchException e) {
            unableToOpenPerspective(persp, e.getStatus());
        }
    }

    private void unableToOpenPerspective(PerspectiveDescriptor persp,
            IStatus status) {
        PerspectiveRegistry perspRegistry = (PerspectiveRegistry) WorkbenchPlugin
                .getDefault().getPerspectiveRegistry();
        perspRegistry.deletePerspective(persp);
        // If this is a predefined perspective, we will not be able to delete
        // the perspective (we wouldn't want to).  But make sure to delete the
        // customized portion.
        persp.deleteCustomDefinition();
        String title = WorkbenchMessages.Perspective_problemRestoringTitle;
        String msg = WorkbenchMessages.Perspective_errorReadingState;
        if (status == null) {
            MessageDialog.openError((Shell) null, title, msg);
        } else {
            ErrorDialog.openError((Shell) null, title, msg, status);
        }
    }

    /**
     * Create a presentation for a perspective.
     * Note: This method should not modify the current state of the perspective.
     */
    protected void loadPredefinedPersp(PerspectiveDescriptor persp)
            throws WorkbenchException {
        // Create layout engine.
        IPerspectiveFactory factory = null;
        try {
            factory = persp.createFactory();
        } catch (CoreException e) {
            throw new WorkbenchException(NLS.bind(WorkbenchMessages.Perspective_unableToLoad, persp.getId() ));
        }
		
		/*
		 * IPerspectiveFactory#createFactory() can return null
		 */
		if (factory == null) {
			throw new WorkbenchException(NLS.bind(WorkbenchMessages.Perspective_unableToLoad, persp.getId() ));
		}		
		
		
        // Create layout factory.
        ViewSashContainer container = new ViewSashContainer(page, getClientComposite());
        layout = new PageLayout(container, getViewFactory(),
                editorArea, descriptor);
        layout.setFixed(descriptor.getFixed());

        // add the placeholders for the sticky folders and their contents	
        IPlaceholderFolderLayout stickyFolderRight = null, stickyFolderLeft = null, stickyFolderTop = null, stickyFolderBottom = null;

        IStickyViewDescriptor[] descs = WorkbenchPlugin.getDefault()
                .getViewRegistry().getStickyViews();
        for (int i = 0; i < descs.length; i++) {
            IStickyViewDescriptor stickyViewDescriptor = descs[i];
            String id = stickyViewDescriptor.getId();
            switch (stickyViewDescriptor.getLocation()) {
            case IPageLayout.RIGHT:
                if (stickyFolderRight == null) {
					stickyFolderRight = layout
                            .createPlaceholderFolder(
                                    StickyViewDescriptor.STICKY_FOLDER_RIGHT,
                                    IPageLayout.RIGHT, .75f,
                                    IPageLayout.ID_EDITOR_AREA);
				}
                stickyFolderRight.addPlaceholder(id);
                break;
            case IPageLayout.LEFT:
                if (stickyFolderLeft == null) {
					stickyFolderLeft = layout.createPlaceholderFolder(
                            StickyViewDescriptor.STICKY_FOLDER_LEFT,
                            IPageLayout.LEFT, .25f, IPageLayout.ID_EDITOR_AREA);
				}
                stickyFolderLeft.addPlaceholder(id);
                break;
            case IPageLayout.TOP:
                if (stickyFolderTop == null) {
					stickyFolderTop = layout.createPlaceholderFolder(
                            StickyViewDescriptor.STICKY_FOLDER_TOP,
                            IPageLayout.TOP, .25f, IPageLayout.ID_EDITOR_AREA);
				}
                stickyFolderTop.addPlaceholder(id);
                break;
            case IPageLayout.BOTTOM:
                if (stickyFolderBottom == null) {
					stickyFolderBottom = layout.createPlaceholderFolder(
                            StickyViewDescriptor.STICKY_FOLDER_BOTTOM,
                            IPageLayout.BOTTOM, .75f,
                            IPageLayout.ID_EDITOR_AREA);
				}
                stickyFolderBottom.addPlaceholder(id);
                break;
            }

            //should never be null as we've just added the view above
            IViewLayout viewLayout = layout.getViewLayout(id);
            viewLayout.setCloseable(stickyViewDescriptor.isCloseable());
            viewLayout.setMoveable(stickyViewDescriptor.isMoveable());
        }

        // Run layout engine.
        factory.createInitialLayout(layout);
        PerspectiveExtensionReader extender = new PerspectiveExtensionReader();
        extender.extendLayout(page.getExtensionTracker(), descriptor.getId(), layout);

        // Retrieve view layout info stored in the page layout.
        mapIDtoViewLayoutRec.putAll(layout.getIDtoViewLayoutRecMap());

        // Create action sets.
        List temp = new ArrayList();
        createInitialActionSets(temp, layout.getActionSets());

        IContextService service = null;
        if (page != null) {
			service = (IContextService) page.getWorkbenchWindow().getService(
					IContextService.class);
		}
        try {
        	if (service!=null) {
        		service.activateContext(ContextAuthority.DEFER_EVENTS);
        	}
			for (Iterator iter = temp.iterator(); iter.hasNext();) {
				IActionSetDescriptor descriptor = (IActionSetDescriptor) iter
						.next();
				addAlwaysOn(descriptor);
			}
		} finally {
			if (service!=null) {
				service.activateContext(ContextAuthority.SEND_EVENTS);
			}
        }
        newWizardShortcuts = layout.getNewWizardShortcuts();
        showViewShortcuts = layout.getShowViewShortcuts();
        perspectiveShortcuts = layout.getPerspectiveShortcuts();
        showInPartIds = layout.getShowInPartIds();

        // Retrieve fast views
        if (fastViewManager != null) {
	        ArrayList fastViews = layout.getFastViews();
	        for (Iterator fvIter = fastViews.iterator(); fvIter.hasNext();) {
				IViewReference ref = (IViewReference) fvIter.next();
				fastViewManager.addViewReference(FastViewBar.FASTVIEWBAR_ID, -1, ref, 
						!fvIter.hasNext());
			}
        }

        // Is the layout fixed
        fixed = layout.isFixed();

        // Create presentation.	
        presentation = new PerspectiveHelper(page, container, this);

        // Hide editor area if requested by factory
        if (!layout.isEditorAreaVisible()) {
			hideEditorArea();
		}

    }

    private void removeAlwaysOn(IActionSetDescriptor descriptor) {
        if (descriptor == null) {
            return;
        }
        if (!alwaysOnActionSets.contains(descriptor)) {
            return;
        }
        
        alwaysOnActionSets.remove(descriptor);
        if (page != null) {
            page.perspectiveActionSetChanged(this, descriptor, ActionSetManager.CHANGE_HIDE);
        }
    }
    
    protected void addAlwaysOff(IActionSetDescriptor descriptor) {
        if (descriptor == null) {
            return;
        }
        if (alwaysOffActionSets.contains(descriptor)) {
            return;
        }
        alwaysOffActionSets.add(descriptor);
        if (page != null) {
            page.perspectiveActionSetChanged(this, descriptor, ActionSetManager.CHANGE_MASK);
        }
        removeAlwaysOn(descriptor);
    }
    
    protected void addAlwaysOn(IActionSetDescriptor descriptor) {
        if (descriptor == null) {
            return;
        }
        if (alwaysOnActionSets.contains(descriptor)) {
            return;
        }
        alwaysOnActionSets.add(descriptor);
        if (page != null) {
            page.perspectiveActionSetChanged(this, descriptor, ActionSetManager.CHANGE_SHOW);
        }
        removeAlwaysOff(descriptor);
    }
    
    private void removeAlwaysOff(IActionSetDescriptor descriptor) {
        if (descriptor == null) {
            return;
        }
        if (!alwaysOffActionSets.contains(descriptor)) {
            return;
        }
        alwaysOffActionSets.remove(descriptor);
        if (page != null) {
            page.perspectiveActionSetChanged(this, descriptor, ActionSetManager.CHANGE_UNMASK);
        }
    }
    
    /**
     * activate.
     */
	protected void onActivate() {
		// Update editor area state.
		if (editorArea.getControl() != null) {
			boolean visible = isEditorAreaVisible();
			boolean inTrim = editorAreaState == IStackPresentationSite.STATE_MINIMIZED;
			
			// Funky check: Intro uses the old zoom behaviour when maximized. Make sure we don't show the
			// editor if it's supposed to be hidden because the intro is maximized. Note that
			// 'childObscuredByZoom' will only respond 'true' when using the old behaviour.
			boolean introMaxed = getPresentation().getLayout().childObscuredByZoom(editorArea);
			
			editorArea.setVisible(visible && !inTrim && !introMaxed);
		}

		// Update fast views.
		// Make sure the control for the fastviews are created so they can
		// be activated.
		if (fastViewManager != null) {
			List fastViews = fastViewManager.getFastViews(null);		
			for (int i = 0; i < fastViews.size(); i++) {
				ViewPane pane = getPane((IViewReference) fastViews.get(i));
				if (pane != null) {
					Control ctrl = pane.getControl();
					if (ctrl == null) {
						pane.createControl(getClientComposite());
						ctrl = pane.getControl();
					}
					ctrl.setEnabled(false); // Remove focus support.
				}
			}
		}

		// Set the visibility of all fast view pins
		setAllPinsVisible(true);

		// Trim Stack Support
        boolean useNewMinMax = Perspective.useNewMinMax(this);
		boolean hideEditorArea = shouldHideEditorsOnActivate || (editorHidden && editorHolder == null);
		
        // We have to set the editor area's stack state -before-
        // activating the presentation since it's used there to determine
        // size of the resulting stack
        if (useNewMinMax && !hideEditorArea) {
			refreshEditorAreaVisibility();
        }

		// Show the layout
		presentation.activate(getClientComposite());

    	if (useNewMinMax) {
    		fastViewManager.activate();

			// Move any minimized extension stacks to the trim			
			if (layout != null) {
				// Turn aimations off
		        IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
				boolean useAnimations = preferenceStore
						.getBoolean(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS);
				preferenceStore.setValue(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS, false);
				
				List minStacks = layout.getMinimizedStacks();
				for (Iterator msIter = minStacks.iterator(); msIter.hasNext();) {
					ViewStack vs = (ViewStack) msIter.next();
					vs.setMinimized(true);
				}

				// Restore the animation pref
				preferenceStore.setValue(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS, useAnimations);

				// this is a one-off deal...set during the extension reading
				minStacks.clear();
				layout = null;
			}
    	}
    	else {
    		// Update the FVB only if not using the new min/max
    		WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
    		if (wbw != null) {
    			ITrimManager tbm = wbw.getTrimManager();
    			if (tbm != null) {
    				IWindowTrim fvb = tbm.getTrim(FastViewBar.FASTVIEWBAR_ID);
    				if (fvb instanceof FastViewBar) {
    					((FastViewBar)fvb).update(true);
    				}
    			}
    		}
    	}
		
    	// If we are -not- using the new min/max then ensure that there
    	// are no stacks in the trim. This can happen when a user switches
    	// back to the 3.0 presentation... 
		if (!Perspective.useNewMinMax(this) && fastViewManager != null) {
			boolean stacksWereRestored = fastViewManager.restoreAllTrimStacks();
			setEditorAreaTrimVisibility(false);
			
			// Restore any 'maximized' view stack since we've restored
			// the minimized stacks
			if (stacksWereRestored && presentation.getMaximizedStack() instanceof ViewStack) {
				ViewStack vs = (ViewStack) presentation.getMaximizedStack();
				vs.setPresentationState(IStackPresentationSite.STATE_RESTORED);
				presentation.setMaximizedStack(null);
			}
		}

		// We hide the editor area -after- the presentation activates
		if (hideEditorArea) {
			// We do this here to ensure that createPartControl is called on the
			// top editor
			// before it is hidden. See bug 20166.
			hideEditorArea();
			shouldHideEditorsOnActivate = false;
			
			// this is an override so it should handle both states
			if (useNewMinMax)
				setEditorAreaTrimVisibility(editorAreaState == IStackPresentationSite.STATE_MINIMIZED);
		}
	}

	/**
     * deactivate.
     */
	protected void onDeactivate() {
		presentation.deactivate();
		setActiveFastView(null);
		setAllPinsVisible(false);

		// Update fast views.
		if (fastViewManager != null) {
			List fastViews = fastViewManager.getFastViews(null);		
			for (int i = 0; i < fastViews.size(); i++) {
				ViewPane pane = getPane((IViewReference) fastViews.get(i));
				if (pane != null) {
					Control ctrl = pane.getControl();
					if (ctrl != null) {
						ctrl.setEnabled(true); // Add focus support.
					}
				}
			}
			
			fastViewManager.deActivate();
		}
		
		// Ensure that the editor area trim is hidden as well
		setEditorAreaTrimVisibility(false);
	}

    /**
     * Notifies that a part has been activated.
     */
    public void partActivated(IWorkbenchPart activePart) {
        // If a fastview is open close it.
        if (activeFastView != null
                && activeFastView.getPart(false) != activePart) {
			setActiveFastView(null);
		}
    }

    /**
     * The user successfully performed a Show In... action on the specified part.
     * Update the history.
     */
    public void performedShowIn(String partId) {
        showInTimes.put(partId, new Long(System.currentTimeMillis()));
    }

	/**
	 * Sets the fast view attribute. Note: The page is expected to update action
	 * bars.
	 */
	public void removeFastView(IViewReference ref) {
		removeFastView(ref, true);
	}
	
	/**
	 * Sets the fast view attribute. Note: The page is expected to update action
	 * bars.
	 */
	public void removeFastView(IViewReference ref, boolean handleLayout) {
		ViewPane pane = getPane(ref);

		if (activeFastView == ref) {
			setActiveFastView(null);
		}
		
		pane.setFast(false);
		Control ctrl = pane.getControl();
		if (ctrl != null) {
			ctrl.setEnabled(true); // Modify focus support.
		}
		
		if (handleLayout) {
			// We are disabling the pane because it will be enabled when it
			// is added to the presentation. When a pane is enabled a drop
			// listener is added to it, and we do not want to have multiple
			// listeners for a pane
			presentation.addPart(pane);
		}
	}

    /**
     * Fills a presentation with layout data.
     * Note: This method should not modify the current state of the perspective.
     */
    public IStatus restoreState(IMemento memento) {
        MultiStatus result = new MultiStatus(
                PlatformUI.PLUGIN_ID,
                IStatus.OK,
                WorkbenchMessages.Perspective_problemsRestoringPerspective, null);

        // Create persp descriptor.
        descriptor = new PerspectiveDescriptor(null, null, null);
        result.add(descriptor.restoreState(memento));
        PerspectiveDescriptor desc = (PerspectiveDescriptor) WorkbenchPlugin
                .getDefault().getPerspectiveRegistry().findPerspectiveWithId(
                        descriptor.getId());
        if (desc != null) {
			descriptor = desc;
		}

        this.memento = memento;
        // Add the visible views.
        IMemento views[] = memento.getChildren(IWorkbenchConstants.TAG_VIEW);
        result.merge(createReferences(views));

        memento = memento.getChild(IWorkbenchConstants.TAG_FAST_VIEWS);
        if (memento != null) {
            views = memento.getChildren(IWorkbenchConstants.TAG_VIEW);
            result.merge(createReferences(views));
        }
        return result;
    }

    IStatus createReferences(IMemento views[]) {
        MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK,
                WorkbenchMessages.Perspective_problemsRestoringViews, null); 

        for (int x = 0; x < views.length; x++) {
            // Get the view details.
            IMemento childMem = views[x];
            String id = childMem.getString(IWorkbenchConstants.TAG_ID);
            // skip creation of the intro reference -  it's handled elsewhere.
            if (id.equals(IIntroConstants.INTRO_VIEW_ID)) {
				continue;
			}

            String secondaryId = ViewFactory.extractSecondaryId(id);
            if (secondaryId != null) {
                id = ViewFactory.extractPrimaryId(id);
            }
            // Create and open the view.
            try {
                if (!"true".equals(childMem.getString(IWorkbenchConstants.TAG_REMOVED))) { //$NON-NLS-1$
                    viewFactory.createView(id, secondaryId);
                }
            } catch (PartInitException e) {
                childMem.putString(IWorkbenchConstants.TAG_REMOVED, "true"); //$NON-NLS-1$
                result.add(StatusUtil.newStatus(IStatus.ERROR,
                        e.getMessage() == null ? "" : e.getMessage(), //$NON-NLS-1$
                        e));
            }
        }
        return result;
    }

    /**
     * Fills a presentation with layout data.
     * Note: This method should not modify the current state of the perspective.
     */
    public IStatus restoreState() {
        if (this.memento == null) {
			return new Status(IStatus.OK, PlatformUI.PLUGIN_ID, 0, "", null); //$NON-NLS-1$
		}

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

        IMemento memento = this.memento;
        this.memento = null;

        final IMemento boundsMem = memento.getChild(IWorkbenchConstants.TAG_WINDOW);
        if (boundsMem != null) {
        	final Rectangle r = new Rectangle(0, 0, 0, 0);
            r.x = boundsMem.getInteger(IWorkbenchConstants.TAG_X).intValue();
            r.y = boundsMem.getInteger(IWorkbenchConstants.TAG_Y).intValue();
            r.height = boundsMem.getInteger(IWorkbenchConstants.TAG_HEIGHT)
                    .intValue();
            r.width = boundsMem.getInteger(IWorkbenchConstants.TAG_WIDTH)
                    .intValue();
        	StartupThreading.runWithoutExceptions(new StartupRunnable() {

				public void runWithException() throws Throwable {
					if (page.getWorkbenchWindow().getPages().length == 0) {
		                page.getWorkbenchWindow().getShell().setBounds(r);
		            }
				}
			});

        }

        // Create an empty presentation..
        final PerspectiveHelper [] presArray = new PerspectiveHelper[1];
        StartupThreading.runWithoutExceptions(new StartupRunnable() {

			public void runWithException() throws Throwable {
				ViewSashContainer mainLayout = new ViewSashContainer(page, getClientComposite());
				presArray[0] = new PerspectiveHelper(page, mainLayout, Perspective.this);
			}});
        final PerspectiveHelper pres = presArray[0];

        // Read the layout.
        result.merge(pres.restoreState(memento
                .getChild(IWorkbenchConstants.TAG_LAYOUT)));

        StartupThreading.runWithoutExceptions(new StartupRunnable() {

			public void runWithException() throws Throwable {
				// Add the editor workbook. Do not hide it now.
		        pres.replacePlaceholderWithPart(editorArea);
			}});

        // Add the visible views.
        IMemento[] views = memento.getChildren(IWorkbenchConstants.TAG_VIEW);

        for (int x = 0; x < views.length; x++) {
            // Get the view details.
            IMemento childMem = views[x];
            String id = childMem.getString(IWorkbenchConstants.TAG_ID);
            String secondaryId = ViewFactory.extractSecondaryId(id);
            if (secondaryId != null) {
                id = ViewFactory.extractPrimaryId(id);
            }

            // skip the intro as it is restored higher up in workbench.
            if (id.equals(IIntroConstants.INTRO_VIEW_ID)) {
				continue;
			}
            
            // Create and open the view.
            IViewReference viewRef = viewFactory.getView(id, secondaryId);
            WorkbenchPartReference ref = (WorkbenchPartReference) viewRef;

            // report error
            if (ref == null) {
                String key = ViewFactory.getKey(id, secondaryId);
                result.add(new Status(IStatus.ERROR, PlatformUI.PLUGIN_ID, 0,
                        NLS.bind(WorkbenchMessages.Perspective_couldNotFind,  key ), null));
                continue;
            }
            boolean willPartBeVisible = pres.willPartBeVisible(ref.getId(),
                    secondaryId);
            if (willPartBeVisible) {
                IViewPart view = (IViewPart) ref.getPart(true);
                if (view != null) {
                    ViewSite site = (ViewSite) view.getSite();
                    ViewPane pane = (ViewPane) site.getPane();
                    pres.replacePlaceholderWithPart(pane);
                }
            } else {
                pres.replacePlaceholderWithPart(ref.getPane());
            }
        }

        // Load the fast views
        if (fastViewManager != null)
        	fastViewManager.restoreState(memento, result);

        // Load the view layout recs
        IMemento[] recMementos = memento
                .getChildren(IWorkbenchConstants.TAG_VIEW_LAYOUT_REC);
        for (int i = 0; i < recMementos.length; i++) {
            IMemento recMemento = recMementos[i];
            String compoundId = recMemento
                    .getString(IWorkbenchConstants.TAG_ID);
            if (compoundId != null) {
                ViewLayoutRec rec = getViewLayoutRec(compoundId, true);
                if (IWorkbenchConstants.FALSE.equals(recMemento
                        .getString(IWorkbenchConstants.TAG_CLOSEABLE))) {
                    rec.isCloseable = false;
                }
                if (IWorkbenchConstants.FALSE.equals(recMemento
                        .getString(IWorkbenchConstants.TAG_MOVEABLE))) {
                    rec.isMoveable = false;
                }
                if (IWorkbenchConstants.TRUE.equals(recMemento
                        .getString(IWorkbenchConstants.TAG_STANDALONE))) {
                    rec.isStandalone = true;
                    rec.showTitle = !IWorkbenchConstants.FALSE
                            .equals(recMemento
                                    .getString(IWorkbenchConstants.TAG_SHOW_TITLE));
                }
            }
        }

        final IContextService service = (IContextService)page.getWorkbenchWindow().getService(IContextService.class);
        try { // one big try block, don't kill me here
			// defer context events
			if (service != null) {
				service.activateContext(ContextAuthority.DEFER_EVENTS);
			}

			HashSet knownActionSetIds = new HashSet();

			// Load the always on action sets.
			IMemento[] actions = memento
					.getChildren(IWorkbenchConstants.TAG_ALWAYS_ON_ACTION_SET);
			for (int x = 0; x < actions.length; x++) {
				String actionSetID = actions[x]
						.getString(IWorkbenchConstants.TAG_ID);
				final IActionSetDescriptor d = WorkbenchPlugin.getDefault()
						.getActionSetRegistry().findActionSet(actionSetID);
				if (d != null) {
					StartupThreading
							.runWithoutExceptions(new StartupRunnable() {
								public void runWithException() throws Throwable {
									addAlwaysOn(d);
								}
							});

					knownActionSetIds.add(actionSetID);
				}
			}

			// Load the always off action sets.
			actions = memento
					.getChildren(IWorkbenchConstants.TAG_ALWAYS_OFF_ACTION_SET);
			for (int x = 0; x < actions.length; x++) {
				String actionSetID = actions[x]
						.getString(IWorkbenchConstants.TAG_ID);
				final IActionSetDescriptor d = WorkbenchPlugin.getDefault()
						.getActionSetRegistry().findActionSet(actionSetID);
				if (d != null) {
					StartupThreading
							.runWithoutExceptions(new StartupRunnable() {
								public void runWithException() throws Throwable {
									addAlwaysOff(d);
								}
							});
					knownActionSetIds.add(actionSetID);
				}
			}

			// Load "show view actions".
			actions = memento
					.getChildren(IWorkbenchConstants.TAG_SHOW_VIEW_ACTION);
			showViewShortcuts = new ArrayList(actions.length);
			for (int x = 0; x < actions.length; x++) {
				String id = actions[x].getString(IWorkbenchConstants.TAG_ID);
				showViewShortcuts.add(id);
			}

			// Load "show in times".
			actions = memento.getChildren(IWorkbenchConstants.TAG_SHOW_IN_TIME);
			for (int x = 0; x < actions.length; x++) {
				String id = actions[x].getString(IWorkbenchConstants.TAG_ID);
				String timeStr = actions[x]
						.getString(IWorkbenchConstants.TAG_TIME);
				if (id != null && timeStr != null) {
					try {
						long time = Long.parseLong(timeStr);
						showInTimes.put(id, new Long(time));
					} catch (NumberFormatException e) {
						// skip this one
					}
				}
			}

			// Load "show in parts" from registry, not memento
			showInPartIds = getShowInIdsFromRegistry();

			// Load "new wizard actions".
			actions = memento
					.getChildren(IWorkbenchConstants.TAG_NEW_WIZARD_ACTION);
			newWizardShortcuts = new ArrayList(actions.length);
			for (int x = 0; x < actions.length; x++) {
				String id = actions[x].getString(IWorkbenchConstants.TAG_ID);
				newWizardShortcuts.add(id);
			}

			// Load "perspective actions".
			actions = memento
					.getChildren(IWorkbenchConstants.TAG_PERSPECTIVE_ACTION);
			perspectiveShortcuts = new ArrayList(actions.length);
			for (int x = 0; x < actions.length; x++) {
				String id = actions[x].getString(IWorkbenchConstants.TAG_ID);
				perspectiveShortcuts.add(id);
			}

			ArrayList extActionSets = getPerspectiveExtensionActionSets();
			for (int i = 0; i < extActionSets.size(); i++) {
				String actionSetID = (String) extActionSets.get(i);
				if (knownActionSetIds.contains(actionSetID)) {
					continue;
				}
				final IActionSetDescriptor d = WorkbenchPlugin.getDefault()
						.getActionSetRegistry().findActionSet(actionSetID);
				if (d != null) {
					StartupThreading
							.runWithoutExceptions(new StartupRunnable() {
								public void runWithException() throws Throwable {
									addAlwaysOn(d);
								}
							});
					knownActionSetIds.add(d.getId());
				}
			}

			// Add the visible set of action sets to our knownActionSetIds
			// Now go through the registry to ensure we pick up any new action
			// sets
			// that have been added but not yet considered by this perspective.
			ActionSetRegistry reg = WorkbenchPlugin.getDefault()
					.getActionSetRegistry();
			IActionSetDescriptor[] array = reg.getActionSets();
			int count = array.length;
			for (int i = 0; i < count; i++) {
				IActionSetDescriptor desc = array[i];
				if ((!knownActionSetIds.contains(desc.getId()))
						&& (desc.isInitiallyVisible())) {
					addActionSet(desc);
				}
			}
		} finally {
        	// restart context changes
        	if (service != null) {
				StartupThreading.runWithoutExceptions(new StartupRunnable() {
					public void runWithException() throws Throwable {
						service.activateContext(ContextAuthority.SEND_EVENTS);
					}
				});
			}
        }

        // Save presentation.
        presentation = pres;

        // Hide the editor area if needed. Need to wait for the
        // presentation to be fully setup first.
        Integer areaVisible = memento
                .getInteger(IWorkbenchConstants.TAG_AREA_VISIBLE);
        // Rather than hiding the editors now we must wait until after their
		// controls
        // are created. This ensures that if an editor is instantiated,
		// createPartControl
        // is also called. See bug 20166.
        shouldHideEditorsOnActivate = (areaVisible != null && areaVisible
                .intValue() == 0);

        // Restore the trim state of the editor area
        IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
        boolean useNewMinMax = preferenceStore.getBoolean(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
        if (useNewMinMax) {
		    Integer trimStateInt = memento.getInteger(IWorkbenchConstants.TAG_AREA_TRIM_STATE);
		    if (trimStateInt != null) {
		    	editorAreaState = trimStateInt.intValue() & 0x3; // low order two bits contain the state
		    	editorAreaRestoreOnUnzoom = (trimStateInt.intValue() & 4) != 0;
		    }
        }
        
        // restore the fixed state
        Integer isFixed = memento.getInteger(IWorkbenchConstants.TAG_FIXED);
        fixed = (isFixed != null && isFixed.intValue() == 1);

        return result;
    }

    /**
     * Restores a fast view to its corrent presentation structure.
     * This method is pubilc because the FastViewManager uses it to
     * reconstruct it minimized stacks on startup.
     * 
     * @param fvMemento The mement containing the fast view info
     * @param result The result status
     * @return The reference to the restored view
     */
    public IViewReference restoreFastView(IMemento fvMemento, MultiStatus result) {
        String viewID = fvMemento.getString(IWorkbenchConstants.TAG_ID);
        String secondaryId = ViewFactory.extractSecondaryId(viewID);
        if (secondaryId != null) {
            viewID = ViewFactory.extractPrimaryId(viewID);
        }

        IViewReference viewRef = getViewReference(viewID, secondaryId);
        if (viewRef == null) {
            String key = ViewFactory.getKey(viewID, secondaryId);
            WorkbenchPlugin
                    .log("Could not create view: '" + key + "'."); //$NON-NLS-1$ //$NON-NLS-2$
            result
                    .add(new Status(
                            IStatus.ERROR,
                            PlatformUI.PLUGIN_ID,
                            0,
                            NLS.bind(WorkbenchMessages.Perspective_couldNotFind, key ),
                            null));
            return null;
        }

        // Restore fast view width ratio
        Float ratio = fvMemento.getFloat(IWorkbenchConstants.TAG_RATIO);
        if (ratio == null) {
            Integer viewWidth = fvMemento
                    .getInteger(IWorkbenchConstants.TAG_WIDTH);
            if (viewWidth == null) {
				ratio = new Float(IPageLayout.DEFAULT_FASTVIEW_RATIO);
			} else {
				ratio = new Float((float) viewWidth.intValue()
                        / (float) getClientComposite().getSize().x);
			}
        }
        ViewLayoutRec rec = getViewLayoutRec(viewRef, true);
        rec.fastViewWidthRatio = ratio.floatValue();
        
        return viewRef;
    }
    
    /**
     * Returns the ActionSets read from perspectiveExtensions in the registry.  
     */
    protected ArrayList getPerspectiveExtensionActionSets() {
        PerspectiveExtensionReader reader = new PerspectiveExtensionReader();
        reader
                .setIncludeOnlyTags(new String[] { IWorkbenchRegistryConstants.TAG_ACTION_SET });
        PageLayout layout = new PageLayout();
        reader.extendLayout(null, descriptor.getOriginalId(), layout);
        return layout.getActionSets();
    }

    /**
     * Returns the Show In... part ids read from the registry.  
     */
    protected ArrayList getShowInIdsFromRegistry() {
        PerspectiveExtensionReader reader = new PerspectiveExtensionReader();
        reader
                .setIncludeOnlyTags(new String[] { IWorkbenchRegistryConstants.TAG_SHOW_IN_PART });
        PageLayout layout = new PageLayout();
        reader.extendLayout(null, descriptor.getOriginalId(), layout);
        return layout.getShowInPartIds();
    }

    /**
     * Save the layout.
     */
    public void saveDesc() {
        saveDescAs(descriptor);
    }

    /**
     * Save the layout.
     */
    public void saveDescAs(IPerspectiveDescriptor desc) {
        PerspectiveDescriptor realDesc = (PerspectiveDescriptor) desc;
        //get the layout from the registry	
        PerspectiveRegistry perspRegistry = (PerspectiveRegistry) WorkbenchPlugin
                .getDefault().getPerspectiveRegistry();
        // Capture the layout state.	
        XMLMemento memento = XMLMemento.createWriteRoot("perspective");//$NON-NLS-1$
        IStatus status = saveState(memento, realDesc, false);
        if (status.getSeverity() == IStatus.ERROR) {
            ErrorDialog.openError((Shell) null, WorkbenchMessages.Perspective_problemSavingTitle, 
                    WorkbenchMessages.Perspective_problemSavingMessage,
                    status);
            return;
        }
        //save it to the preference store
        try {
            perspRegistry.saveCustomPersp(realDesc, memento);
            descriptor = realDesc;
        } catch (IOException e) {
            perspRegistry.deletePerspective(realDesc);
            MessageDialog.openError((Shell) null, WorkbenchMessages.Perspective_problemSavingTitle, 
                    WorkbenchMessages.Perspective_problemSavingMessage);
        }
    }

    /**
     * Save the layout.
     */
    public IStatus saveState(IMemento memento) {
        MultiStatus result = new MultiStatus(
                PlatformUI.PLUGIN_ID,
                IStatus.OK,
                WorkbenchMessages.Perspective_problemsSavingPerspective, null);

        result.merge(saveState(memento, descriptor, true));

        return result;
    }

    /**
     * Save the layout.
     */
    private IStatus saveState(IMemento memento, PerspectiveDescriptor p,
            boolean saveInnerViewState) {
        MultiStatus result = new MultiStatus(
                PlatformUI.PLUGIN_ID,
                IStatus.OK,
                WorkbenchMessages.Perspective_problemsSavingPerspective, null); 

        if (this.memento != null) {
            memento.putMemento(this.memento);
            return result;
        }

        // Save the version number.
        memento.putString(IWorkbenchConstants.TAG_VERSION, VERSION_STRING);
        result.add(p.saveState(memento));
        if (!saveInnerViewState) {
            Rectangle bounds = page.getWorkbenchWindow().getShell().getBounds();
            IMemento boundsMem = memento
                    .createChild(IWorkbenchConstants.TAG_WINDOW);
            boundsMem.putInteger(IWorkbenchConstants.TAG_X, bounds.x);
            boundsMem.putInteger(IWorkbenchConstants.TAG_Y, bounds.y);
            boundsMem.putInteger(IWorkbenchConstants.TAG_HEIGHT, bounds.height);
            boundsMem.putInteger(IWorkbenchConstants.TAG_WIDTH, bounds.width);
        }


        // Save the "always on" action sets.
        Iterator itr = alwaysOnActionSets.iterator();
        while (itr.hasNext()) {
            IActionSetDescriptor desc = (IActionSetDescriptor) itr.next();
            IMemento child = memento
                    .createChild(IWorkbenchConstants.TAG_ALWAYS_ON_ACTION_SET);
            child.putString(IWorkbenchConstants.TAG_ID, desc.getId());
        }

        // Save the "always off" action sets.
        itr = alwaysOffActionSets.iterator();
        while (itr.hasNext()) {
            IActionSetDescriptor desc = (IActionSetDescriptor) itr.next();
            IMemento child = memento
                    .createChild(IWorkbenchConstants.TAG_ALWAYS_OFF_ACTION_SET);
            child.putString(IWorkbenchConstants.TAG_ID, desc.getId());
        }

        // Save "show view actions"
        itr = showViewShortcuts.iterator();
        while (itr.hasNext()) {
            String str = (String) itr.next();
            IMemento child = memento
                    .createChild(IWorkbenchConstants.TAG_SHOW_VIEW_ACTION);
            child.putString(IWorkbenchConstants.TAG_ID, str);
        }

        // Save "show in times"
        itr = showInTimes.keySet().iterator();
        while (itr.hasNext()) {
            String id = (String) itr.next();
            Long time = (Long) showInTimes.get(id);
            IMemento child = memento
                    .createChild(IWorkbenchConstants.TAG_SHOW_IN_TIME);
            child.putString(IWorkbenchConstants.TAG_ID, id);
            child.putString(IWorkbenchConstants.TAG_TIME, time.toString());
        }

        // Save "new wizard actions".
        itr = newWizardShortcuts.iterator();
        while (itr.hasNext()) {
            String str = (String) itr.next();
            IMemento child = memento
                    .createChild(IWorkbenchConstants.TAG_NEW_WIZARD_ACTION);
            child.putString(IWorkbenchConstants.TAG_ID, str);
        }

        // Save "perspective actions".
        itr = perspectiveShortcuts.iterator();
        while (itr.hasNext()) {
            String str = (String) itr.next();
            IMemento child = memento
                    .createChild(IWorkbenchConstants.TAG_PERSPECTIVE_ACTION);
            child.putString(IWorkbenchConstants.TAG_ID, str);
        }

        // Get visible views.
        List viewPanes = new ArrayList(5);
        presentation.collectViewPanes(viewPanes);

        // Save the views.
        itr = viewPanes.iterator();
        int errors = 0;
        while (itr.hasNext()) {
            ViewPane pane = (ViewPane) itr.next();
            IViewReference ref = pane.getViewReference();
            IMemento viewMemento = memento
                    .createChild(IWorkbenchConstants.TAG_VIEW);
            viewMemento.putString(IWorkbenchConstants.TAG_ID, ViewFactory
                    .getKey(ref));
        }

        // save all fastview state
        if (fastViewManager != null)
        	fastViewManager.saveState(memento);
    	
        // Save the view layout recs.
        for (Iterator i = mapIDtoViewLayoutRec.keySet().iterator(); i.hasNext();) {
            String compoundId = (String) i.next();
            ViewLayoutRec rec = (ViewLayoutRec) mapIDtoViewLayoutRec
                    .get(compoundId);
            if (rec != null
                    && (!rec.isCloseable || !rec.isMoveable || rec.isStandalone)) {
                IMemento layoutMemento = memento
                        .createChild(IWorkbenchConstants.TAG_VIEW_LAYOUT_REC);
                layoutMemento.putString(IWorkbenchConstants.TAG_ID, compoundId);
                if (!rec.isCloseable) {
                    layoutMemento.putString(IWorkbenchConstants.TAG_CLOSEABLE,
                            IWorkbenchConstants.FALSE);
                }
                if (!rec.isMoveable) {
                    layoutMemento.putString(IWorkbenchConstants.TAG_MOVEABLE,
                            IWorkbenchConstants.FALSE);
                }
                if (rec.isStandalone) {
                    layoutMemento.putString(IWorkbenchConstants.TAG_STANDALONE,
                            IWorkbenchConstants.TRUE);
                    layoutMemento.putString(IWorkbenchConstants.TAG_SHOW_TITLE,
                            String.valueOf(rec.showTitle));
                }
            }
        }

        if (errors > 0) {
            String message = WorkbenchMessages.Perspective_multipleErrors;
            if (errors == 1) {
				message = WorkbenchMessages.Perspective_oneError;
			}
            MessageDialog.openError(null,
                    WorkbenchMessages.Error, message); 
        }

        // Save the layout.
        IMemento childMem = memento.createChild(IWorkbenchConstants.TAG_LAYOUT);
        result.add(presentation.saveState(childMem));

        // Save the editor visibility state
        if (isEditorAreaVisible()) {
			memento.putInteger(IWorkbenchConstants.TAG_AREA_VISIBLE, 1);
		} else {
			memento.putInteger(IWorkbenchConstants.TAG_AREA_VISIBLE, 0);
		}

        // Save the trim state of the editor area if using the new min/max
        IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
        boolean useNewMinMax = preferenceStore.getBoolean(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
        if (useNewMinMax) {
	        int trimState = editorAreaState;
	        trimState |= editorAreaRestoreOnUnzoom ? 4 : 0;
	        memento.putInteger(IWorkbenchConstants.TAG_AREA_TRIM_STATE, trimState);
        }
        
        // Save the fixed state
        if (fixed) {
			memento.putInteger(IWorkbenchConstants.TAG_FIXED, 1);
		} else {
			memento.putInteger(IWorkbenchConstants.TAG_FIXED, 0);
		}

        return result;
    }
    
    public void turnOnActionSets(IActionSetDescriptor[] newArray) {
        for (int i = 0; i < newArray.length; i++) {
            IActionSetDescriptor descriptor = newArray[i];
            
            addAlwaysOn(descriptor);
        }
    }
    
    public void turnOffActionSets(IActionSetDescriptor[] toDisable) {
        for (int i = 0; i < toDisable.length; i++) {
            IActionSetDescriptor descriptor = toDisable[i];
            
            turnOffActionSet(descriptor);
        }
    }

    public void turnOffActionSet(IActionSetDescriptor toDisable) {
        addAlwaysOff(toDisable);
    }
    
    /**
     * Return the active fast view or null if there are no
     * fast views or if there are all minimized.
     */
    public IViewReference getActiveFastView() {
        return activeFastView;
    }

    /**
     * Sets the active fast view. If a different fast view is already open,
     * it shrinks equally <code>steps</code> times before disappearing
     * completely. Then, <code>view</code> becomes active and is shown.
     */
    /*package*/void setActiveFastView(IViewReference ref, int steps) {
        if (activeFastView == ref) {
			return;
		}

        if (activeFastView != null) {
            ViewPane pane = getPane(activeFastView);
            if (pane != null) {
                if (pane.isZoomed()) {
                    presentation.zoomOut();
                }
                hideFastView(activeFastView, steps);
            }
        }
        activeFastView = ref;
        try {
            if (activeFastView != null) {
                if (!showFastView(activeFastView)) {
                    activeFastView = null;
                }
            }
        } catch (RuntimeException e) {
            activeFastView = null;
        }
    }

    /**
     * Sets the active fast view.
     */
    /*package*/void setActiveFastView(IViewReference ref) {
        setActiveFastView(ref, FASTVIEW_HIDE_STEPS);
    }

    /**
     * Sets the visibility of all fast view pins.
     */
    protected void setAllPinsVisible(boolean visible) {
    	if (fastViewManager == null)
    		return;
    	
        Iterator iter = fastViewManager.getFastViews(null).iterator();
        while (iter.hasNext()) {
            ViewPane pane = getPane((IViewReference) iter.next());
            if (pane != null) {
				pane.setFast(visible);
			}
        }
    }

    /**
     * Sets the selection for the shortcut bar icon representing the givevn fast view.
     */
    private void setFastViewIconSelection(IViewReference ref, boolean selected) {
    	if (fastViewManager == null)
    		return;
    	
		fastViewManager.setFastViewIconSelection(ref, selected);
    }

    /**
     * Sets the new wizard actions for the page.
     * This is List of Strings.
     */
    public void setNewWizardActionIds(ArrayList newList) {
        newWizardShortcuts = newList;
    }

    /**
     * Sets the perspective actions for this page.
     * This is List of Strings.
     */
    public void setPerspectiveActionIds(ArrayList list) {
        perspectiveShortcuts = list;
    }

    /**
     * Sets the ids of the parts to list in the Show In... prompter.
     * This is a List of Strings.
     */
    public void setShowInPartIds(ArrayList list) {
        showInPartIds = list;
    }

    /**
     * Sets the ids of the views to list in the Show View shortcuts.
     * This is a List of Strings.
     */
    public void setShowViewActionIds(ArrayList list) {
        showViewShortcuts = list;
    }


    /**
     * Show the editor area if not visible
     */
    protected void showEditorArea() {
        if (isEditorAreaVisible()) {
			return;
		}

        editorHidden = false;
        
        // Show the editor in the appropriate location
        if (useNewMinMax(this)) {
        	boolean isMinimized = editorAreaState == IStackPresentationSite.STATE_MINIMIZED;
        	if (!isMinimized) {
        		// If the editor area is going to show then we have to restore
            	if (getPresentation().getMaximizedStack() != null)
            		getPresentation().getMaximizedStack().setState(IStackPresentationSite.STATE_RESTORED);
            	
        		showEditorAreaLocal();
        	}
        	else
        		setEditorAreaTrimVisibility(true);
        }
        else {
        	showEditorAreaLocal();
        }
    }

    /**
     * Show the editor area if not visible
     */
    protected void showEditorAreaLocal() {
        if (editorHolder == null || editorHidden) {
			return;
		}

        // Replace the part holder with the editor area.
        presentation.getLayout().replace(editorHolder, editorArea);
        editorHolder = null;
    }

    private EditorAreaTrimToolBar getEditorAreaTrim(boolean createIfNecessary) {
		WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
		ITrimManager tbm = wbw.getTrimManager();
		if (tbm == null)
			return null;

		// Create if necesary
		EditorAreaTrimToolBar editorAreaTrim = (EditorAreaTrimToolBar) tbm.getTrim(IPageLayout.ID_EDITOR_AREA);
    	if (editorAreaTrim  == null && createIfNecessary) {
    		int suggestedSide = SWT.RIGHT;
			int cachedSide = ((TrimLayout)tbm).getPreferredArea(IPageLayout.ID_EDITOR_AREA);
			if (cachedSide != -1)
				suggestedSide = cachedSide;
			
			IWindowTrim beforeMe = ((TrimLayout)tbm).getPreferredLocation(IPageLayout.ID_EDITOR_AREA);
			
    		// Gain access to the trim manager
			editorAreaTrim = new EditorAreaTrimToolBar(wbw, editorArea);
			editorAreaTrim.dock(suggestedSide);
			tbm.addTrim(suggestedSide, editorAreaTrim, beforeMe);
    	}
		
		return editorAreaTrim;
    }
    
    public void setEditorAreaState(int newState) {
    	if (newState == editorAreaState)
    		return;
    	
    	editorAreaState = newState;
    	
    	// reset the restore flag if we're not minimized
    	if (newState != IStackPresentationSite.STATE_MINIMIZED)
    		editorAreaRestoreOnUnzoom = false;
    	
    	refreshEditorAreaVisibility();
    }
    
    public int getEditorAreaState() {
    	return editorAreaState;
    }
    
    /**
	 * 
	 */
	public void refreshEditorAreaVisibility() {
		// Nothing shows up if the editor area isn't visible at all
		if (editorHidden) {
			hideEditorAreaLocal();
			setEditorAreaTrimVisibility(false);
			return;
		}
		
		EditorStack editorStack = ((EditorSashContainer) editorArea).getUpperRightEditorStack(null);
		if (editorStack == null)
			return;
		
		// Whatever we're doing, make the current editor stack match it
		editorStack.setStateLocal(editorAreaState);
		
		// If it's minimized then it's in the trim
		if (editorAreaState == IStackPresentationSite.STATE_MINIMIZED) {
			// Hide the editor area and show its trim 
			hideEditorAreaLocal();
			setEditorAreaTrimVisibility(true);
		}
		else {
			// Show the editor area and hide its trim 
			setEditorAreaTrimVisibility(false);
			showEditorAreaLocal();
			
			if (editorAreaState == IStackPresentationSite.STATE_MAXIMIZED)
				getPresentation().setMaximizedStack(editorStack);
		}
	}

	protected EditorAreaTrimToolBar setEditorAreaTrimVisibility(boolean visible) {
		WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
		ITrimManager tbm = wbw.getTrimManager();
		if (tbm == null)
			return null;
		
		// Only create the trim element if it's going to be visible
		EditorAreaTrimToolBar editorAreaTrim = getEditorAreaTrim(visible);
		if (editorAreaTrim == null)
			return null;
		
    	tbm.setTrimVisible(editorAreaTrim, visible);
    	tbm.forceLayout();
    	
    	return editorAreaTrim;
    }
    
    /**
     * Shows a fast view.
     * @return whether the view was successfully shown
     */
    boolean showFastView(IViewReference ref) {
    	if (fastViewManager == null)
    		return false;
    	
        // Make sure the part is restored.
    	IWorkbenchPart refPart = ref.getPart(true);
        if (refPart == null) {
			return false;
		}

        ViewPane pane = getPane(ref);
        if (pane == null) {
			return false;
		}

        saveFastViewWidthRatio();

        // Special check to ensure that a 'minimized' intro view shows
        // as 'standby'
        if (ref.getId().equals("org.eclipse.ui.internal.introview")) { //$NON-NLS-1$
        	if (refPart instanceof ViewIntroAdapterPart) {
	        	((ViewIntroAdapterPart)refPart).setStandby(true);
        	}
        }
        
		// Determine the display orientation
		int side = fastViewManager.getViewSide(ref);
        fastViewPane.showView(getClientComposite(), pane, side,
                getFastViewWidthRatio(ref)); 

        setFastViewIconSelection(ref, true);

        return true;
    }

    private void saveFastViewWidthRatio() {
        ViewPane pane = fastViewPane.getCurrentPane();
        if (pane != null) {
            ViewLayoutRec rec = getViewLayoutRec(pane.getViewReference(), true);
            rec.fastViewWidthRatio = fastViewPane.getCurrentRatio();
        }
    }

    /**
     * Resolves a view's id into its reference, creating the
     * view if necessary.
     * 
     * @param viewId The primary id of the view (must not be
     * <code>null</code>
     * @param secondaryId The secondary id of a multiple-instance view
     * (may be <code>null</code>).
     * 
     * @return The reference to the specified view. This may be null if the
     * view fails to create (i.e. thrown a PartInitException)
     */
    public IViewReference getViewReference(String viewId, String secondaryId) {
    	IViewReference ref = page.findViewReference(viewId, secondaryId);
    	if (ref == null) {
            ViewFactory factory = getViewFactory();
            try {
				ref = factory.createView(viewId, secondaryId);
			} catch (PartInitException e) {
				IStatus status = StatusUtil.newStatus(IStatus.ERROR,
                        e.getMessage() == null ? "" : e.getMessage(), //$NON-NLS-1$
                        e);
	            StatusUtil.handleStatus(status, "Failed to create view: id=" + viewId, //$NON-NLS-1$
	            		StatusManager.LOG);
			}
    	}
    	return ref;
    }
    
    /**
     * Shows the view with the given id and secondary id.
     */
    public IViewPart showView(String viewId, String secondaryId)
            throws PartInitException {
        ViewFactory factory = getViewFactory();
        IViewReference ref = factory.createView(viewId, secondaryId);
        IViewPart part = (IViewPart) ref.getPart(true);
        if (part == null) {
            throw new PartInitException(NLS.bind(WorkbenchMessages.ViewFactory_couldNotCreate, ref.getId()));
        }
        ViewSite site = (ViewSite) part.getSite();
        ViewPane pane = (ViewPane) site.getPane();

        IPreferenceStore store = WorkbenchPlugin.getDefault()
                .getPreferenceStore();
        int openViewMode = store.getInt(IPreferenceConstants.OPEN_VIEW_MODE);

        if (openViewMode == IPreferenceConstants.OVM_FAST &&
        	fastViewManager != null) {
        	fastViewManager.addViewReference(FastViewBar.FASTVIEWBAR_ID, -1, ref, true);
            setActiveFastView(ref);
        } else if (openViewMode == IPreferenceConstants.OVM_FLOAT
                && presentation.canDetach()) {
            presentation.addDetachedPart(pane);
        } else {
        	if (useNewMinMax(this)) {
            	// Is this view going to show in the trim?
            	LayoutPart vPart = presentation.findPart(viewId, secondaryId);

            	// Determine if there is a trim stack that should get the view
            	String trimId = null;
            	
            	// If we can locate the correct trim stack then do so
            	if (vPart != null) {
            		String id = null;
            		ILayoutContainer container = vPart.getContainer();
            		if (container instanceof ContainerPlaceholder)
            			id = ((ContainerPlaceholder)container).getID();
            		else if (container instanceof ViewStack)
            			id = ((ViewStack)container).getID();
            		
            		// Is this place-holder in the trim?
                    if (id != null && fastViewManager.getFastViews(id).size() > 0) {
                    	trimId = id;
                    }
            	}
            	
            	// No explicit trim found; If we're maximized then we either have to find an
            	// arbitrary stack...
            	if (trimId == null && presentation.getMaximizedStack() != null) {
            		if (vPart == null) {
            			ViewStackTrimToolBar blTrimStack = fastViewManager.getBottomRightTrimStack();
            			if (blTrimStack != null) {
            				// OK, we've found a trim stack to add it to...
            				trimId = blTrimStack.getId();
            				
            				// Since there was no placeholder we have to add one
            				LayoutPart blPart = presentation.findPart(trimId, null);
            				if (blPart instanceof ContainerPlaceholder) {
            					ContainerPlaceholder cph = (ContainerPlaceholder) blPart;
            					if (cph.getRealContainer() instanceof ViewStack) {
            						ViewStack vs = (ViewStack) cph.getRealContainer();
            						
            						// Create a 'compound' id if this is a multi-instance part
            						String compoundId = ref.getId();
            						if (ref.getSecondaryId() != null)
            							compoundId = compoundId + ':' + ref.getSecondaryId();

            						// Add the new placeholder
            						vs.add(new PartPlaceholder(compoundId));
            					}
            				}
            			}
            		}
            	}
            	
            	// If we have a trim stack located then add the view to it
            	if (trimId != null) {
                	fastViewManager.addViewReference(trimId, -1, ref, true);
            	}
            	else {
            		boolean inMaximizedStack = vPart != null && vPart.getContainer() == presentation.getMaximizedStack();

            		// Do the default behavior
            		presentation.addPart(pane);
            		
            		// Now, if we're maximized then we have to minimize the new stack
            		if (presentation.getMaximizedStack() != null && !inMaximizedStack) {
            			vPart = presentation.findPart(viewId, secondaryId);
            			if (vPart != null && vPart.getContainer() instanceof ViewStack) {
            				ViewStack vs = (ViewStack)vPart.getContainer();
            				vs.setState(IStackPresentationSite.STATE_MINIMIZED);
            				
            				// setting the state to minimized will create the trim toolbar
            				// so we don't need a null pointer check here...
            				fastViewManager.getViewStackTrimToolbar(vs.getID()).setRestoreOnUnzoom(true);
            			}
            		}
            	}
        	}
        	else {
        		presentation.addPart(pane);
        	}
        }
        
        // Ensure that the newly showing part is enabled
        if (pane != null && pane.getControl() != null)
        	pane.getControl().setEnabled(true);
        
        return part;
    }

    /**
     * Toggles the visibility of a fast view.  If the view is active it
     * is deactivated.  Otherwise, it is activated.
     */
    public void toggleFastView(IViewReference ref) {
        if (ref == activeFastView) {
            setActiveFastView(null);
        } else {
            setActiveFastView(ref);
        }
    }

    /**
     * Returns the old part reference.
     * Returns null if there was no previously active part.
     * 
     * @return the old part reference or <code>null</code>
     */
    public IWorkbenchPartReference getOldPartRef() {
        return oldPartRef;
    }

    /**
     * Sets the old part reference.
     * 
     * @param oldPartRef The old part reference to set, or <code>null</code>
     */
    public void setOldPartRef(IWorkbenchPartReference oldPartRef) {
        this.oldPartRef = oldPartRef;
    }

    //for dynamic UI
    protected void addActionSet(IActionSetDescriptor newDesc) {
    	IContextService service = (IContextService)page.getWorkbenchWindow().getService(IContextService.class);
    	try {
			service.activateContext(ContextAuthority.DEFER_EVENTS);
			for (int i = 0; i < alwaysOnActionSets.size(); i++) {
				IActionSetDescriptor desc = (IActionSetDescriptor) alwaysOnActionSets
						.get(i);
				if (desc.getId().equals(newDesc.getId())) {
					removeAlwaysOn(desc);
					removeAlwaysOff(desc);
					break;
				}
			}
			addAlwaysOn(newDesc);
		} finally {
    		service.activateContext(ContextAuthority.SEND_EVENTS);
    	}
    }

    // for dynamic UI
    /* package */void removeActionSet(String id) {
    	IContextService service = (IContextService)page.getWorkbenchWindow().getService(IContextService.class);
    	try {
			service.activateContext(ContextAuthority.DEFER_EVENTS);
			for (int i = 0; i < alwaysOnActionSets.size(); i++) {
				IActionSetDescriptor desc = (IActionSetDescriptor) alwaysOnActionSets
						.get(i);
				if (desc.getId().equals(id)) {
					removeAlwaysOn(desc);
					break;
				}
			}

			for (int i = 0; i < alwaysOffActionSets.size(); i++) {
				IActionSetDescriptor desc = (IActionSetDescriptor) alwaysOffActionSets
						.get(i);
				if (desc.getId().equals(id)) {
					removeAlwaysOff(desc);
					break;
				}
			}
		} finally {
    		service.activateContext(ContextAuthority.SEND_EVENTS);
    	}
    }
    
    void removeActionSet(IActionSetDescriptor toRemove) {
        removeAlwaysOn(toRemove);
        removeAlwaysOff(toRemove);
    }

    public void setFastViewState(int newState) {
        fastViewPane.setState(newState);
    }
    
    public int getFastViewState() {
    	return fastViewPane.getState();
    }

    /**
     * Returns whether the given view is closeable in this perspective.
     * 
     * @since 3.0
     */
    public boolean isCloseable(IViewReference reference) {
        ViewLayoutRec rec = getViewLayoutRec(reference, false);
        if (rec != null) {
			return rec.isCloseable;
		}
        return true;
    }

    /**
     * Returns whether the given view is moveable in this perspective.
     * 
     * @since 3.0
     */
    public boolean isMoveable(IViewReference reference) {
        ViewLayoutRec rec = getViewLayoutRec(reference, false);
        if (rec != null) {
			return rec.isMoveable;
		}
        return true;
    }

    /**
     * Writes a description of the layout to the given string buffer.
     * This is used for drag-drop test suites to determine if two layouts are the
     * same. Like a hash code, the description should compare as equal iff the
     * layouts are the same. However, it should be user-readable in order to
     * help debug failed tests. Although these are english readable strings,
     * they should not be translated or equality tests will fail.
     * <p>
     * This is only intended for use by test suites.
     * </p>
     * 
     * @param buf
     */
    public void describeLayout(StringBuffer buf) {
        IViewReference[] fastViews = getFastViews();

        if (fastViews.length != 0) {
            buf.append("fastviews ("); //$NON-NLS-1$
            for (int idx = 0; idx < fastViews.length; idx++) {
                IViewReference ref = fastViews[idx];

                if (idx > 0) {
                    buf.append(", "); //$NON-NLS-1$
                }

                buf.append(ref.getPartName());
            }
            buf.append("), "); //$NON-NLS-1$
        }

        getPresentation().describeLayout(buf);
    }

    /**
     * Sanity-checks the LayoutParts in this perspective. Throws an Assertation exception
     * if an object's internal state is invalid.
     */
    public void testInvariants() {        
        getPresentation().getLayout().testInvariants();
    }

    public IActionSetDescriptor[] getAlwaysOnActionSets() {
        return (IActionSetDescriptor[]) alwaysOnActionSets.toArray(new IActionSetDescriptor[alwaysOnActionSets.size()]);
    }
    
    public IActionSetDescriptor[] getAlwaysOffActionSets() {
        return (IActionSetDescriptor[]) alwaysOffActionSets.toArray(new IActionSetDescriptor[alwaysOffActionSets.size()]);
    }

	/* package */ FastViewPane getFastViewPane() {
		return fastViewPane;
	}


	/**
	 * Restores a part in the trim to the actual layout
	 * @param part The part to restore
	 */
	public void restoreTrimPart(LayoutPart part) {
		if (fastViewManager == null)
			return;
		
		// Remove any current fastview
		setActiveFastView(null);

		// Set the part's state to place it back in the layout
		if (part instanceof ViewStack) {
			ViewStack vs = (ViewStack) part;
			fastViewManager.restoreToPresentation(vs.getID());
		}

		if (part == editorArea) {
			setEditorAreaState(IStackPresentationSite.STATE_RESTORED);
			editorAreaRestoreOnUnzoom = false;
		}
	}

	/**
	 * Determine the correct side to initially dock a new
	 * trim part on. We do this by checking its rect against
	 * the editor area.
	 * 
	 * @param stackBounds The bounds of the stack we want to create trim for
	 * @return the SWT side to dock the trim element on
	 */
	public int calcStackSide(Rectangle stackBounds) {
		// Where is the stack in relation to the EditorArea?
		Rectangle editorAreaBounds = editorArea.getBounds();
		
		// Is this the Editor Area
		if (editorAreaBounds.equals(stackBounds))
			return SWT.TOP;
		
		Point stackCenter = Geometry.centerPoint(stackBounds);
		Point editorAreaCenter = Geometry.centerPoint(editorAreaBounds);

		int dx = editorAreaCenter.x - stackCenter.x;
		int dy = editorAreaCenter.y - stackCenter.y;

		if (Math.abs(dx) > Math.abs(dy)) {
			return (dx > 0) ? SWT.LEFT : SWT.RIGHT;
		}

		if (dy > 0) {
			return (dx > 0) ? SWT.LEFT : SWT.RIGHT;
		}
		
		return SWT.BOTTOM;
	}

	/**
	 * Restore any parts that are showing in the trim as
	 * a result of a 'zoom' operation
	 */
	public void restoreZoomedParts() {
		if (fastViewManager == null)
			return;
		
		// Remove any current fastview
		setActiveFastView(null);
			
		// have the layout restore the parts
		fastViewManager.restoreZoomedViewStacks();
		
		if (editorAreaRestoreOnUnzoom) {
			restoreTrimPart(editorArea);
		}
	}

	/**
	 * @return Returns the fastViewManager.
	 */
	public FastViewManager getFastViewManager() {
		return fastViewManager;
	}

	/**
	 * Sets the restore on unzoom state for the editor area
	 * @param restore the new state
	 */
	public void setEditorAreaRestoreOnUnzoom(boolean restore) {
		editorAreaRestoreOnUnzoom = restore;
	}

	/**
	 * @return the restore on unzoom state
	 */
	public boolean getEditorAreaRestoreOnUnzoom() {
		return editorAreaRestoreOnUnzoom;
	}

	/**
	 * Used to restrict the use of the new min/max behavior to envoronments
	 * in which it has a chance of working...
	 * 
	 * @param activePerspective We pass this in as an arg so others won't have
	 * to check it for 'null' (which is one of the failure cases)
	 * 
	 */
	public static boolean useNewMinMax(Perspective activePerspective) {
		// We need to have an active perspective
		if (activePerspective == null)
			return false;
		
		// We need to have a trim manager (if we don't then we
		// don't create a FastViewManager because it'd be useless)
		if (activePerspective.getFastViewManager() == null)
			return false;
		
		// Make sure we don't NPE anyplace
        WorkbenchWindow wbw = (WorkbenchWindow) activePerspective.page.getWorkbenchWindow();
        if (wbw == null)
        	return false;
        
        WorkbenchWindowConfigurer configurer = wbw.getWindowConfigurer();
        if (configurer == null)
        	return false;
        
        AbstractPresentationFactory factory = configurer.getPresentationFactory();
        if (factory == null)
        	return false;
        
		// Ok, we should be good to go, return the pref
	    IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
        boolean useNewMinMax = preferenceStore.getBoolean(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
        return useNewMinMax;
    }
}