/*******************************************************************************
* 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.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.StartupThreading.StartupRunnable;
import org.eclipse.ui.internal.presentations.PresentationSerializer;
import org.eclipse.ui.presentations.IStackPresentationSite;
import org.eclipse.ui.presentations.StackPresentation;
/**
* Represents the area set aside for editor workbooks.
* This container only accepts EditorStack and PartSash
* as layout parts.
*
* Note no views are allowed within this container.
*/
public class EditorSashContainer extends PartSashContainer {
static final String DEFAULT_WORKBOOK_ID = "DefaultEditorWorkbook";//$NON-NLS-1$
private ArrayList editorWorkbooks = new ArrayList(3);
private EditorStack activeEditorWorkbook;
private DropTarget dropTarget;
public EditorSashContainer(String editorId, WorkbenchPage page, Composite parent) {
super(editorId, page, parent);
createDefaultWorkbook();
}
/**
* Add an editor to the active workbook.
*/
public void addEditor(EditorPane pane, EditorStack stack) {
//EditorStack workbook = getActiveWorkbook();
stack.add(pane);
}
/* (non-Javadoc)
* @see org.eclipse.ui.internal.PartSashContainer#addChild(org.eclipse.ui.internal.PartSashContainer.RelationshipInfo)
*/
protected void addChild(RelationshipInfo info) {
super.addChild(info);
updateStackButtons();
}
/**
* Hides the min/max buttons for all editor stacks
* -except- for the upper/left one.
*/
public void updateStackButtons() {
// This is applicable only when the new
// min/max behaviour is being used
Perspective persp = getPage().getActivePerspective();
if (!Perspective.useNewMinMax(persp))
return;
// Find the upper Right editor stack
LayoutPart[] stacks = getChildren();
EditorStack winner = getUpperRightEditorStack(stacks);
// Now hide the buttons for all but the upper right stack
for (int i = 0; i < stacks.length; i++) {
if (!(stacks[i] instanceof EditorStack))
continue;
((EditorStack)stacks[i]).showMinMax(stacks[i] == winner);
}
// Force the stack's presentation state to match its perspective
persp.refreshEditorAreaVisibility();
}
/**
* @param stacks
* @return the EditorStack in the upper right position
*/
public EditorStack getUpperRightEditorStack(LayoutPart[] stacks) {
if (stacks == null)
stacks = getChildren();
// Find the upper Right editor stack
EditorStack winner = null;
Rectangle winnerRect = null;
for (int i = 0; i < stacks.length; i++) {
if (!(stacks[i] instanceof EditorStack))
continue;
EditorStack stack = (EditorStack) stacks[i];
Rectangle bb = stack.getBounds();
if (winnerRect == null ||
bb.y < winnerRect.y ||
(bb.y == winnerRect.y && bb.x > winnerRect.x)) {
winner = stack;
winnerRect = bb;
}
}
return winner;
}
/**
* Notification that a child layout part has been
* added to the container. Subclasses may override
* this method to perform any container specific
* work.
*/
protected void childAdded(LayoutPart child) {
super.childAdded(child);
if (child instanceof EditorStack) {
editorWorkbooks.add(child);
}
}
/**
* Notification that a child layout part has been
* removed from the container. Subclasses may override
* this method to perform any container specific
* work.
*/
protected void childRemoved(LayoutPart child) {
super.childRemoved(child);
if (child instanceof EditorStack) {
editorWorkbooks.remove(child);
if (activeEditorWorkbook == child) {
setActiveWorkbook(null, false);
}
updateStackButtons();
}
}
protected EditorStack createDefaultWorkbook() {
EditorStack newWorkbook = EditorStack.newEditorWorkbook(this, page);
newWorkbook.setID(DEFAULT_WORKBOOK_ID);
add(newWorkbook);
return newWorkbook;
}
/**
* Subclasses override this method to specify
* the composite to use to parent all children
* layout parts it contains.
*/
protected Composite createParent(Composite parentWidget) {
return new Composite(parentWidget, SWT.NONE);
}
/**
* Dispose of the editor area.
*/
public void dispose() {
// Free editor workbooks.
editorWorkbooks.clear();
// Free rest.
super.dispose();
}
/**
* Subclasses override this method to dispose
* of any swt resources created during createParent.
*/
protected void disposeParent() {
this.parent.dispose();
}
/**
* Return the editor workbook which is active.
*/
public EditorStack getActiveWorkbook() {
if (activeEditorWorkbook == null) {
if (editorWorkbooks.size() < 1) {
setActiveWorkbook(createDefaultWorkbook(), false);
} else {
setActiveWorkbook((EditorStack) editorWorkbooks.get(0), false);
}
}
return activeEditorWorkbook;
}
/**
* Return the editor workbook id which is active.
*/
public String getActiveWorkbookID() {
return getActiveWorkbook().getID();
}
/**
* Return the all the editor workbooks.
*/
public ArrayList getEditorWorkbooks() {
return (ArrayList) editorWorkbooks.clone();
}
/**
* Return the all the editor workbooks.
*/
public int getEditorWorkbookCount() {
return editorWorkbooks.size();
}
/**
* Return true is the workbook specified
* is the active one.
*/
protected boolean isActiveWorkbook(EditorStack workbook) {
return activeEditorWorkbook == workbook;
}
/**
* Find the sashs around the specified part.
*/
public void findSashes(LayoutPart pane, PartPane.Sashes sashes) {
//Find the sashes around the current editor and
//then the sashes around the editor area.
super.findSashes(pane, sashes);
ILayoutContainer container = getContainer();
if (container != null) {
container.findSashes(this, sashes);
}
}
/**
* Remove all the editors
*/
public void removeAllEditors() {
EditorStack currentWorkbook = getActiveWorkbook();
// Iterate over a copy so the original can be modified.
Iterator workbooks = ((ArrayList) editorWorkbooks.clone()).iterator();
while (workbooks.hasNext()) {
EditorStack workbook = (EditorStack) workbooks.next();
workbook.removeAll();
if (workbook != currentWorkbook) {
remove(workbook);
workbook.dispose();
}
}
}
/**
* Remove an editor from its' workbook.
*/
public void removeEditor(EditorPane pane) {
EditorStack workbook = pane.getWorkbook();
if (workbook == null) {
return;
}
workbook.remove(pane);
// remove the editor workbook if empty
if (workbook.getItemCount() < 1 /* && editorWorkbooks.size() > 1*/) {
// If the user closes the last editor and the editor area
// is maximized, restore it
Perspective persp = getPage().getActivePerspective();
if (Perspective.useNewMinMax(persp)) {
if (persp.getPresentation().getMaximizedStack() instanceof EditorStack)
persp.getPresentation().getMaximizedStack().
setState(IStackPresentationSite.STATE_RESTORED);
}
remove(workbook);
workbook.dispose();
}
}
/**
* @see IPersistablePart
*/
public IStatus restoreState(IMemento memento) {
MultiStatus result = new MultiStatus(
PlatformUI.PLUGIN_ID,
IStatus.OK,
WorkbenchMessages.RootLayoutContainer_problemsRestoringPerspective, null);
// Remove the default editor workbook that is
// initialy created with the editor area.
if (children != null) {
StartupThreading.runWithoutExceptions(new StartupRunnable() {
public void runWithException() throws Throwable {
EditorStack defaultWorkbook = null;
for (int i = 0; i < children.size(); i++) {
LayoutPart child = (LayoutPart) children.get(i);
if (child.getID() == DEFAULT_WORKBOOK_ID) {
defaultWorkbook = (EditorStack) child;
if (defaultWorkbook.getItemCount() > 0) {
defaultWorkbook = null;
}
}
}
if (defaultWorkbook != null) {
remove(defaultWorkbook);
}
}});
}
// Restore the relationship/layout
IMemento[] infos = memento.getChildren(IWorkbenchConstants.TAG_INFO);
final Map mapIDtoPart = new HashMap(infos.length);
for (int i = 0; i < infos.length; i++) {
// Get the info details.
IMemento childMem = infos[i];
final String partID = childMem.getString(IWorkbenchConstants.TAG_PART);
final String relativeID = childMem
.getString(IWorkbenchConstants.TAG_RELATIVE);
int relationship = 0;
int left = 0, right = 0;
float ratio = 0.5f;
if (relativeID != null) {
relationship = childMem.getInteger(
IWorkbenchConstants.TAG_RELATIONSHIP).intValue();
Float ratioFloat = childMem
.getFloat(IWorkbenchConstants.TAG_RATIO);
Integer leftInt = childMem
.getInteger(IWorkbenchConstants.TAG_RATIO_LEFT);
Integer rightInt = childMem
.getInteger(IWorkbenchConstants.TAG_RATIO_RIGHT);
if (leftInt != null && rightInt != null) {
left = leftInt.intValue();
right = rightInt.intValue();
} else if (ratioFloat != null) {
ratio = ratioFloat.floatValue();
}
}
final EditorStack workbook [] = new EditorStack[1];
StartupThreading.runWithoutExceptions(new StartupRunnable() {
public void runWithException() throws Throwable {
// Create the part.
workbook[0] = EditorStack.newEditorWorkbook(EditorSashContainer.this, page);
workbook[0].setID(partID);
// 1FUN70C: ITPUI:WIN - Shouldn't set Container when not active
workbook[0].setContainer(EditorSashContainer.this);
}});
IMemento workbookMemento = childMem
.getChild(IWorkbenchConstants.TAG_FOLDER);
if (workbookMemento != null) {
result.add(workbook[0].restoreState(workbookMemento));
}
final int myLeft = left, myRight = right, myRelationship = relationship;
final float myRatio = ratio;
StartupThreading.runWithoutExceptions(new StartupRunnable() {
public void runWithException() throws Throwable {
// Add the part to the layout
if (relativeID == null) {
add(workbook[0]);
} else {
LayoutPart refPart = (LayoutPart) mapIDtoPart.get(relativeID);
if (refPart != null) {
//$TODO pass in left and right
if (myLeft == 0 || myRight == 0) {
add(workbook[0], myRelationship, myRatio, refPart);
} else {
add(workbook[0], myRelationship, myLeft, myRight, refPart);
}
} else {
WorkbenchPlugin
.log("Unable to find part for ID: " + relativeID);//$NON-NLS-1$
}
}
}});
mapIDtoPart.put(partID, workbook[0]);
}
return result;
}
/**
* @see IPersistablePart
*/
public IStatus saveState(IMemento memento) {
RelationshipInfo[] relationships = computeRelation();
MultiStatus result = new MultiStatus(
PlatformUI.PLUGIN_ID,
IStatus.OK,
WorkbenchMessages.RootLayoutContainer_problemsSavingPerspective, null);
for (int i = 0; i < relationships.length; i++) {
// Save the relationship info ..
// private LayoutPart part;
// private int relationship;
// private float ratio;
// private LayoutPart relative;
RelationshipInfo info = relationships[i];
IMemento childMem = memento
.createChild(IWorkbenchConstants.TAG_INFO);
childMem.putString(IWorkbenchConstants.TAG_PART, info.part.getID());
EditorStack stack = (EditorStack) info.part;
if (stack != null) {
IMemento folderMem = childMem
.createChild(IWorkbenchConstants.TAG_FOLDER);
result.add(stack.saveState(folderMem));
}
if (info.relative != null) {
childMem.putString(IWorkbenchConstants.TAG_RELATIVE,
info.relative.getID());
childMem.putInteger(IWorkbenchConstants.TAG_RELATIONSHIP,
info.relationship);
childMem.putInteger(IWorkbenchConstants.TAG_RATIO_LEFT,
info.left);
childMem.putInteger(IWorkbenchConstants.TAG_RATIO_RIGHT,
info.right);
// Note: "ratio" is not used in newer versions of Eclipse, which use "left"
// and "right" (above) instead
childMem.putFloat(IWorkbenchConstants.TAG_RATIO, info
.getRatio());
}
}
return result;
}
/**
* Set the editor workbook which is active.
*/
public void setActiveWorkbook(EditorStack newWorkbook, boolean hasFocus) {
if (newWorkbook != null) {
if (newWorkbook.isDisposed()) {
return;
}
if (!editorWorkbooks.contains(newWorkbook)) {
return;
}
}
EditorStack oldWorkbook = activeEditorWorkbook;
activeEditorWorkbook = newWorkbook;
if (oldWorkbook != null && oldWorkbook != newWorkbook) {
oldWorkbook.setActive(StackPresentation.AS_INACTIVE);
}
if (newWorkbook != null) {
if (hasFocus) {
newWorkbook.setActive(StackPresentation.AS_ACTIVE_FOCUS);
} else {
newWorkbook.setActive(StackPresentation.AS_ACTIVE_NOFOCUS);
}
}
updateTabList();
}
/**
* Set the editor workbook which is active.
*/
public void setActiveWorkbookFromID(String id) {
for (int i = 0; i < editorWorkbooks.size(); i++) {
EditorStack workbook = (EditorStack) editorWorkbooks.get(i);
if (workbook.getID().equals(id)) {
setActiveWorkbook(workbook, false);
}
}
}
public EditorStack getWorkbookFromID(String id) {
for (int i = 0; i < editorWorkbooks.size(); i++) {
EditorStack workbook = (EditorStack) editorWorkbooks.get(i);
if (workbook.getID().equals(id)) {
return workbook;
}
}
return null;
}
/**
* Updates the editor area's tab list to include the active
* editor and its tab.
*/
public void updateTabList() {
Composite parent = getParent();
if (parent != null) { // parent may be null on startup
EditorStack wb = getActiveWorkbook();
if (wb == null) {
parent.setTabList(new Control[0]);
} else {
parent.setTabList(wb.getTabList());
}
}
}
/**
* @see org.eclipse.ui.internal.LayoutPart#createControl(org.eclipse.swt.widgets.Composite)
*/
public void createControl(Composite parent) {
super.createControl(parent);
//let the user drop files/editor input on the editor area
addDropSupport();
}
private void addDropSupport() {
if (dropTarget == null) {
WorkbenchWindowConfigurer winConfigurer = ((WorkbenchWindow) page
.getWorkbenchWindow()).getWindowConfigurer();
dropTarget = new DropTarget(getControl(), DND.DROP_DEFAULT
| DND.DROP_COPY | DND.DROP_LINK);
dropTarget.setTransfer(winConfigurer.getTransfers());
if (winConfigurer.getDropTargetListener() != null) {
dropTarget.addDropListener(winConfigurer
.getDropTargetListener());
}
}
}
/* package */DropTarget getDropTarget() {
return dropTarget;
}
/**
* @see org.eclipse.ui.internal.LayoutPart#getImportance()
*/
public boolean isCompressible() {
//Added for bug 19524
return true;
}
/* (non-Javadoc)
* @see org.eclipse.ui.internal.PartSashContainer#isStackType(org.eclipse.ui.internal.LayoutPart)
*/
public boolean isStackType(LayoutPart toTest) {
return (toTest instanceof EditorStack);
}
/* (non-Javadoc)
* @see org.eclipse.ui.internal.PartSashContainer#isPaneType(org.eclipse.ui.internal.LayoutPart)
*/
public boolean isPaneType(LayoutPart toTest) {
return (toTest instanceof EditorPane);
}
/* (non-Javadoc)
* @see org.eclipse.ui.internal.PartSashContainer#createStack(org.eclipse.ui.internal.LayoutPart)
*/
protected PartStack createStack() {
EditorStack newWorkbook = EditorStack.newEditorWorkbook(this, page);
return newWorkbook;
}
/* (non-Javadoc)
* @see org.eclipse.ui.internal.PartSashContainer#setVisiblePart(org.eclipse.ui.internal.ILayoutContainer, org.eclipse.ui.internal.LayoutPart)
*/
protected void setVisiblePart(ILayoutContainer container,
LayoutPart visiblePart) {
EditorStack refPart = (EditorStack) container;
refPart.becomeActiveWorkbook(true);
refPart.setSelection(visiblePart);
}
/* (non-Javadoc)
* @see org.eclipse.ui.internal.PartSashContainer#getVisiblePart(org.eclipse.ui.internal.ILayoutContainer)
*/
protected LayoutPart getVisiblePart(ILayoutContainer container) {
EditorStack refPart = (EditorStack) container;
return refPart.getSelection();
}
/* (non-Javadoc)
* @see org.eclipse.ui.internal.PartSashContainer#pickPartToZoom()
*/
public LayoutPart pickPartToZoom() {
return getActiveWorkbook();
}
/**
* Restore the presentation state. Loop over the workbooks, create the appropriate serializer and pass to the presentation.
*
* @param areaMem the memento containing presentation
* @return the restoration status
*/
public IStatus restorePresentationState(IMemento areaMem) {
for (Iterator i = getEditorWorkbooks().iterator(); i.hasNext();) {
final EditorStack workbook = (EditorStack) i.next();
final IMemento memento = workbook.getSavedPresentationState();
if (memento == null) {
continue;
}
final PresentationSerializer serializer = new PresentationSerializer(
workbook.getPresentableParts());
StartupThreading.runWithoutExceptions(new StartupRunnable(){
public void runWithException() throws Throwable {
workbook.getPresentation().restoreState(serializer, memento);
}});
}
return new Status(IStatus.OK, PlatformUI.PLUGIN_ID, 0, "", null); //$NON-NLS-1$
}
}