org.eclipse.ui.internal.Perspective Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of workbench Show documentation
Show all versions of workbench Show documentation
This plug-in contains the bulk of the Workbench implementation, and depends on JFace, SWT, and Core Runtime. It cannot be used independently from org.eclipse.ui. Workbench client plug-ins should not depend directly on this plug-in.
The newest version!
/*******************************************************************************
* 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 {
private PerspectiveDescriptor descriptor;
protected WorkbenchPage page;
// Editor Area management
protected LayoutPart editorArea;
private PartPlaceholder editorHolder;
private boolean editorHidden = false;
private boolean editorAreaRestoreOnUnzoom = false;
private int editorAreaState = IStackPresentationSite.STATE_RESTORED;
private ViewFactory viewFactory;
private ArrayList alwaysOnActionSets;
private ArrayList alwaysOffActionSets;
private ArrayList newWizardShortcuts;
private ArrayList showViewShortcuts;
private ArrayList perspectiveShortcuts;
//private List fastViews;
private FastViewManager fastViewManager = null;
private Map mapIDtoViewLayoutRec;
private boolean fixed;
private ArrayList showInPartIds;
private HashMap showInTimes = new HashMap();
private IViewReference activeFastView;
private 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;
private boolean shouldHideEditorsOnActivate = false;
private 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.
*/
private 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 null
* 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 null 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.
*/
private 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 steps 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.
*/
private 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);
}
}
private 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);
}
private 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.
*/
private 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.
*/
private 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 steps times before disappearing
* completely. Then, view 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.
*/
private 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
* null
* @param secondaryId The secondary id of a multiple-instance view
* (may be null).
*
* @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);
}
}
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 null
*/
public IWorkbenchPartReference getOldPartRef() {
return oldPartRef;
}
/**
* Sets the old part reference.
*
* @param oldPartRef The old part reference to set, or null
*/
public void setOldPartRef(IWorkbenchPartReference oldPartRef) {
this.oldPartRef = oldPartRef;
}
//for dynamic UI
/* package */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.
*
* This is only intended for use by test suites.
*
*
* @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;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy