/*******************************************************************************
* Copyright (c) 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.List;
import java.util.Map;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.jface.util.Geometry;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IPerspectiveListener2;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.internal.StartupThreading.StartupRunnable;
import org.eclipse.ui.internal.layout.IWindowTrim;
import org.eclipse.ui.internal.layout.LayoutUtil;
import org.eclipse.ui.internal.layout.TrimLayout;
import org.eclipse.ui.internal.presentations.PresentablePart;
import org.eclipse.ui.internal.presentations.util.TabbedStackPresentation;
import org.eclipse.ui.internal.tweaklets.Animations;
import org.eclipse.ui.internal.tweaklets.Tweaklets;
import org.eclipse.ui.internal.util.Util;
import org.eclipse.ui.presentations.IPresentablePart;
import org.eclipse.ui.presentations.IStackPresentationSite;
/**
* Manage all Fast views for a particular perspective. As of 3.3 fast views
* appear in more than one manner (legacy FVB and Trim Stacks). The manager is
* responsible for providing a single implementation for the methods relating to
* fast views regardless of their UI presentation.
*
* @since 3.3
*
*/
public class FastViewManager {
private Perspective perspective;
private WorkbenchPage page;
private WorkbenchWindow wbw;
private TrimLayout tbm;
/**
* Maps a String to a list of IViewReferences. The string represents the
* 'id' of either the legacy FBV or the ViewStack id of some stack which may
* have elements in the trim.
* <p>
* NOTE: For TrimStacks, the order of the view ref's in the contained list
* is the order in which they will appear in the tab folder when the stack
* un-minimizes.
* </p>
*/
private Map idToFastViewsMap = new HashMap();
/**
* Batch update management
*/
private boolean deferringUpdates = false;
/**
* animation whose life-cycle spans a
* 'deferUpdates' cycle.
*/
private AnimationEngine batchAnimation = null;
/**
* Used for non-deferred animations
*/
private AnimationEngine oneShotAnimation = null;
//private RectangleAnimation oneShotAnimation = null;
private IPerspectiveListener2 perspListener = new IPerspectiveListener2() {
public void perspectiveActivated(IWorkbenchPage page,
IPerspectiveDescriptor perspective) {
// Only listen for changes in -this- perspective
if (FastViewManager.this.perspective.getDesc() == perspective)
handlePerspectiveActivation(page, perspective);
}
public void perspectiveChanged(IWorkbenchPage changedPage,
IPerspectiveDescriptor perspective,
IWorkbenchPartReference partRef, String changeId) {
// Only listen for changes in -this- perspective
if (FastViewManager.this.perspective.getDesc() == perspective)
handlePerspectiveChange(changedPage, perspective, partRef,
changeId);
}
public void perspectiveChanged(IWorkbenchPage changedPage,
IPerspectiveDescriptor perspective, String changeId) {
// Only listen for changes in -this- perspective
if (FastViewManager.this.perspective.getDesc() == perspective)
handlePerspectiveChange(changedPage, perspective, changeId);
}
};
/**
* Creates a new manager for a particular perspective
*
* @param perspective
* @param page
*/
public FastViewManager(Perspective perspective, WorkbenchPage page) {
this.perspective = perspective;
this.page = page;
// Access the trim manager for this window
wbw = (WorkbenchWindow) page.getWorkbenchWindow();
tbm = (TrimLayout) wbw.getTrimManager();
}
protected void handlePerspectiveActivation(IWorkbenchPage activatingPage,
IPerspectiveDescriptor activatingPerspective) {
// If this perspective is activating then update the
// legacy FVB to show this perspective's refs
if (activatingPage == page
&& perspective.getDesc() == activatingPerspective)
updateTrim(FastViewBar.FASTVIEWBAR_ID);
}
protected void handlePerspectiveChange(IWorkbenchPage changedPage,
IPerspectiveDescriptor changedPerspective,
IWorkbenchPartReference partRef, String changeId) {
// Only handle changes for our perspective
if (changedPage != page && perspective.getDesc() != changedPerspective)
return;
if (changeId.equals(IWorkbenchPage.CHANGE_VIEW_HIDE)) {
if (partRef instanceof IViewReference) {
ViewReference ref = (ViewReference) partRef;
if (ref.getPane().getContainer() instanceof ViewStack) {
int viewCount = 0;
LayoutPart[] children = ref.getPane().getContainer().getChildren();
for (int i = 0; i < children.length; i++) {
if (children[i] instanceof ViewPane && children[i] != ref.getPane())
viewCount++;
}
if (viewCount == 0)
ref.getPane().getStack().setState(IStackPresentationSite.STATE_RESTORED);
}
}
// Remove the view from any FV list that it may be in
// Do this here since the view's controls may be about
// to be disposed...
removeViewReference((IViewReference) partRef, false, true);
}
if (changeId.equals(IWorkbenchPage.CHANGE_FAST_VIEW_REMOVE)) {
// Remove the view from any FV list that it may be in
// Do this here since the view's controls may be about
// to be disposed...
removeViewReference((IViewReference) partRef, false, true);
}
}
protected void handlePerspectiveChange(IWorkbenchPage changedPage,
IPerspectiveDescriptor changedPerspective, String changeId) {
}
/**
* @return The list of current fast views associated with the given id or
* the complete list of fastviews if the id == null.
*/
public List getFastViews(String forId) {
List fvs = new ArrayList();
Iterator mapIter = idToFastViewsMap.keySet().iterator();
while (mapIter.hasNext()) {
String id = (String) mapIter.next();
if (forId == null || forId.equals(id)) {
List fvList = (List) idToFastViewsMap.get(id);
for (Iterator fvIter = fvList.iterator(); fvIter.hasNext();) {
fvs.add(fvIter.next());
}
}
}
return fvs;
}
/**
* Casues the given {@link IViewReference} to be added to the list
* identified by the 'id' parameter. The reference is added at the specified
* index or at the end if the index is -1. If there was a previous entry for
* this ref it will be removed so that only the ref will only ever be in one
* list at a time.
* <p>
* NOTE: The trim life-cycle is managed at the stack level so there -must-
* be an entry in the map and a corresponding trim element before calling
* this method,
* </p>
* <p>
* The page/perspective are updated to make the view a fastview if
* necessary.
* </p>
*
* @param id
* The id of the {@link IWindowTrim} that is to show the ref
* @param index
* The index to insert the ref at
* @param ref
* The {@link IViewReference} to add
* @param update
* cause the trim to update if <code>true</code>
*/
public void addViewReference(String id, int index, IViewReference ref,
boolean update) {
if (id == null || ref == null)
return;
List fvList = (List) idToFastViewsMap.get(id);
if (fvList == null) {
// Not in the model yet, add it
fvList = new ArrayList();
idToFastViewsMap.put(id, fvList);
}
// bounds checking
if (index < 0 || index > fvList.size())
index = fvList.size();
// Is it already in a list?
String curLocation = getIdForRef(ref);
if (curLocation != null) {
// is it the same list that it's being added to?
if (id.equals(curLocation)) {
int curIndex = fvList.indexOf(ref);
if (index == curIndex)
return; // No-Op
// If we're inserting after where we
// were then decrement the index to
// account for the removal of the old ref
if (index > curIndex)
index--;
}
// Remove it...
removeViewReference(ref, false, true);
} else {
// It's not a fastview, make it one
makeFast(ref, true, false);
}
fvList.add(index, ref);
// Note that the update call will create and show the ViewStackTrimToolbar
// if necessary
if (update)
updateTrim(id);
}
/**
* Create the Trim element for the stack containing the given reference
*
* @param suggestedSide
* @param paneOrientation
* @param ref
* The {@link IViewReference} whose stack needs trim creation.
*/
private ViewStackTrimToolBar getTrimForViewStack(String id,
int suggestedSide, int paneOrientation) {
// Do we already have one??
ViewStackTrimToolBar trim = (ViewStackTrimToolBar) tbm.getTrim(id);
if (trim == null) {
int cachedSide = tbm.getPreferredArea(id);
if (cachedSide != -1)
suggestedSide = cachedSide;
IWindowTrim beforeMe = tbm.getPreferredLocation(id);
trim = new ViewStackTrimToolBar(id, suggestedSide,
paneOrientation, wbw);
tbm.addTrim(suggestedSide, trim, beforeMe);
updateTrim(trim.getId());
}
return trim;
}
/**
* Causes the trim element associated with the id to synch itself with the
* current list of views. This method will create a new ViewStackTrimToolbar
* if necessary (i.e. on the first call after views have been added to the map)
* and will also hide the trim element when the number of views in the mapped
* list goes to zero.
*
* @param id
* The id of the {@link IWindowTrim} to update
*/
private void updateTrim(String id) {
// Get the trim part from the trim manager
IWindowTrim trim = tbm.getTrim(id);
// If it's not there there's not much we can do
if (trim == null)
return;
// If there are no fast views for the bar then hide it
List fvs = (List) idToFastViewsMap.get(id);
if (fvs != null && fvs.size() == 0
&& !FastViewBar.FASTVIEWBAR_ID.equals(id)) {
if (trim.getControl().getVisible()) {
tbm.setTrimVisible(trim, false);
tbm.forceLayout();
}
return;
}
// Ensure that the trim is displayed
if (!trim.getControl().getVisible()) {
tbm.setTrimVisible(trim, true);
}
if (trim instanceof FastViewBar) {
FastViewBar fvb = (FastViewBar) trim;
fvb.update(true);
} else if (trim instanceof ViewStackTrimToolBar) {
ViewStackTrimToolBar vstb = (ViewStackTrimToolBar) trim;
vstb.update(true);
vstb.getControl().pack();
LayoutUtil.resize(trim.getControl());
}
tbm.forceLayout();
}
/**
* Remove the view reference from its existing location
*
* @param ref
* The {@link IViewReference} to remove
*/
public void removeViewReference(IViewReference ref, boolean makeUnfast, boolean update) {
String id = getIdForRef(ref);
if (id != null) {
// Remove the ref
List fvList = (List) idToFastViewsMap.get(id);
fvList.remove(ref);
if (makeUnfast)
makeFast(ref, false, false);
if (update)
updateTrim(id);
}
}
/**
*
* @param ref
* @param makeFast
* @param activate
*/
private void makeFast(IViewReference ref, boolean makeFast, boolean activate) {
if (ref == null || page == null)
return;
if (makeFast) {
page.makeFastView(ref);
} else {
page.removeFastView(ref);
if (activate) {
IWorkbenchPart toActivate = ref.getPart(true);
if (toActivate != null) {
page.activate(toActivate);
}
}
}
}
/**
* @param ref
* The IViewRference to check
* @return true iff the ref is in -any- list
*/
boolean isFastView(IViewReference ref) {
return getIdForRef(ref) != null;
}
/**
* @param ref
* The IViewRference to check
* @return The id of the trim bar currently showing the reference or
* <code>null</code> if it's not in any list
*/
public String getIdForRef(IViewReference ref) {
Iterator mapIter = idToFastViewsMap.keySet().iterator();
while (mapIter.hasNext()) {
String id = (String) mapIter.next();
List fvList = (List) idToFastViewsMap.get(id);
if (fvList.contains(ref))
return id;
}
return null;
}
/**
* @return The side that the fast view pane should be attached to based on
* the position of the trim element containing the ref.
*/
public int getViewSide(IViewReference ref) {
IWindowTrim trim = getTrimForRef(ref);
if (trim == null)
return SWT.BOTTOM;
int curSide = SWT.BOTTOM;
int paneOrientation = SWT.BOTTOM;
if (trim instanceof ViewStackTrimToolBar) {
curSide = ((ViewStackTrimToolBar) trim).getCurrentSide();
paneOrientation = ((ViewStackTrimToolBar) trim)
.getPaneOrientation();
} else if (trim instanceof FastViewBar) {
curSide = ((FastViewBar) trim).getSide();
paneOrientation = ((FastViewBar) trim).getOrientation(ref);
}
// Get trim layout info
Point trimCenter = Geometry.centerPoint(trim.getControl().getBounds());
Point shellCenter = Geometry.centerPoint(trim.getControl().getShell()
.getClientArea());
// Horizontal has to snap to either TOP or BOTTOM...
if (paneOrientation == SWT.HORIZONTAL) {
if (curSide == SWT.TOP || curSide == SWT.BOTTOM)
return curSide;
// Are we on the top or bottom 'end' of the trim area?
return (trimCenter.y < shellCenter.y) ? SWT.TOP : SWT.BOTTOM;
}
if (paneOrientation == SWT.VERTICAL) {
if (curSide == SWT.LEFT || curSide == SWT.RIGHT)
return curSide;
// Are we on the left or right 'end' of the trim area?
return (trimCenter.x < shellCenter.x) ? SWT.LEFT : SWT.RIGHT;
}
return SWT.BOTTOM;
}
/**
* Return the trim element showing the given reference
*
* @param ref
* The reference to find
* @return the IWindowTrim showing the ref
*/
private IWindowTrim getTrimForRef(IViewReference ref) {
String id = getIdForRef(ref);
if (id == null)
return null; // Not in trim
return tbm.getTrim(id);
}
/**
* @return a List of <code>IViewReference</code> sorted into the order in
* which they appear in the visual stack.
*/
private List getTrueViewOrder(ViewStack stack) {
List orderedViews = new ArrayList();
IPresentablePart[] parts = null;
if (stack.getPresentation() instanceof TabbedStackPresentation) {
TabbedStackPresentation tsp = (TabbedStackPresentation) stack
.getPresentation();
// KLUDGE!! uses a 'testing only' API to get the parts in their 'visible' order
parts = tsp.getPartList();
}
// If we didn't get the parts from the tab list then try the presentable part API
// ViewStack's declared 'no title' fail the call above, returning an empty array
if (parts == null || parts.length == 0){
// We'll have to process the parts in the order given...
// This is certain to fail on drag re-ordering of the
// icons in the trim since we have no API to inform the
// custom presentation
List partList = stack.getPresentableParts();
parts = (IPresentablePart[]) partList.toArray(new IPresentablePart[partList.size()]);
}
// Now, process the parts...
for (int i = 0; i < parts.length; i++) {
if (parts[i] instanceof PresentablePart) {
PresentablePart part = (PresentablePart) parts[i];
IWorkbenchPartReference ref = part.getPane()
.getPartReference();
if (ref instanceof IViewReference)
orderedViews.add(ref);
}
}
return orderedViews;
}
public void moveToTrim(ViewStack vs, boolean restoreOnUnzoom) {
// Don't do anything when initializing...
if (vs.getBounds().width == 0)
return; // indicates that we're startin up
// If we're part of a 'maximize' operation then use the cached
// bounds...
Rectangle stackBounds = perspective.getPresentation().getCachedBoundsFor(vs.getID());
// OK, no cache means that we use the current stack position
if (stackBounds == null)
stackBounds = vs.getBounds();
int paneOrientation = (stackBounds.width > stackBounds.height) ? SWT.HORIZONTAL
: SWT.VERTICAL;
// Remember the tab that was selected when we minimized
String selId = ""; //$NON-NLS-1$
PartPane selectedTab = vs.getSelection();
if (selectedTab != null)
selId = selectedTab.getCompoundId();
vs.deferUpdates(true);
// animate the minimize
RectangleAnimationFeedbackBase animation = (RectangleAnimationFeedbackBase) getDeferrableAnimation().getFeedback();
animation.addStartRect(vs.getControl());
//long startTick = System.currentTimeMillis();
// Update the model first
List toMove = getTrueViewOrder(vs);
for (Iterator viewIter = toMove.iterator(); viewIter.hasNext();) {
IViewReference ref = (IViewReference) viewIter.next();
addViewReference(vs.getID(), -1, ref, false);
}
vs.deferUpdates(false);
// Find (or create) the trim stack to move to
ViewStackTrimToolBar vstb = getTrimForViewStack(vs.getID(), perspective
.calcStackSide(stackBounds), paneOrientation);
vstb.setRestoreOnUnzoom(restoreOnUnzoom);
vstb.setSelectedTabId(selId);
updateTrim(vstb.getId());
//System.out.println("minimize time: " + (System.currentTimeMillis()-startTick)); //$NON-NLS-1$
if (vstb != null) {
animation.addEndRect(vstb.getControl());
scheduleDeferrableAnimation();
}
}
/**
* Restore the trim element representing a ViewStack back into the
* presentation.
*
* @param viewStackTrimToolBar
* The trim version to restore
*/
public void restoreToPresentation(String id) {
ViewStackTrimToolBar vstb = getViewStackTrimToolbar(id);
// The IntroPart uses the old min/max behavior; ensure that
// we were really a minimized trim stack
if (vstb == null)
return;
// remove any showing fast view
page.hideFastView();
// The stored id may be 'compound' if it's a multi-instance
// view; split out the secondary id (if any)
String selectedTabId = vstb.getSelectedTabId();
String[] idParts = Util.split(selectedTabId, ':');
if (idParts[0].length() == selectedTabId.length())
idParts[1] = null;
List fvs = getFastViews(id);
for (Iterator fvIter = fvs.iterator(); fvIter.hasNext();) {
IViewReference ref = (IViewReference) fvIter.next();
removeViewReference(ref, true, !fvIter.hasNext());
}
// Restore the correct tab to the 'top'
LayoutPart stack = perspective.getPresentation().findPart(id, null);
if (stack instanceof PartStack) {
LayoutPart selTab = perspective.getPresentation().findPart(idParts[0], idParts[1]);
if (selTab instanceof PartPane && selTab instanceof ViewPane) {
((PartStack)stack).setSelection(selTab);
// activate the view if we're not doing a compound operation
if (!deferringUpdates)
((ViewPane)selTab).requestActivation();
}
}
// Hide the Trim
updateTrim(id);
}
/**
* Restore all fact view stacks created as part of a zoom
*/
public void restoreZoomedViewStacks() {
Iterator mapIter = idToFastViewsMap.keySet().iterator();
while (mapIter.hasNext()) {
String id = (String) mapIter.next();
IWindowTrim trim = tbm.getTrim(id);
if (trim != null && trim instanceof ViewStackTrimToolBar) {
ViewStackTrimToolBar vstb = (ViewStackTrimToolBar) trim;
if (vstb.restoreOnUnzoom())
restoreToPresentation(vstb.getId());
}
}
}
/**
* @param ref
* Sets the ref of the icon
* @param selected
* the selection state of the icon
*/
public void setFastViewIconSelection(IViewReference ref, boolean selected) {
String id = getIdForRef(ref);
IWindowTrim trim = tbm.getTrim(id);
if (trim instanceof ViewStackTrimToolBar) {
ViewStackTrimToolBar vstb = (ViewStackTrimToolBar) trim;
vstb.setIconSelection(ref, selected);
} else if (trim instanceof FastViewBar) {
FastViewBar fvb = (FastViewBar) trim;
if (selected) {
fvb.setSelection(ref);
} else {
if (ref == fvb.getSelection()) {
fvb.setSelection(null);
}
}
}
}
/**
* Activate the manager. Called from the Perspecive's 'onActivate'
*/
public void activate() {
wbw.addPerspectiveListener(perspListener);
setTrimStackVisibility(true);
}
/**
* Activate the manager. Called from the Perspecive's 'onActivate'
*/
public void deActivate() {
wbw.removePerspectiveListener(perspListener);
setTrimStackVisibility(false);
}
/**
* Restore any trim stacks. This method is used when the presentation
* is switched back to 3.0; if we aren't using the new min/max story
* then we shouldn't -have- any trim stacks.
*/
public boolean restoreAllTrimStacks() {
boolean stacksWereRestored = false;
Iterator mapIter = idToFastViewsMap.keySet().iterator();
while (mapIter.hasNext()) {
String id = (String) mapIter.next();
// Skip the legacy FstViewBar
if (id.equals(FastViewBar.FASTVIEWBAR_ID))
continue;
// Restore the views
List fvs = getFastViews(id);
for (Iterator fvIter = fvs.iterator(); fvIter.hasNext();) {
IViewReference ref = (IViewReference) fvIter.next();
removeViewReference(ref, true, !fvIter.hasNext());
}
// Blow the trim away
IWindowTrim trim = tbm.getTrim(id);
if (trim != null && trim instanceof ViewStackTrimToolBar) {
tbm.removeTrim(trim);
trim.getControl().dispose();
stacksWereRestored = true;
}
}
tbm.forceLayout();
return stacksWereRestored;
}
/**
* Show all non-empty trim stacks. Create the stack if necessary
*/
private void setTrimStackVisibility(boolean visible) {
Iterator mapIter = idToFastViewsMap.keySet().iterator();
while (mapIter.hasNext()) {
String id = (String) mapIter.next();
List fvs = getFastViews(id);
// Never show 'empty' stacks
if (visible && fvs.size() == 0)
continue;
IWindowTrim trim = tbm.getTrim(id);
if (trim != null && trim instanceof ViewStackTrimToolBar) {
((ViewStackTrimToolBar)trim).update(true);
tbm.setTrimVisible(trim, visible);
}
}
}
public void saveState(IMemento memento) {
// Output legacy fastviews
FastViewBar fvb = wbw.getFastViewBar();
if (fvb != null) {
List fvRefs = getFastViews(FastViewBar.FASTVIEWBAR_ID);
if (fvRefs.size() > 0) {
IMemento childMem = memento
.createChild(IWorkbenchConstants.TAG_FAST_VIEWS);
Iterator itr = fvRefs.iterator();
while (itr.hasNext()) {
IViewReference ref = (IViewReference) itr.next();
IMemento viewMemento = childMem
.createChild(IWorkbenchConstants.TAG_VIEW);
String id = ViewFactory.getKey(ref);
viewMemento.putString(IWorkbenchConstants.TAG_ID, id);
float ratio = perspective.getFastViewWidthRatio(ref);
viewMemento.putFloat(IWorkbenchConstants.TAG_RATIO, ratio);
}
}
}
// Write all the current (non-empty) bars
IMemento barsMemento = memento
.createChild(IWorkbenchConstants.TAG_FAST_VIEW_BARS);
Iterator mapIter = idToFastViewsMap.keySet().iterator();
while (mapIter.hasNext()) {
String id = (String) mapIter.next();
// Legacy FV's are stored above...
if (FastViewBar.FASTVIEWBAR_ID.equals(id))
continue;
List fvs = getFastViews(id);
if (fvs.size() > 0) {
IMemento barMemento = barsMemento
.createChild(IWorkbenchConstants.TAG_FAST_VIEW_BAR);
barMemento.putString(IWorkbenchConstants.TAG_ID, id);
// Orientation / restore
ViewStackTrimToolBar vstb = (ViewStackTrimToolBar) tbm
.getTrim(id);
if (vstb != null) {
barMemento.putInteger(
IWorkbenchConstants.TAG_FAST_VIEW_SIDE,
vstb.getCurrentSide());
barMemento.putInteger(
IWorkbenchConstants.TAG_FAST_VIEW_ORIENTATION,
vstb.getPaneOrientation());
int boolVal = vstb.restoreOnUnzoom() ? 1 : 0;
barMemento.putInteger(IWorkbenchConstants.TAG_FAST_VIEW_STYLE, boolVal);
barMemento.putString(IWorkbenchConstants.TAG_FAST_VIEW_SEL_ID, vstb.getSelectedTabId());
}
IMemento viewsMem = barMemento
.createChild(IWorkbenchConstants.TAG_FAST_VIEWS);
Iterator itr = fvs.iterator();
while (itr.hasNext()) {
IMemento refMem = viewsMem
.createChild(IWorkbenchConstants.TAG_VIEW);
IViewReference ref = (IViewReference) itr.next();
// id
String viewId = ViewFactory.getKey(ref);
refMem.putString(IWorkbenchConstants.TAG_ID, viewId);
// width ratio
float ratio = perspective.getFastViewWidthRatio(ref);
refMem.putFloat(IWorkbenchConstants.TAG_RATIO, ratio);
}
}
}
}
public void restoreState(IMemento memento, MultiStatus result) {
// Load the fast views
IMemento fastViewsMem = memento
.getChild(IWorkbenchConstants.TAG_FAST_VIEWS);
// -Replace- the current list with the one from the store
List refsList = new ArrayList();
idToFastViewsMap.put(FastViewBar.FASTVIEWBAR_ID, refsList);
if (fastViewsMem != null) {
IMemento[] views = fastViewsMem
.getChildren(IWorkbenchConstants.TAG_VIEW);
for (int x = 0; x < views.length; x++) {
// Get the view details.
IMemento childMem = views[x];
IViewReference ref = perspective.restoreFastView(childMem,
result);
if (ref != null)
refsList.add(ref);
}
}
// Load the Trim Stack info
IMemento barsMem = memento
.getChild(IWorkbenchConstants.TAG_FAST_VIEW_BARS);
// It's not there for old workspaces
if (barsMem == null)
return;
IMemento[] bars = barsMem
.getChildren(IWorkbenchConstants.TAG_FAST_VIEW_BAR);
for (int i = 0; i < bars.length; i++) {
final String id = bars[i].getString(IWorkbenchConstants.TAG_ID);
fastViewsMem = bars[i].getChild(IWorkbenchConstants.TAG_FAST_VIEWS);
// -Replace- the current list with the one from the store
refsList = new ArrayList();
idToFastViewsMap.put(id, refsList);
if (fastViewsMem != null) {
IMemento[] views = fastViewsMem
.getChildren(IWorkbenchConstants.TAG_VIEW);
result.merge(perspective.createReferences(views));
// Create the trim area for the trim stack
// Only create the TB if there are views in it
if (views.length > 0) {
final int side = bars[i].getInteger(
IWorkbenchConstants.TAG_FAST_VIEW_SIDE)
.intValue();
final int orientation = bars[i].getInteger(
IWorkbenchConstants.TAG_FAST_VIEW_ORIENTATION)
.intValue();
int boolVal = bars[i].getInteger(
IWorkbenchConstants.TAG_FAST_VIEW_STYLE).intValue();
final boolean restoreOnUnzoom = (boolVal > 0);
final String selId = bars[i].getString(IWorkbenchConstants.TAG_FAST_VIEW_SEL_ID);
// Create the stack
StartupThreading.runWithoutExceptions(new StartupRunnable() {
public void runWithException() throws Throwable {
ViewStackTrimToolBar vstb = getTrimForViewStack(id, side, orientation);
vstb.setRestoreOnUnzoom(restoreOnUnzoom);
if (selId != null)
vstb.setSelectedTabId(selId);
}
});
}
for (int x = 0; x < views.length; x++) {
// Get the view details.
IMemento childMem = views[x];
IViewReference ref = perspective.restoreFastView(childMem,
result);
if (ref != null)
refsList.add(ref);
}
}
}
}
/**
* Returns the trim element for the given id if it exists. This
* will not be <code>null</code> if there are entries in the
* 'idToFastViewsMap' for this id.
*
* @param id The id of the view stack to get the trim toolbar for.
*/
public ViewStackTrimToolBar getViewStackTrimToolbar(String id) {
return (ViewStackTrimToolBar) tbm.getTrim(id);
}
public void printFVModel() {
Iterator mapIter = idToFastViewsMap.keySet().iterator();
while (mapIter.hasNext()) {
String id = (String) mapIter.next();
List fvList = (List) idToFastViewsMap.get(id);
System.out.println("FastView: " + id + " count = " + fvList.size()); //$NON-NLS-1$//$NON-NLS-2$
for (Iterator fvIter = fvList.iterator(); fvIter.hasNext();) {
IViewReference ref = (IViewReference) fvIter.next();
System.out.println(" Ref: " + ref.getId()); //$NON-NLS-1$
}
}
}
/**
* Informs the manager that a batch operation has started
* (say 'maximize', where many stacks will change state).
*
* @param defer
* true when starting a batch operation
* false when ending the operation
*/
public void deferUpdates(boolean defer) {
if (defer && !deferringUpdates) {
deferringUpdates = defer;
deferAnimations(true);
return;
}
// 'false': reset and run any necessary updates
deferringUpdates = false;
deferAnimations(false);
}
/**
* When 'defer' is true we create a RectangleAnimation object
* to be used for any desired feedback. When ending it
* schedules the animation and resets.
*
* @param defer
* true when starting a batch operation
* false when ending the operation
*/
private void deferAnimations(boolean defer) {
if (defer) {
RectangleAnimationFeedbackBase feedback = ((Animations) Tweaklets
.get(Animations.KEY)).createFeedback(wbw.getShell());
batchAnimation = new AnimationEngine(feedback, 400);
return;
}
if (batchAnimation != null)
batchAnimation.schedule();
batchAnimation = null;
}
/**
* Returns the animation object appropriate for the deferred state
* @return Either a 'one-shot' or a 'batch' animation object
*/
private AnimationEngine getDeferrableAnimation() {
if (deferringUpdates)
return batchAnimation;
// Create a 'one-shot' animation
RectangleAnimationFeedbackBase feedback = ((Animations) Tweaklets
.get(Animations.KEY)).createFeedback(wbw.getShell());
oneShotAnimation = new AnimationEngine(feedback, 400);
return oneShotAnimation;
}
private void scheduleDeferrableAnimation() {
if (deferringUpdates)
return;
// We can only schedule the 'one-shot' animations
// the batch ones are sheduled at batch end
if (oneShotAnimation != null)
oneShotAnimation.schedule();
oneShotAnimation = null;
}
/**
* Returns the 'bottom/right' trim stack. This is used to
* match the old behavior when opening a new view that has no placeholder
* in the case where there WB is maximized.
*
* @return The 'bottom/right' trim stack or null if there are no
* defined trim stacks
*/
public ViewStackTrimToolBar getBottomRightTrimStack() {
ViewStackTrimToolBar blTrimStack = null;
Point blPt = new Point(0,0);
Iterator mapIter = idToFastViewsMap.keySet().iterator();
while (mapIter.hasNext()) {
String id = (String) mapIter.next();
// Skip the legacy FstViewBar
if (id.equals(FastViewBar.FASTVIEWBAR_ID))
continue;
if (getFastViews(id).size() > 0) {
// if we have views in the model then 'vstt' will not be null
ViewStackTrimToolBar vstt = getViewStackTrimToolbar(id);
Point loc = vstt.getControl().getLocation();
if (loc.y > blPt.y || (loc.y == blPt.y && loc.x > blPt.x)) {
blPt = loc;
blTrimStack = vstt;
}
}
}
return blTrimStack;
}
}